svn merge ^/branches/released .

213 files changed, 44463 insertions, 44002 deletions

diff --git a/xorg-server/hw/dmx/config/dmxparse.c b/xorg-server/hw/dmx/config/dmxparse.c
index 28a1835af..f75151eac 100644
--- a/xorg-server/hw/dmx/config/dmxparse.c
+++ b/xorg-server/hw/dmx/config/dmxparse.c
@@ -1,607 +1,607 @@
-/*
- * Copyright 2002 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- *
- * This file provides support routines and helper functions to be used
- * by the DMX configuration file parser.
- *
- * Because the DMX configuration file parsing should be capable of being
- * used in a stand-alone fashion (i.e., independent from the DMX server
- * source tree), no dependencies on other DMX routines are made. */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include "dmxparse.h"
-
-/** A general error logging routine that does not depend on the dmxLog
- * functions. */
-void dmxConfigLog(const char *format, ...)
-{
-    va_list args;
-    
-    va_start(args, format);
-    vprintf(format, args);      /* RATS: All calls to dmxConfigLog from
-                                 * dmxparse.c and dmxprint.c use a
-                                 * trusted format. */
-    va_end(args);
-}
-
-void *dmxConfigAlloc(unsigned long bytes)
-{
-    void *area = calloc(1, bytes);
-    if (!area) {
-        dmxConfigLog("dmxConfigAlloc: out of memory\n");
-        return NULL;
-    }
-    return area;
-}
-
-void *dmxConfigRealloc(void *orig, unsigned long orig_bytes,
-                       unsigned long bytes)
-{
-    unsigned char *area = realloc(orig, bytes);
-    if (!area) {
-        dmxConfigLog("dmxConfigRealloc: out of memory\n");
-        return NULL;
-    }
-    memset(area + orig_bytes, 0, bytes - orig_bytes);
-    return area;
-}
-
-const char *dmxConfigCopyString(const char *string, int length)
-{
-    char *copy;
-    
-    if (!length) length = strlen(string);
-    copy = dmxConfigAlloc(length + 1);
-    if (length) strncpy(copy, string, length);
-    copy[length] = '\0';
-    return copy;
-}
-
-void dmxConfigFree(void *area)
-{
-    if (area) free(area);
-}
-
-DMXConfigTokenPtr dmxConfigCreateToken(int token, int line,
-                                       const char *comment)
-{
-    DMXConfigTokenPtr pToken = dmxConfigAlloc(sizeof(*pToken));
-    pToken->token   = token;
-    pToken->line    = line;
-    pToken->comment = comment;
-    return pToken;
-}
-
-void dmxConfigFreeToken(DMXConfigTokenPtr p)
-{
-    if (!p) return;
-    dmxConfigFree((void *)p->comment);
-    dmxConfigFree(p);
-}
-
-DMXConfigStringPtr dmxConfigCreateString(int token, int line,
-                                         const char *comment,
-                                         const char *string)
-{
-    DMXConfigStringPtr pString = dmxConfigAlloc(sizeof(*pString));
-
-    pString->token   = token;
-    pString->line    = line;
-    pString->comment = comment;
-    pString->string  = string;
-    return pString;
-}
-
-void dmxConfigFreeString(DMXConfigStringPtr p)
-{
-    DMXConfigStringPtr next;
-
-    if (!p) return;
-    do {
-        next = p->next;
-        dmxConfigFree((void *)p->comment);
-        dmxConfigFree((void *)p->string);
-        dmxConfigFree(p);
-    } while ((p = next));
-}
- 
-DMXConfigNumberPtr dmxConfigCreateNumber(int token, int line,
-                                         const char *comment,
-                                         int number)
-{
-    DMXConfigNumberPtr pNumber = dmxConfigAlloc(sizeof(*pNumber));
-
-    pNumber->token   = token;
-    pNumber->line    = line;
-    pNumber->comment = comment;
-    pNumber->number  = number;
-    return pNumber;
-}
-
-void dmxConfigFreeNumber(DMXConfigNumberPtr p)
-{
-    if (!p) return;
-    dmxConfigFree((void *)p->comment);
-    dmxConfigFree(p);
-}
-
-DMXConfigPairPtr dmxConfigCreatePair(int token, int line,
-                                     const char *comment,
-                                     int x, int y,
-                                     int xsign, int ysign)
-{
-    DMXConfigPairPtr pPair = dmxConfigAlloc(sizeof(*pPair));
-
-    pPair->token   = token;
-    pPair->line    = line;
-    pPair->comment = comment;
-    pPair->x       = x;
-    pPair->y       = y;
-    pPair->xsign   = (xsign < 0) ? -1 : 1;
-    pPair->ysign   = (ysign < 0) ? -1 : 1;
-    return pPair;
-}
-
-void dmxConfigFreePair(DMXConfigPairPtr p)
-{
-    if (!p) return;
-    dmxConfigFree((void *)p->comment);
-    dmxConfigFree(p);
-}
-
-DMXConfigCommentPtr dmxConfigCreateComment(int token, int line,
-                                           const char *comment)
-{
-    DMXConfigCommentPtr pComment = dmxConfigAlloc(sizeof(*pComment));
-
-    pComment->token   = token;
-    pComment->line    = line;
-    pComment->comment = comment;
-    return pComment;
-}
-
-void dmxConfigFreeComment(DMXConfigCommentPtr p)
-{
-    if (!p) return;
-    dmxConfigFree((void *)p->comment);
-    dmxConfigFree(p);
-}
-
-DMXConfigPartDimPtr dmxConfigCreatePartDim(DMXConfigPairPtr pDim,
-                                           DMXConfigPairPtr pOffset)
-{
-    DMXConfigPartDimPtr pPart = dmxConfigAlloc(sizeof(*pPart));
-    pPart->dim    = pDim;
-    pPart->offset = pOffset;
-    return pPart;
-}
-
-void dmxConfigFreePartDim(DMXConfigPartDimPtr p)
-{
-    if (!p) return;
-    dmxConfigFreePair(p->dim);
-    dmxConfigFreePair(p->offset);
-    dmxConfigFree(p);
-}
-
-DMXConfigFullDimPtr dmxConfigCreateFullDim(DMXConfigPartDimPtr pScrn,
-                                           DMXConfigPartDimPtr pRoot)
-{
-    DMXConfigFullDimPtr pFull = dmxConfigAlloc(sizeof(*pFull));
-    pFull->scrn = pScrn;
-    pFull->root = pRoot;
-    return pFull;
-}
-
-void dmxConfigFreeFullDim(DMXConfigFullDimPtr p)
-{
-    if (!p) return;
-    dmxConfigFreePartDim(p->scrn);
-    dmxConfigFreePartDim(p->root);
-    dmxConfigFree(p);
-}
-
-DMXConfigDisplayPtr dmxConfigCreateDisplay(DMXConfigTokenPtr pStart,
-                                           DMXConfigStringPtr pName,
-                                           DMXConfigFullDimPtr pDim,
-                                           DMXConfigPairPtr pOrigin,
-                                           DMXConfigTokenPtr pEnd)
-{
-    DMXConfigDisplayPtr pDisplay = dmxConfigAlloc(sizeof(*pDisplay));
-
-    pDisplay->start          = pStart;
-    pDisplay->dname          = pName;
-    pDisplay->dim            = pDim;
-    pDisplay->origin         = pOrigin;
-    pDisplay->end            = pEnd;
-
-    pDisplay->name           = pName ? pName->string : NULL;
-    pDisplay->rootXOrigin    = pOrigin ? pOrigin->x : 0;
-    pDisplay->rootYOrigin    = pOrigin ? pOrigin->y : 0;
-
-    if (pDim && pDim->scrn && pDim->scrn->dim) {
-        pDisplay->scrnWidth  = pDim->scrn->dim->x;
-        pDisplay->scrnHeight = pDim->scrn->dim->y;
-    }
-    if (pDim && pDim->scrn && pDim->scrn->offset) {
-        pDisplay->scrnX      = pDim->scrn->offset->x;
-        pDisplay->scrnY      = pDim->scrn->offset->y;
-        pDisplay->scrnXSign  = pDim->scrn->offset->xsign;
-        pDisplay->scrnYSign  = pDim->scrn->offset->ysign;
-    }
-    
-    if (pDim && pDim->root) {
-        if (pDim->root->dim) {
-            pDisplay->rootWidth  = pDim->root->dim->x;
-            pDisplay->rootHeight = pDim->root->dim->y;
-        }
-        if (pDim->root->offset) {
-            pDisplay->rootX      = pDim->root->offset->x;
-            pDisplay->rootY      = pDim->root->offset->y;
-            pDisplay->rootXSign  = pDim->root->offset->xsign;
-            pDisplay->rootYSign  = pDim->root->offset->ysign;
-        }
-    } else {                    /* If no root specification, copy width
-                                 * and height from scrn -- leave offset
-                                 * as zero, since it is relative to
-                                 * scrn. */
-        pDisplay->rootWidth  = pDisplay->scrnWidth;
-        pDisplay->rootHeight = pDisplay->scrnHeight;
-    }
-
-
-    return pDisplay;
-}
-
-void dmxConfigFreeDisplay(DMXConfigDisplayPtr p)
-{
-    if (!p) return;
-    dmxConfigFreeToken(p->start);
-    dmxConfigFreeString(p->dname);
-    dmxConfigFreeFullDim(p->dim);
-    dmxConfigFreeToken(p->end);
-    dmxConfigFree(p);
-}
-
-DMXConfigWallPtr dmxConfigCreateWall(DMXConfigTokenPtr pStart,
-                                     DMXConfigPairPtr pWallDim,
-                                     DMXConfigPairPtr pDisplayDim,
-                                     DMXConfigStringPtr pNameList,
-                                     DMXConfigTokenPtr pEnd)
-{
-    DMXConfigWallPtr pWall = dmxConfigAlloc(sizeof(*pWall));
-
-    pWall->start      = pStart;
-    pWall->wallDim    = pWallDim;
-    pWall->displayDim = pDisplayDim;
-    pWall->nameList   = pNameList;
-    pWall->end        = pEnd;
-
-    pWall->width      = pDisplayDim ? pDisplayDim->x : 0;
-    pWall->height     = pDisplayDim ? pDisplayDim->y : 0;
-    pWall->xwall      = pWallDim    ? pWallDim->x    : 0;
-    pWall->ywall      = pWallDim    ? pWallDim->y    : 0;
-
-    return pWall;
-}
-
-void dmxConfigFreeWall(DMXConfigWallPtr p)
-{
-    if (!p) return;
-    dmxConfigFreeToken(p->start);
-    dmxConfigFreePair(p->wallDim);
-    dmxConfigFreePair(p->displayDim);
-    dmxConfigFreeString(p->nameList);
-    dmxConfigFreeToken(p->end);
-    dmxConfigFree(p);
-}
-
-DMXConfigOptionPtr dmxConfigCreateOption(DMXConfigTokenPtr pStart,
-                                         DMXConfigStringPtr pOption,
-                                         DMXConfigTokenPtr pEnd)
-{
-    int                length = 0;
-    int                offset = 0;
-    DMXConfigStringPtr p;
-    DMXConfigOptionPtr option = dmxConfigAlloc(sizeof(*option));
-
-    for (p = pOption; p; p = p->next) {
-        if (p->string) length += strlen(p->string) + 1;
-    }
-
-    option->string = dmxConfigAlloc(length + 1);
-    
-    for (p = pOption; p; p = p->next) {
-        if (p->string) {
-            int len = strlen(p->string);
-            strncpy(option->string + offset, p->string, len);
-            offset += len;
-            if (p->next) option->string[offset++] = ' ';
-        }
-    }
-    option->string[offset] = '\0';
-
-    option->start  = pStart;
-    option->option = pOption;
-    option->end    = pEnd;
-
-    return option;
-}
-
-void dmxConfigFreeOption(DMXConfigOptionPtr p)
-{
-    if (!p) return;
-    if (p->string) free(p->string);
-    dmxConfigFreeToken(p->start);
-    dmxConfigFreeString(p->option);
-    dmxConfigFreeToken(p->end);
-    dmxConfigFree(p);
-}
-
-const char **dmxConfigLookupParam(DMXConfigParamPtr p, const char *key,
-                                  int *argc)
-{
-    DMXConfigParamPtr pt;
-
-    for (pt = p; pt; pt = pt->next) {
-        if (pt->argv && !strcasecmp(pt->argv[0], key)) {
-            *argc = pt->argc;
-            return pt->argv;
-        }
-    }
-    *argc  = 0;
-    return NULL;
-}
-
-DMXConfigParamPtr dmxConfigCreateParam(DMXConfigTokenPtr pStart,
-                                       DMXConfigTokenPtr pOpen,
-                                       DMXConfigStringPtr pParam,
-                                       DMXConfigTokenPtr pClose,
-                                       DMXConfigTokenPtr pEnd)
-{
-    DMXConfigParamPtr  param = dmxConfigAlloc(sizeof(*param));
-    DMXConfigStringPtr pt;
-
-    param->argc = 0;
-    param->argv = NULL;
-    for (pt = pParam; pt; pt = pt->next) {
-        if (pt->string) {
-            param->argv = realloc(param->argv,
-                                  (param->argc+2) * sizeof(*param->argv));
-            param->argv[param->argc] = pt->string;
-            ++param->argc;
-        }
-    }
-    if (param->argv) param->argv[param->argc] = NULL;
-
-    param->start = pStart;
-    param->open  = pOpen;
-    param->param = pParam;
-    param->close = pClose;
-    param->end   = pEnd;
-
-    return param;
-}
-
-void dmxConfigFreeParam(DMXConfigParamPtr p)
-{
-    DMXConfigParamPtr next;
-
-    if (!p) return;
-    do {
-        next = p->next;
-        dmxConfigFreeToken(p->start);
-        dmxConfigFreeToken(p->open);
-        dmxConfigFreeString(p->param);
-        dmxConfigFreeToken(p->close);
-        dmxConfigFreeToken(p->end);
-        dmxConfigFree(p->argv);
-        dmxConfigFree(p);
-    } while ((p = next));
-}
-
-DMXConfigSubPtr dmxConfigCreateSub(DMXConfigType type,
-                                   DMXConfigCommentPtr comment,
-                                   DMXConfigDisplayPtr display,
-                                   DMXConfigWallPtr wall,
-                                   DMXConfigOptionPtr option,
-                                   DMXConfigParamPtr param)
-{
-    DMXConfigSubPtr pSub = dmxConfigAlloc(sizeof(*pSub));
-    pSub->type = type;
-    switch (type) {
-    case dmxConfigComment: pSub->comment = comment;                     break;
-    case dmxConfigDisplay: pSub->display = display;                     break;
-    case dmxConfigWall:    pSub->wall    = wall;                        break;
-    case dmxConfigOption:  pSub->option  = option;                      break;
-    case dmxConfigParam:   pSub->param   = param;                       break;
-    default: dmxConfigLog("Type %d not supported in subentry\n", type); break;
-    }
-    return pSub;
-}
-
-void dmxConfigFreeSub(DMXConfigSubPtr sub)
-{
-    DMXConfigSubPtr pt;
-
-    for (pt = sub; pt; pt = pt->next) {
-        switch (pt->type) {
-        case dmxConfigComment: dmxConfigFreeComment(pt->comment); break;
-        case dmxConfigDisplay: dmxConfigFreeDisplay(pt->display); break;
-        case dmxConfigWall:    dmxConfigFreeWall(pt->wall);       break;
-        case dmxConfigOption:  dmxConfigFreeOption(pt->option);   break;
-        case dmxConfigParam:   dmxConfigFreeParam(pt->param);     break;
-        default:
-            dmxConfigLog("Type %d not supported in subentry\n", pt->type);
-            break;
-        }
-    }
-    dmxConfigFree(sub);
-}
-
-DMXConfigSubPtr dmxConfigSubComment(DMXConfigCommentPtr comment)
-{
-    return dmxConfigCreateSub(dmxConfigComment, comment, NULL, NULL, NULL,
-                              NULL);
-}
-
-DMXConfigSubPtr dmxConfigSubDisplay(DMXConfigDisplayPtr display)
-{
-    return dmxConfigCreateSub(dmxConfigDisplay, NULL, display, NULL, NULL,
-                              NULL);
-}
-
-DMXConfigSubPtr dmxConfigSubWall(DMXConfigWallPtr wall)
-{
-    return dmxConfigCreateSub(dmxConfigWall, NULL, NULL, wall, NULL, NULL);
-}
-
-DMXConfigSubPtr dmxConfigSubOption(DMXConfigOptionPtr option)
-{
-    return dmxConfigCreateSub(dmxConfigOption, NULL, NULL, NULL, option, NULL);
-}
-
-DMXConfigSubPtr dmxConfigSubParam(DMXConfigParamPtr param)
-{
-    return dmxConfigCreateSub(dmxConfigParam, NULL, NULL, NULL, NULL, param);
-}
-
-extern DMXConfigSubPtr dmxConfigAddSub(DMXConfigSubPtr head,
-                                       DMXConfigSubPtr sub)
-{
-    DMXConfigSubPtr pt;
-    
-    if (!head) return sub;
-    for (pt = head; pt->next; pt = pt->next);
-    pt->next = sub;
-    return head;
-}
-
-DMXConfigVirtualPtr dmxConfigCreateVirtual(DMXConfigTokenPtr pStart,
-                                           DMXConfigStringPtr pName,
-                                           DMXConfigPairPtr pDim,
-                                           DMXConfigTokenPtr pOpen,
-                                           DMXConfigSubPtr pSubentry,
-                                           DMXConfigTokenPtr pClose)
-{
-    DMXConfigVirtualPtr pVirtual = dmxConfigAlloc(sizeof(*pVirtual));
-
-    pVirtual->start    = pStart;
-    pVirtual->vname    = pName;
-    pVirtual->dim      = pDim;
-    pVirtual->open     = pOpen;
-    pVirtual->subentry = pSubentry;
-    pVirtual->close    = pClose;
-
-    pVirtual->name     = pName ? pName->string : NULL;
-    pVirtual->width    = pDim ? pDim->x : 0;
-    pVirtual->height   = pDim ? pDim->y : 0;
-    
-    return pVirtual;
-}
-
-void dmxConfigFreeVirtual(DMXConfigVirtualPtr virtual)
-{
-    dmxConfigFreeToken(virtual->start);
-    dmxConfigFreeString(virtual->vname);
-    dmxConfigFreePair(virtual->dim);
-    dmxConfigFreeToken(virtual->open);
-    dmxConfigFreeSub(virtual->subentry);
-    dmxConfigFreeToken(virtual->close);
-    dmxConfigFree(virtual);
-}
-
-DMXConfigEntryPtr dmxConfigCreateEntry(DMXConfigType type,
-                                       DMXConfigCommentPtr comment,
-                                       DMXConfigVirtualPtr virtual)
-{
-    DMXConfigEntryPtr pEntry = dmxConfigAlloc(sizeof(*pEntry));
-    pEntry->type = type;
-    switch (type) {
-    case dmxConfigComment: pEntry->comment = comment;                break;
-    case dmxConfigVirtual: pEntry->virtual = virtual;                break;
-    default: dmxConfigLog("Type %d not supported in entry\n", type); break;
-    }
-    return pEntry;
-}
-
-void dmxConfigFreeEntry(DMXConfigEntryPtr entry)
-{
-    DMXConfigEntryPtr pt;
-
-    for (pt = entry; pt; pt = pt->next) {
-        switch (pt->type) {
-        case dmxConfigComment: dmxConfigFreeComment(pt->comment); break;
-        case dmxConfigVirtual: dmxConfigFreeVirtual(pt->virtual); break;
-        default:
-            dmxConfigLog("Type %d not supported in entry\n", pt->type);
-            break;
-        }
-    }
-    dmxConfigFree(entry);
-}
-
-DMXConfigEntryPtr dmxConfigAddEntry(DMXConfigEntryPtr head,
-                                    DMXConfigType type,
-                                    DMXConfigCommentPtr comment,
-                                    DMXConfigVirtualPtr virtual)
-{
-    DMXConfigEntryPtr child = dmxConfigCreateEntry(type, comment, virtual);
-    DMXConfigEntryPtr pt;
-
-    if (!head) return child;
-
-    for (pt = head; pt->next; pt = pt->next);
-    pt->next = child;
-
-    return head;
-}
-
-DMXConfigEntryPtr dmxConfigEntryComment(DMXConfigCommentPtr comment)
-{
-    return dmxConfigCreateEntry(dmxConfigComment, comment, NULL);
-}
-
-DMXConfigEntryPtr dmxConfigEntryVirtual(DMXConfigVirtualPtr virtual)
-{
-    return dmxConfigCreateEntry(dmxConfigVirtual, NULL, virtual);
-}
+/*

+ * Copyright 2002 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ *

+ * This file provides support routines and helper functions to be used

+ * by the DMX configuration file parser.

+ *

+ * Because the DMX configuration file parsing should be capable of being

+ * used in a stand-alone fashion (i.e., independent from the DMX server

+ * source tree), no dependencies on other DMX routines are made. */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <stdarg.h>

+#include "dmxparse.h"

+

+/** A general error logging routine that does not depend on the dmxLog

+ * functions. */

+void dmxConfigLog(const char *format, ...)

+{

+    va_list args;

+    

+    va_start(args, format);

+    vprintf(format, args);      /* RATS: All calls to dmxConfigLog from

+                                 * dmxparse.c and dmxprint.c use a

+                                 * trusted format. */

+    va_end(args);

+}

+

+void *dmxConfigAlloc(unsigned long bytes)

+{

+    void *area = calloc(1, bytes);

+    if (!area) {

+        dmxConfigLog("dmxConfigAlloc: out of memory\n");

+        return NULL;

+    }

+    return area;

+}

+

+void *dmxConfigRealloc(void *orig, unsigned long orig_bytes,

+                       unsigned long bytes)

+{

+    unsigned char *area = realloc(orig, bytes);

+    if (!area) {

+        dmxConfigLog("dmxConfigRealloc: out of memory\n");

+        return NULL;

+    }

+    memset(area + orig_bytes, 0, bytes - orig_bytes);

+    return area;

+}

+

+const char *dmxConfigCopyString(const char *string, int length)

+{

+    char *copy;

+    

+    if (!length) length = strlen(string);

+    copy = dmxConfigAlloc(length + 1);

+    if (length) strncpy(copy, string, length);

+    copy[length] = '\0';

+    return copy;

+}

+

+void dmxConfigFree(void *area)

+{

+    free(area);

+}

+

+DMXConfigTokenPtr dmxConfigCreateToken(int token, int line,

+                                       const char *comment)

+{

+    DMXConfigTokenPtr pToken = dmxConfigAlloc(sizeof(*pToken));

+    pToken->token   = token;

+    pToken->line    = line;

+    pToken->comment = comment;

+    return pToken;

+}

+

+void dmxConfigFreeToken(DMXConfigTokenPtr p)

+{

+    if (!p) return;

+    dmxConfigFree((void *)p->comment);

+    dmxConfigFree(p);

+}

+

+DMXConfigStringPtr dmxConfigCreateString(int token, int line,

+                                         const char *comment,

+                                         const char *string)

+{

+    DMXConfigStringPtr pString = dmxConfigAlloc(sizeof(*pString));

+

+    pString->token   = token;

+    pString->line    = line;

+    pString->comment = comment;

+    pString->string  = string;

+    return pString;

+}

+

+void dmxConfigFreeString(DMXConfigStringPtr p)

+{

+    DMXConfigStringPtr next;

+

+    if (!p) return;

+    do {

+        next = p->next;

+        dmxConfigFree((void *)p->comment);

+        dmxConfigFree((void *)p->string);

+        dmxConfigFree(p);

+    } while ((p = next));

+}

+ 

+DMXConfigNumberPtr dmxConfigCreateNumber(int token, int line,

+                                         const char *comment,

+                                         int number)

+{

+    DMXConfigNumberPtr pNumber = dmxConfigAlloc(sizeof(*pNumber));

+

+    pNumber->token   = token;

+    pNumber->line    = line;

+    pNumber->comment = comment;

+    pNumber->number  = number;

+    return pNumber;

+}

+

+void dmxConfigFreeNumber(DMXConfigNumberPtr p)

+{

+    if (!p) return;

+    dmxConfigFree((void *)p->comment);

+    dmxConfigFree(p);

+}

+

+DMXConfigPairPtr dmxConfigCreatePair(int token, int line,

+                                     const char *comment,

+                                     int x, int y,

+                                     int xsign, int ysign)

+{

+    DMXConfigPairPtr pPair = dmxConfigAlloc(sizeof(*pPair));

+

+    pPair->token   = token;

+    pPair->line    = line;

+    pPair->comment = comment;

+    pPair->x       = x;

+    pPair->y       = y;

+    pPair->xsign   = (xsign < 0) ? -1 : 1;

+    pPair->ysign   = (ysign < 0) ? -1 : 1;

+    return pPair;

+}

+

+void dmxConfigFreePair(DMXConfigPairPtr p)

+{

+    if (!p) return;

+    dmxConfigFree((void *)p->comment);

+    dmxConfigFree(p);

+}

+

+DMXConfigCommentPtr dmxConfigCreateComment(int token, int line,

+                                           const char *comment)

+{

+    DMXConfigCommentPtr pComment = dmxConfigAlloc(sizeof(*pComment));

+

+    pComment->token   = token;

+    pComment->line    = line;

+    pComment->comment = comment;

+    return pComment;

+}

+

+void dmxConfigFreeComment(DMXConfigCommentPtr p)

+{

+    if (!p) return;

+    dmxConfigFree((void *)p->comment);

+    dmxConfigFree(p);

+}

+

+DMXConfigPartDimPtr dmxConfigCreatePartDim(DMXConfigPairPtr pDim,

+                                           DMXConfigPairPtr pOffset)

+{

+    DMXConfigPartDimPtr pPart = dmxConfigAlloc(sizeof(*pPart));

+    pPart->dim    = pDim;

+    pPart->offset = pOffset;

+    return pPart;

+}

+

+void dmxConfigFreePartDim(DMXConfigPartDimPtr p)

+{

+    if (!p) return;

+    dmxConfigFreePair(p->dim);

+    dmxConfigFreePair(p->offset);

+    dmxConfigFree(p);

+}

+

+DMXConfigFullDimPtr dmxConfigCreateFullDim(DMXConfigPartDimPtr pScrn,

+                                           DMXConfigPartDimPtr pRoot)

+{

+    DMXConfigFullDimPtr pFull = dmxConfigAlloc(sizeof(*pFull));

+    pFull->scrn = pScrn;

+    pFull->root = pRoot;

+    return pFull;

+}

+

+void dmxConfigFreeFullDim(DMXConfigFullDimPtr p)

+{

+    if (!p) return;

+    dmxConfigFreePartDim(p->scrn);

+    dmxConfigFreePartDim(p->root);

+    dmxConfigFree(p);

+}

+

+DMXConfigDisplayPtr dmxConfigCreateDisplay(DMXConfigTokenPtr pStart,

+                                           DMXConfigStringPtr pName,

+                                           DMXConfigFullDimPtr pDim,

+                                           DMXConfigPairPtr pOrigin,

+                                           DMXConfigTokenPtr pEnd)

+{

+    DMXConfigDisplayPtr pDisplay = dmxConfigAlloc(sizeof(*pDisplay));

+

+    pDisplay->start          = pStart;

+    pDisplay->dname          = pName;

+    pDisplay->dim            = pDim;

+    pDisplay->origin         = pOrigin;

+    pDisplay->end            = pEnd;

+

+    pDisplay->name           = pName ? pName->string : NULL;

+    pDisplay->rootXOrigin    = pOrigin ? pOrigin->x : 0;

+    pDisplay->rootYOrigin    = pOrigin ? pOrigin->y : 0;

+

+    if (pDim && pDim->scrn && pDim->scrn->dim) {

+        pDisplay->scrnWidth  = pDim->scrn->dim->x;

+        pDisplay->scrnHeight = pDim->scrn->dim->y;

+    }

+    if (pDim && pDim->scrn && pDim->scrn->offset) {

+        pDisplay->scrnX      = pDim->scrn->offset->x;

+        pDisplay->scrnY      = pDim->scrn->offset->y;

+        pDisplay->scrnXSign  = pDim->scrn->offset->xsign;

+        pDisplay->scrnYSign  = pDim->scrn->offset->ysign;

+    }

+    

+    if (pDim && pDim->root) {

+        if (pDim->root->dim) {

+            pDisplay->rootWidth  = pDim->root->dim->x;

+            pDisplay->rootHeight = pDim->root->dim->y;

+        }

+        if (pDim->root->offset) {

+            pDisplay->rootX      = pDim->root->offset->x;

+            pDisplay->rootY      = pDim->root->offset->y;

+            pDisplay->rootXSign  = pDim->root->offset->xsign;

+            pDisplay->rootYSign  = pDim->root->offset->ysign;

+        }

+    } else {                    /* If no root specification, copy width

+                                 * and height from scrn -- leave offset

+                                 * as zero, since it is relative to

+                                 * scrn. */

+        pDisplay->rootWidth  = pDisplay->scrnWidth;

+        pDisplay->rootHeight = pDisplay->scrnHeight;

+    }

+

+

+    return pDisplay;

+}

+

+void dmxConfigFreeDisplay(DMXConfigDisplayPtr p)

+{

+    if (!p) return;

+    dmxConfigFreeToken(p->start);

+    dmxConfigFreeString(p->dname);

+    dmxConfigFreeFullDim(p->dim);

+    dmxConfigFreeToken(p->end);

+    dmxConfigFree(p);

+}

+

+DMXConfigWallPtr dmxConfigCreateWall(DMXConfigTokenPtr pStart,

+                                     DMXConfigPairPtr pWallDim,

+                                     DMXConfigPairPtr pDisplayDim,

+                                     DMXConfigStringPtr pNameList,

+                                     DMXConfigTokenPtr pEnd)

+{

+    DMXConfigWallPtr pWall = dmxConfigAlloc(sizeof(*pWall));

+

+    pWall->start      = pStart;

+    pWall->wallDim    = pWallDim;

+    pWall->displayDim = pDisplayDim;

+    pWall->nameList   = pNameList;

+    pWall->end        = pEnd;

+

+    pWall->width      = pDisplayDim ? pDisplayDim->x : 0;

+    pWall->height     = pDisplayDim ? pDisplayDim->y : 0;

+    pWall->xwall      = pWallDim    ? pWallDim->x    : 0;

+    pWall->ywall      = pWallDim    ? pWallDim->y    : 0;

+

+    return pWall;

+}

+

+void dmxConfigFreeWall(DMXConfigWallPtr p)

+{

+    if (!p) return;

+    dmxConfigFreeToken(p->start);

+    dmxConfigFreePair(p->wallDim);

+    dmxConfigFreePair(p->displayDim);

+    dmxConfigFreeString(p->nameList);

+    dmxConfigFreeToken(p->end);

+    dmxConfigFree(p);

+}

+

+DMXConfigOptionPtr dmxConfigCreateOption(DMXConfigTokenPtr pStart,

+                                         DMXConfigStringPtr pOption,

+                                         DMXConfigTokenPtr pEnd)

+{

+    int                length = 0;

+    int                offset = 0;

+    DMXConfigStringPtr p;

+    DMXConfigOptionPtr option = dmxConfigAlloc(sizeof(*option));

+

+    for (p = pOption; p; p = p->next) {

+        if (p->string) length += strlen(p->string) + 1;

+    }

+

+    option->string = dmxConfigAlloc(length + 1);

+    

+    for (p = pOption; p; p = p->next) {

+        if (p->string) {

+            int len = strlen(p->string);

+            strncpy(option->string + offset, p->string, len);

+            offset += len;

+            if (p->next) option->string[offset++] = ' ';

+        }

+    }

+    option->string[offset] = '\0';

+

+    option->start  = pStart;

+    option->option = pOption;

+    option->end    = pEnd;

+

+    return option;

+}

+

+void dmxConfigFreeOption(DMXConfigOptionPtr p)

+{

+    if (!p) return;

+    free(p->string);

+    dmxConfigFreeToken(p->start);

+    dmxConfigFreeString(p->option);

+    dmxConfigFreeToken(p->end);

+    dmxConfigFree(p);

+}

+

+const char **dmxConfigLookupParam(DMXConfigParamPtr p, const char *key,

+                                  int *argc)

+{

+    DMXConfigParamPtr pt;

+

+    for (pt = p; pt; pt = pt->next) {

+        if (pt->argv && !strcasecmp(pt->argv[0], key)) {

+            *argc = pt->argc;

+            return pt->argv;

+        }

+    }

+    *argc  = 0;

+    return NULL;

+}

+

+DMXConfigParamPtr dmxConfigCreateParam(DMXConfigTokenPtr pStart,

+                                       DMXConfigTokenPtr pOpen,

+                                       DMXConfigStringPtr pParam,

+                                       DMXConfigTokenPtr pClose,

+                                       DMXConfigTokenPtr pEnd)

+{

+    DMXConfigParamPtr  param = dmxConfigAlloc(sizeof(*param));

+    DMXConfigStringPtr pt;

+

+    param->argc = 0;

+    param->argv = NULL;

+    for (pt = pParam; pt; pt = pt->next) {

+        if (pt->string) {

+            param->argv = realloc(param->argv,

+                                  (param->argc+2) * sizeof(*param->argv));

+            param->argv[param->argc] = pt->string;

+            ++param->argc;

+        }

+    }

+    if (param->argv) param->argv[param->argc] = NULL;

+

+    param->start = pStart;

+    param->open  = pOpen;

+    param->param = pParam;

+    param->close = pClose;

+    param->end   = pEnd;

+

+    return param;

+}

+

+void dmxConfigFreeParam(DMXConfigParamPtr p)

+{

+    DMXConfigParamPtr next;

+

+    if (!p) return;

+    do {

+        next = p->next;

+        dmxConfigFreeToken(p->start);

+        dmxConfigFreeToken(p->open);

+        dmxConfigFreeString(p->param);

+        dmxConfigFreeToken(p->close);

+        dmxConfigFreeToken(p->end);

+        dmxConfigFree(p->argv);

+        dmxConfigFree(p);

+    } while ((p = next));

+}

+

+DMXConfigSubPtr dmxConfigCreateSub(DMXConfigType type,

+                                   DMXConfigCommentPtr comment,

+                                   DMXConfigDisplayPtr display,

+                                   DMXConfigWallPtr wall,

+                                   DMXConfigOptionPtr option,

+                                   DMXConfigParamPtr param)

+{

+    DMXConfigSubPtr pSub = dmxConfigAlloc(sizeof(*pSub));

+    pSub->type = type;

+    switch (type) {

+    case dmxConfigComment: pSub->comment = comment;                     break;

+    case dmxConfigDisplay: pSub->display = display;                     break;

+    case dmxConfigWall:    pSub->wall    = wall;                        break;

+    case dmxConfigOption:  pSub->option  = option;                      break;

+    case dmxConfigParam:   pSub->param   = param;                       break;

+    default: dmxConfigLog("Type %d not supported in subentry\n", type); break;

+    }

+    return pSub;

+}

+

+void dmxConfigFreeSub(DMXConfigSubPtr sub)

+{

+    DMXConfigSubPtr pt;

+

+    for (pt = sub; pt; pt = pt->next) {

+        switch (pt->type) {

+        case dmxConfigComment: dmxConfigFreeComment(pt->comment); break;

+        case dmxConfigDisplay: dmxConfigFreeDisplay(pt->display); break;

+        case dmxConfigWall:    dmxConfigFreeWall(pt->wall);       break;

+        case dmxConfigOption:  dmxConfigFreeOption(pt->option);   break;

+        case dmxConfigParam:   dmxConfigFreeParam(pt->param);     break;

+        default:

+            dmxConfigLog("Type %d not supported in subentry\n", pt->type);

+            break;

+        }

+    }

+    dmxConfigFree(sub);

+}

+

+DMXConfigSubPtr dmxConfigSubComment(DMXConfigCommentPtr comment)

+{

+    return dmxConfigCreateSub(dmxConfigComment, comment, NULL, NULL, NULL,

+                              NULL);

+}

+

+DMXConfigSubPtr dmxConfigSubDisplay(DMXConfigDisplayPtr display)

+{

+    return dmxConfigCreateSub(dmxConfigDisplay, NULL, display, NULL, NULL,

+                              NULL);

+}

+

+DMXConfigSubPtr dmxConfigSubWall(DMXConfigWallPtr wall)

+{

+    return dmxConfigCreateSub(dmxConfigWall, NULL, NULL, wall, NULL, NULL);

+}

+

+DMXConfigSubPtr dmxConfigSubOption(DMXConfigOptionPtr option)

+{

+    return dmxConfigCreateSub(dmxConfigOption, NULL, NULL, NULL, option, NULL);

+}

+

+DMXConfigSubPtr dmxConfigSubParam(DMXConfigParamPtr param)

+{

+    return dmxConfigCreateSub(dmxConfigParam, NULL, NULL, NULL, NULL, param);

+}

+

+extern DMXConfigSubPtr dmxConfigAddSub(DMXConfigSubPtr head,

+                                       DMXConfigSubPtr sub)

+{

+    DMXConfigSubPtr pt;

+    

+    if (!head) return sub;

+    for (pt = head; pt->next; pt = pt->next);

+    pt->next = sub;

+    return head;

+}

+

+DMXConfigVirtualPtr dmxConfigCreateVirtual(DMXConfigTokenPtr pStart,

+                                           DMXConfigStringPtr pName,

+                                           DMXConfigPairPtr pDim,

+                                           DMXConfigTokenPtr pOpen,

+                                           DMXConfigSubPtr pSubentry,

+                                           DMXConfigTokenPtr pClose)

+{

+    DMXConfigVirtualPtr pVirtual = dmxConfigAlloc(sizeof(*pVirtual));

+

+    pVirtual->start    = pStart;

+    pVirtual->vname    = pName;

+    pVirtual->dim      = pDim;

+    pVirtual->open     = pOpen;

+    pVirtual->subentry = pSubentry;

+    pVirtual->close    = pClose;

+

+    pVirtual->name     = pName ? pName->string : NULL;

+    pVirtual->width    = pDim ? pDim->x : 0;

+    pVirtual->height   = pDim ? pDim->y : 0;

+    

+    return pVirtual;

+}

+

+void dmxConfigFreeVirtual(DMXConfigVirtualPtr virtual)

+{

+    dmxConfigFreeToken(virtual->start);

+    dmxConfigFreeString(virtual->vname);

+    dmxConfigFreePair(virtual->dim);

+    dmxConfigFreeToken(virtual->open);

+    dmxConfigFreeSub(virtual->subentry);

+    dmxConfigFreeToken(virtual->close);

+    dmxConfigFree(virtual);

+}

+

+DMXConfigEntryPtr dmxConfigCreateEntry(DMXConfigType type,

+                                       DMXConfigCommentPtr comment,

+                                       DMXConfigVirtualPtr virtual)

+{

+    DMXConfigEntryPtr pEntry = dmxConfigAlloc(sizeof(*pEntry));

+    pEntry->type = type;

+    switch (type) {

+    case dmxConfigComment: pEntry->comment = comment;                break;

+    case dmxConfigVirtual: pEntry->virtual = virtual;                break;

+    default: dmxConfigLog("Type %d not supported in entry\n", type); break;

+    }

+    return pEntry;

+}

+

+void dmxConfigFreeEntry(DMXConfigEntryPtr entry)

+{

+    DMXConfigEntryPtr pt;

+

+    for (pt = entry; pt; pt = pt->next) {

+        switch (pt->type) {

+        case dmxConfigComment: dmxConfigFreeComment(pt->comment); break;

+        case dmxConfigVirtual: dmxConfigFreeVirtual(pt->virtual); break;

+        default:

+            dmxConfigLog("Type %d not supported in entry\n", pt->type);

+            break;

+        }

+    }

+    dmxConfigFree(entry);

+}

+

+DMXConfigEntryPtr dmxConfigAddEntry(DMXConfigEntryPtr head,

+                                    DMXConfigType type,

+                                    DMXConfigCommentPtr comment,

+                                    DMXConfigVirtualPtr virtual)

+{

+    DMXConfigEntryPtr child = dmxConfigCreateEntry(type, comment, virtual);

+    DMXConfigEntryPtr pt;

+

+    if (!head) return child;

+

+    for (pt = head; pt->next; pt = pt->next);

+    pt->next = child;

+

+    return head;

+}

+

+DMXConfigEntryPtr dmxConfigEntryComment(DMXConfigCommentPtr comment)

+{

+    return dmxConfigCreateEntry(dmxConfigComment, comment, NULL);

+}

+

+DMXConfigEntryPtr dmxConfigEntryVirtual(DMXConfigVirtualPtr virtual)

+{

+    return dmxConfigCreateEntry(dmxConfigVirtual, NULL, virtual);

+}

diff --git a/xorg-server/hw/dmx/dmx.h b/xorg-server/hw/dmx/dmx.h
index fbb8b96ed..ddc11e368 100644
--- a/xorg-server/hw/dmx/dmx.h
+++ b/xorg-server/hw/dmx/dmx.h
@@ -1,367 +1,390 @@
-/*
- * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *   David H. Dawes <dawes@xfree86.org>
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- * Main header file included by all other DMX-related files.
- */
-
-/** \mainpage
- * - <a href="http://dmx.sourceforge.net">DMX Home Page</a>
- * - <a href="http://sourceforge.net/projects/dmx">DMX Project Page (on
- * Source Forge)</a>
- * - <a href="http://dmx.sourceforge.net/dmx.html">Distributed Multihead
- * X design</a>, the design document for DMX
- * - <a href="http://dmx.sourceforge.net/DMXSpec.txt">Client-to-Server
- * DMX Extension to the X Protocol</a>
- */
-
-#ifndef DMX_H
-#define DMX_H
-
-#if HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "gcstruct.h"
-
-/* Handle client-side include files in one place. */
-#include "dmxclient.h"
-
-#include "globals.h"
-#include "scrnintstr.h"
-
-#include "picturestr.h"
-
-#ifdef GLXEXT
-#include <GL/glx.h>
-#include <GL/glxint.h>
-#endif
-
-typedef enum {
-    PosNone = -1,
-    PosAbsolute = 0,
-    PosRightOf,
-    PosLeftOf,
-    PosAbove,
-    PosBelow,
-    PosRelative
-} PositionType;
-
-/** Provide the typedef globally, but keep the contents opaque outside
- * of the input routines.  \see dmxinput.h */
-typedef struct _DMXInputInfo DMXInputInfo;
-
-/** Provide the typedef globally, but keep the contents opaque outside
- * of the XSync statistic routines.  \see dmxstat.c */
-typedef struct _DMXStatInfo DMXStatInfo;
-
-/** Global structure containing information about each backend screen. */
-typedef struct _DMXScreenInfo {
-    const char   *name;           /**< Name from command line or config file */
-    int           index;          /**< Index into dmxScreens global          */
-
-    /*---------- Back-end X server information ----------*/
-
-    Display      *beDisplay;      /**< Back-end X server's display */
-    int           beWidth;        /**< Width of BE display */
-    int           beHeight;       /**< Height of BE display */
-    int           beDepth;        /**< Depth of BE display */
-    int           beBPP;          /**< Bits per pixel of BE display */
-    int           beXDPI;         /**< Horizontal dots per inch of BE */
-    int           beYDPI;         /**< Vertical dots per inch of BE */
-
-    int           beNumDepths;    /**< Number of depths on BE server */
-    int          *beDepths;       /**< Depths from BE server */
-
-    int           beNumPixmapFormats; /**< Number of pixmap formats on BE */
-    XPixmapFormatValues *bePixmapFormats; /**< Pixmap formats on BE */
-
-    int           beNumVisuals;   /**< Number of visuals on BE */
-    XVisualInfo  *beVisuals;      /**< Visuals from BE server */
-    int           beDefVisualIndex; /**< Default visual index of BE */
-
-    int           beNumDefColormaps; /**< Number of default colormaps */
-    Colormap     *beDefColormaps; /**< Default colormaps for DMX server */ 
-
-    Pixel         beBlackPixel;   /**< Default black pixel for BE */
-    Pixel         beWhitePixel;   /**< Default white pixel for BE */
-
-    /*---------- Screen window information ----------*/
-
-    Window        scrnWin;        /**< "Screen" window on backend display */
-    int           scrnX;          /**< X offset of "screen" WRT BE display */
-    int           scrnY;          /**< Y offset of "screen" WRT BE display */
-    int           scrnWidth;      /**< Width of "screen" */
-    int           scrnHeight;     /**< Height of "screen" */
-    int           scrnXSign;      /**< X offset sign of "screen" */
-    int           scrnYSign;      /**< Y offset sign of "screen" */
-
-                                  /** Default drawables for "screen" */
-    Drawable      scrnDefDrawables[MAXFORMATS];
-
-    struct _DMXScreenInfo *next;  /**< List of "screens" on same display */
-    struct _DMXScreenInfo *over;  /**< List of "screens" that overlap */
-
-    /*---------- Root window information ----------*/
-
-    Window        rootWin;        /**< "Root" window on backend display */
-    int           rootX;          /**< X offset of "root" window WRT "screen"*/
-    int           rootY;          /**< Y offset of "root" window WRT "screen"*/
-    int           rootWidth;      /**< Width of "root" window */
-    int           rootHeight;     /**< Height of "root" window */
-
-    int           rootXOrigin;    /**< Global X origin of "root" window */
-    int           rootYOrigin;    /**< Global Y origin of "root" window */
-
-    /*---------- Shadow framebuffer information ----------*/
-
-    void         *shadow;         /**< Shadow framebuffer data (if enabled) */
-    XlibGC        shadowGC;       /**< Default GC used by shadow FB code */
-    XImage       *shadowFBImage;  /**< Screen image used by shadow FB code */
-
-    /*---------- Other related information ----------*/
-
-    int           shared;         /**< Non-zero if another Xdmx is running */
-
-    Bool          WMRunningOnBE;
-
-    Cursor        noCursor;
-    Cursor        curCursor;
-                                /* Support for cursors on overlapped
-                                 * backend displays. */
-    CursorPtr     cursor;
-    int           cursorVisible;
-    int           cursorNotShared; /* for overlapping screens on a backend */
-
-    PositionType  where;            /**< Relative layout information */
-    int           whereX;           /**< Relative layout information */
-    int           whereY;           /**< Relative layout information */
-    int           whereRefScreen;   /**< Relative layout information */
-
-    int           savedTimeout;     /**< Original screen saver timeout */
-    int           dpmsCapable;      /**< Non-zero if backend is DPMS capable */
-    int           dpmsEnabled;      /**< Non-zero if DPMS enabled */
-    int           dpmsStandby;      /**< Original DPMS standby value  */
-    int           dpmsSuspend;      /**< Original DPMS suspend value  */
-    int           dpmsOff;          /**< Original DPMS off value  */
-
-    DMXStatInfo  *stat;             /**< Statistics about XSync  */
-    Bool          needsSync;        /**< True if an XSync is pending  */
-
-#ifdef GLXEXT
-                                  /** Visual information for glxProxy */
-    int           numGlxVisuals;
-    __GLXvisualConfig *glxVisuals;
-    int           glxMajorOpcode;
-    int           glxErrorBase;
-
-                                  /** FB config information for glxProxy */
-    __GLXFBConfig *fbconfigs;
-    int           numFBConfigs;
-#endif
-
-                                    /** Function pointers to wrapped screen
-				     *  functions */
-    CloseScreenProcPtr             CloseScreen;
-    SaveScreenProcPtr              SaveScreen;
-
-    CreateGCProcPtr                CreateGC;
-
-    CreateWindowProcPtr            CreateWindow;
-    DestroyWindowProcPtr           DestroyWindow;
-    PositionWindowProcPtr          PositionWindow;
-    ChangeWindowAttributesProcPtr  ChangeWindowAttributes;
-    RealizeWindowProcPtr           RealizeWindow;
-    UnrealizeWindowProcPtr         UnrealizeWindow;
-    RestackWindowProcPtr           RestackWindow;
-    WindowExposuresProcPtr         WindowExposures;
-    CopyWindowProcPtr              CopyWindow;
-
-    ResizeWindowProcPtr            ResizeWindow;
-    ReparentWindowProcPtr          ReparentWindow;
-
-    ChangeBorderWidthProcPtr       ChangeBorderWidth;
-
-    GetImageProcPtr                GetImage;
-    GetSpansProcPtr                GetSpans;
-
-    CreatePixmapProcPtr            CreatePixmap;
-    DestroyPixmapProcPtr           DestroyPixmap;
-    BitmapToRegionProcPtr          BitmapToRegion;
-
-    RealizeFontProcPtr             RealizeFont;
-    UnrealizeFontProcPtr           UnrealizeFont;
-
-    CreateColormapProcPtr          CreateColormap;
-    DestroyColormapProcPtr         DestroyColormap;
-    InstallColormapProcPtr         InstallColormap;
-    StoreColorsProcPtr             StoreColors;
-
-    SetShapeProcPtr                SetShape;
-
-    CreatePictureProcPtr           CreatePicture;
-    DestroyPictureProcPtr          DestroyPicture;
-    ChangePictureClipProcPtr       ChangePictureClip;
-    DestroyPictureClipProcPtr      DestroyPictureClip;
-    
-    ChangePictureProcPtr           ChangePicture;
-    ValidatePictureProcPtr         ValidatePicture;
-
-    CompositeProcPtr               Composite;
-    GlyphsProcPtr                  Glyphs;
-    CompositeRectsProcPtr          CompositeRects;
-
-    InitIndexedProcPtr             InitIndexed;
-    CloseIndexedProcPtr            CloseIndexed;
-    UpdateIndexedProcPtr           UpdateIndexed;
-
-    TrapezoidsProcPtr              Trapezoids;
-    TrianglesProcPtr               Triangles;
-    TriStripProcPtr                TriStrip;
-    TriFanProcPtr                  TriFan;
-} DMXScreenInfo;
-
-/* Global variables available to all Xserver/hw/dmx routines. */
-extern int              dmxNumScreens;          /**< Number of dmxScreens */
-extern DMXScreenInfo   *dmxScreens;             /**< List of outputs */
-extern int              dmxShadowFB;            /**< Non-zero if using
-                                                 * shadow frame-buffer
-                                                 * (deprecated) */
-extern XErrorEvent      dmxLastErrorEvent;      /**< Last error that
-                                                 * occurred */
-extern Bool             dmxErrorOccurred;       /**< True if an error
-                                                 * occurred */
-extern Bool             dmxOffScreenOpt;        /**< True if using off
-                                                 * screen
-                                                 * optimizations */
-extern Bool             dmxSubdividePrimitives; /**< True if using the
-                                                 * primitive subdivision
-                                                 * optimization */
-extern Bool             dmxLazyWindowCreation;  /**< True if using the
-                                                 * lazy window creation
-                                                 * optimization */
-extern Bool             dmxUseXKB;              /**< True if the XKB
-                                                 * extension should be
-                                                 * used with the backend
-                                                 * servers */
-extern int              dmxDepth;               /**< Requested depth if
-                                                 * non-zero */
-#ifdef GLXEXT
-extern Bool             dmxGLXProxy;            /**< True if glxProxy
-						 * support is enabled */
-extern Bool             dmxGLXSwapGroupSupport; /**< True if glxProxy
-						 * support for swap
-						 * groups and barriers
-						 * is enabled */
-extern Bool             dmxGLXSyncSwap;         /**< True if glxProxy
-						 * should force an XSync
-						 * request after each
-						 * swap buffers call */
-extern Bool             dmxGLXFinishSwap;       /**< True if glxProxy
-						 * should force a
-						 * glFinish request
-						 * after each swap
-						 * buffers call */
-#endif
-extern char            *dmxFontPath;            /**< NULL if no font
-						 * path is set on the
-						 * command line;
-						 * otherwise, a string
-						 * of comma separated
-						 * paths built from the
-						 * command line
-						 * specified font
-						 * paths */
-extern Bool             dmxIgnoreBadFontPaths;  /**< True if bad font
-						 * paths should be
-						 * ignored during server
-						 * init */
-extern Bool             dmxAddRemoveScreens;    /**< True if add and
-						 * remove screens support
-						 * is enabled */
-
-/** Wrap screen or GC function pointer */
-#define DMX_WRAP(_entry, _newfunc, _saved, _actual)			\
-do {									\
-    (_saved)->_entry  = (_actual)->_entry;				\
-    (_actual)->_entry = (_newfunc);					\
-} while (0)
-
-/** Unwrap screen or GC function pointer */
-#define DMX_UNWRAP(_entry, _saved, _actual)				\
-do {									\
-    (_actual)->_entry = (_saved)->_entry;				\
-} while (0)
-
-/* Define the MAXSCREENSALLOC/FREE macros, when MAXSCREENS patch has not
- * been applied to sources. */
-#ifdef MAXSCREENS
-#define MAXSCREEN_MAKECONSTSTR1(x) #x
-#define MAXSCREEN_MAKECONSTSTR2(x) MAXSCREEN_MAKECONSTSTR1(x)
-
-#define MAXSCREEN_FAILED_TXT "Failed at ["                              \
-   MAXSCREEN_MAKECONSTSTR2(__LINE__) ":" __FILE__ "] to allocate object: "
-
-#define _MAXSCREENSALLOCF(o,size,fatal)                                 \
-    do {                                                                \
-        if (!o) {                                                       \
-            o = calloc((size), sizeof(*(o)));                          \
-            if (!o && fatal) FatalError(MAXSCREEN_FAILED_TXT #o);       \
-        }                                                               \
-    } while (0)
-#define _MAXSCREENSALLOCR(o,size,retval)                                \
-    do {                                                                \
-        if (!o) {                                                       \
-            o = calloc((size), sizeof(*(o)));                          \
-            if (!o) return retval;                                      \
-        }                                                               \
-    } while (0)
-        
-#define MAXSCREENSFREE(o)                                               \
-    do {                                                                \
-        if (o) free(o);                                                \
-        o = NULL;                                                       \
-    } while (0)
-
-#define MAXSCREENSALLOC(o)              _MAXSCREENSALLOCF(o,MAXSCREENS,  0)
-#define MAXSCREENSALLOC_FATAL(o)        _MAXSCREENSALLOCF(o,MAXSCREENS,  1)
-#define MAXSCREENSALLOC_RETURN(o,r)     _MAXSCREENSALLOCR(o,MAXSCREENS, (r))
-#define MAXSCREENSALLOCPLUSONE(o)       _MAXSCREENSALLOCF(o,MAXSCREENS+1,0)
-#define MAXSCREENSALLOCPLUSONE_FATAL(o) _MAXSCREENSALLOCF(o,MAXSCREENS+1,1)
-#define MAXSCREENSCALLOC(o,m)           _MAXSCREENSALLOCF(o,MAXSCREENS*(m),0)
-#define MAXSCREENSCALLOC_FATAL(o,m)     _MAXSCREENSALLOCF(o,MAXSCREENS*(m),1)
-#endif
-
-#endif /* DMX_H */
+/*

+ * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Kevin E. Martin <kem@redhat.com>

+ *   David H. Dawes <dawes@xfree86.org>

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ * Main header file included by all other DMX-related files.

+ */

+

+/** \mainpage

+ * - <a href="http://dmx.sourceforge.net">DMX Home Page</a>

+ * - <a href="http://sourceforge.net/projects/dmx">DMX Project Page (on

+ * Source Forge)</a>

+ * - <a href="http://dmx.sourceforge.net/dmx.html">Distributed Multihead

+ * X design</a>, the design document for DMX

+ * - <a href="http://dmx.sourceforge.net/DMXSpec.txt">Client-to-Server

+ * DMX Extension to the X Protocol</a>

+ */

+

+#ifndef DMX_H

+#define DMX_H

+

+#if HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include "gcstruct.h"

+

+/* Handle client-side include files in one place. */

+#include "dmxclient.h"

+

+#include "globals.h"

+#include "scrnintstr.h"

+

+#include "picturestr.h"

+

+#ifdef GLXEXT

+#include <GL/glx.h>

+#include <GL/glxint.h>

+#endif

+

+typedef enum {

+    PosNone = -1,

+    PosAbsolute = 0,

+    PosRightOf,

+    PosLeftOf,

+    PosAbove,

+    PosBelow,

+    PosRelative

+} PositionType;

+

+/** Provide the typedef globally, but keep the contents opaque outside

+ * of the input routines.  \see dmxinput.h */

+typedef struct _DMXInputInfo DMXInputInfo;

+

+/** Provide the typedef globally, but keep the contents opaque outside

+ * of the XSync statistic routines.  \see dmxstat.c */

+typedef struct _DMXStatInfo DMXStatInfo;

+

+/** Global structure containing information about each backend screen. */

+typedef struct _DMXScreenInfo {

+    const char   *name;           /**< Name from command line or config file */

+    int           index;          /**< Index into dmxScreens global          */

+

+    /*---------- Back-end X server information ----------*/

+

+    Display      *beDisplay;      /**< Back-end X server's display */

+    int           beWidth;        /**< Width of BE display */

+    int           beHeight;       /**< Height of BE display */

+    int           beDepth;        /**< Depth of BE display */

+    int           beBPP;          /**< Bits per pixel of BE display */

+    int           beXDPI;         /**< Horizontal dots per inch of BE */

+    int           beYDPI;         /**< Vertical dots per inch of BE */

+

+    int           beNumDepths;    /**< Number of depths on BE server */

+    int          *beDepths;       /**< Depths from BE server */

+

+    int           beNumPixmapFormats; /**< Number of pixmap formats on BE */

+    XPixmapFormatValues *bePixmapFormats; /**< Pixmap formats on BE */

+

+    int           beNumVisuals;   /**< Number of visuals on BE */

+    XVisualInfo  *beVisuals;      /**< Visuals from BE server */

+    int           beDefVisualIndex; /**< Default visual index of BE */

+

+    int           beNumDefColormaps; /**< Number of default colormaps */

+    Colormap     *beDefColormaps; /**< Default colormaps for DMX server */ 

+

+    Pixel         beBlackPixel;   /**< Default black pixel for BE */

+    Pixel         beWhitePixel;   /**< Default white pixel for BE */

+

+    /*---------- Screen window information ----------*/

+

+    Window        scrnWin;        /**< "Screen" window on backend display */

+    int           scrnX;          /**< X offset of "screen" WRT BE display */

+    int           scrnY;          /**< Y offset of "screen" WRT BE display */

+    int           scrnWidth;      /**< Width of "screen" */

+    int           scrnHeight;     /**< Height of "screen" */

+    int           scrnXSign;      /**< X offset sign of "screen" */

+    int           scrnYSign;      /**< Y offset sign of "screen" */

+

+                                  /** Default drawables for "screen" */

+    Drawable      scrnDefDrawables[MAXFORMATS];

+

+    struct _DMXScreenInfo *next;  /**< List of "screens" on same display */

+    struct _DMXScreenInfo *over;  /**< List of "screens" that overlap */

+

+    /*---------- Root window information ----------*/

+

+    Window        rootWin;        /**< "Root" window on backend display */

+    int           rootX;          /**< X offset of "root" window WRT "screen"*/

+    int           rootY;          /**< Y offset of "root" window WRT "screen"*/

+    int           rootWidth;      /**< Width of "root" window */

+    int           rootHeight;     /**< Height of "root" window */

+

+    int           rootXOrigin;    /**< Global X origin of "root" window */

+    int           rootYOrigin;    /**< Global Y origin of "root" window */

+

+    /*---------- Shadow framebuffer information ----------*/

+

+    void         *shadow;         /**< Shadow framebuffer data (if enabled) */

+    XlibGC        shadowGC;       /**< Default GC used by shadow FB code */

+    XImage       *shadowFBImage;  /**< Screen image used by shadow FB code */

+

+    /*---------- Other related information ----------*/

+

+    int           shared;         /**< Non-zero if another Xdmx is running */

+

+    Bool          WMRunningOnBE;

+

+    Cursor        noCursor;

+    Cursor        curCursor;

+                                /* Support for cursors on overlapped

+                                 * backend displays. */

+    CursorPtr     cursor;

+    int           cursorVisible;

+    int           cursorNotShared; /* for overlapping screens on a backend */

+

+    PositionType  where;            /**< Relative layout information */

+    int           whereX;           /**< Relative layout information */

+    int           whereY;           /**< Relative layout information */

+    int           whereRefScreen;   /**< Relative layout information */

+

+    int           savedTimeout;     /**< Original screen saver timeout */

+    int           dpmsCapable;      /**< Non-zero if backend is DPMS capable */

+    int           dpmsEnabled;      /**< Non-zero if DPMS enabled */

+    int           dpmsStandby;      /**< Original DPMS standby value  */

+    int           dpmsSuspend;      /**< Original DPMS suspend value  */

+    int           dpmsOff;          /**< Original DPMS off value  */

+

+    DMXStatInfo  *stat;             /**< Statistics about XSync  */

+    Bool          needsSync;        /**< True if an XSync is pending  */

+

+#ifdef GLXEXT

+                                  /** Visual information for glxProxy */

+    int           numGlxVisuals;

+    __GLXvisualConfig *glxVisuals;

+    int           glxMajorOpcode;

+    int           glxErrorBase;

+

+                                  /** FB config information for glxProxy */

+    __GLXFBConfig *fbconfigs;

+    int           numFBConfigs;

+#endif

+

+                                    /** Function pointers to wrapped screen

+				     *  functions */

+    CloseScreenProcPtr             CloseScreen;

+    SaveScreenProcPtr              SaveScreen;

+

+    CreateGCProcPtr                CreateGC;

+

+    CreateWindowProcPtr            CreateWindow;

+    DestroyWindowProcPtr           DestroyWindow;

+    PositionWindowProcPtr          PositionWindow;

+    ChangeWindowAttributesProcPtr  ChangeWindowAttributes;

+    RealizeWindowProcPtr           RealizeWindow;

+    UnrealizeWindowProcPtr         UnrealizeWindow;

+    RestackWindowProcPtr           RestackWindow;

+    WindowExposuresProcPtr         WindowExposures;

+    CopyWindowProcPtr              CopyWindow;

+

+    ResizeWindowProcPtr            ResizeWindow;

+    ReparentWindowProcPtr          ReparentWindow;

+

+    ChangeBorderWidthProcPtr       ChangeBorderWidth;

+

+    GetImageProcPtr                GetImage;

+    GetSpansProcPtr                GetSpans;

+

+    CreatePixmapProcPtr            CreatePixmap;

+    DestroyPixmapProcPtr           DestroyPixmap;

+    BitmapToRegionProcPtr          BitmapToRegion;

+

+    RealizeFontProcPtr             RealizeFont;

+    UnrealizeFontProcPtr           UnrealizeFont;

+

+    CreateColormapProcPtr          CreateColormap;

+    DestroyColormapProcPtr         DestroyColormap;

+    InstallColormapProcPtr         InstallColormap;

+    StoreColorsProcPtr             StoreColors;

+

+    SetShapeProcPtr                SetShape;

+

+    CreatePictureProcPtr           CreatePicture;

+    DestroyPictureProcPtr          DestroyPicture;

+    ChangePictureClipProcPtr       ChangePictureClip;

+    DestroyPictureClipProcPtr      DestroyPictureClip;

+    

+    ChangePictureProcPtr           ChangePicture;

+    ValidatePictureProcPtr         ValidatePicture;

+

+    CompositeProcPtr               Composite;

+    GlyphsProcPtr                  Glyphs;

+    CompositeRectsProcPtr          CompositeRects;

+

+    InitIndexedProcPtr             InitIndexed;

+    CloseIndexedProcPtr            CloseIndexed;

+    UpdateIndexedProcPtr           UpdateIndexed;

+

+    TrapezoidsProcPtr              Trapezoids;

+    TrianglesProcPtr               Triangles;

+    TriStripProcPtr                TriStrip;

+    TriFanProcPtr                  TriFan;

+} DMXScreenInfo;

+

+/* Global variables available to all Xserver/hw/dmx routines. */

+extern int              dmxNumScreens;          /**< Number of dmxScreens */

+extern DMXScreenInfo   *dmxScreens;             /**< List of outputs */

+extern int              dmxShadowFB;            /**< Non-zero if using

+                                                 * shadow frame-buffer

+                                                 * (deprecated) */

+extern XErrorEvent      dmxLastErrorEvent;      /**< Last error that

+                                                 * occurred */

+extern Bool             dmxErrorOccurred;       /**< True if an error

+                                                 * occurred */

+extern Bool             dmxOffScreenOpt;        /**< True if using off

+                                                 * screen

+                                                 * optimizations */

+extern Bool             dmxSubdividePrimitives; /**< True if using the

+                                                 * primitive subdivision

+                                                 * optimization */

+extern Bool             dmxLazyWindowCreation;  /**< True if using the

+                                                 * lazy window creation

+                                                 * optimization */

+extern Bool             dmxUseXKB;              /**< True if the XKB

+                                                 * extension should be

+                                                 * used with the backend

+                                                 * servers */

+extern int              dmxDepth;               /**< Requested depth if

+                                                 * non-zero */

+#ifdef GLXEXT

+extern Bool             dmxGLXProxy;            /**< True if glxProxy

+						 * support is enabled */

+extern Bool             dmxGLXSwapGroupSupport; /**< True if glxProxy

+						 * support for swap

+						 * groups and barriers

+						 * is enabled */

+extern Bool             dmxGLXSyncSwap;         /**< True if glxProxy

+						 * should force an XSync

+						 * request after each

+						 * swap buffers call */

+extern Bool             dmxGLXFinishSwap;       /**< True if glxProxy

+						 * should force a

+						 * glFinish request

+						 * after each swap

+						 * buffers call */

+#endif

+extern char            *dmxFontPath;            /**< NULL if no font

+						 * path is set on the

+						 * command line;

+						 * otherwise, a string

+						 * of comma separated

+						 * paths built from the

+						 * command line

+						 * specified font

+						 * paths */

+extern Bool             dmxIgnoreBadFontPaths;  /**< True if bad font

+						 * paths should be

+						 * ignored during server

+						 * init */

+extern Bool             dmxAddRemoveScreens;    /**< True if add and

+						 * remove screens support

+						 * is enabled */

+

+/** Wrap screen or GC function pointer */

+#define DMX_WRAP(_entry, _newfunc, _saved, _actual)			\

+do {									\

+    (_saved)->_entry  = (_actual)->_entry;				\

+    (_actual)->_entry = (_newfunc);					\

+} while (0)

+

+/** Unwrap screen or GC function pointer */

+#define DMX_UNWRAP(_entry, _saved, _actual)				\

+do {									\

+    (_actual)->_entry = (_saved)->_entry;				\

+} while (0)

+

+/* Define the MAXSCREENSALLOC/FREE macros, when MAXSCREENS patch has not

+ * been applied to sources. */

+#ifdef MAXSCREENS

+#define MAXSCREEN_MAKECONSTSTR1(x) #x

+#define MAXSCREEN_MAKECONSTSTR2(x) MAXSCREEN_MAKECONSTSTR1(x)

+

+#define MAXSCREEN_FAILED_TXT "Failed at ["                              \

+   MAXSCREEN_MAKECONSTSTR2(__LINE__) ":" __FILE__ "] to allocate object: "

+

+#define _MAXSCREENSALLOCF(o,size,fatal)                                 \

+    do {                                                                \

+        if (!o) {                                                       \

+            o = calloc((size), sizeof(*(o)));                          \

+            if (!o && fatal) FatalError(MAXSCREEN_FAILED_TXT #o);       \

+        }                                                               \

+    } while (0)

+#define _MAXSCREENSALLOCR(o,size,retval)                                \

+    do {                                                                \

+        if (!o) {                                                       \

+            o = calloc((size), sizeof(*(o)));                          \

+            if (!o) return retval;                                      \

+        }                                                               \

+    } while (0)

+        

+#define MAXSCREENSFREE(o)                                               \

+    do {                                                                \

+        free(o);                                                \

+        o = NULL;                                                       \

+    } while (0)

+

+#define MAXSCREENSALLOC(o)              _MAXSCREENSALLOCF(o,MAXSCREENS,  0)

+#define MAXSCREENSALLOC_FATAL(o)        _MAXSCREENSALLOCF(o,MAXSCREENS,  1)

+#define MAXSCREENSALLOC_RETURN(o,r)     _MAXSCREENSALLOCR(o,MAXSCREENS, (r))

+#define MAXSCREENSALLOCPLUSONE(o)       _MAXSCREENSALLOCF(o,MAXSCREENS+1,0)

+#define MAXSCREENSALLOCPLUSONE_FATAL(o) _MAXSCREENSALLOCF(o,MAXSCREENS+1,1)

+#define MAXSCREENSCALLOC(o,m)           _MAXSCREENSALLOCF(o,MAXSCREENS*(m),0)

+#define MAXSCREENSCALLOC_FATAL(o,m)     _MAXSCREENSALLOCF(o,MAXSCREENS*(m),1)

+#endif

+

+extern DevPrivateKeyRec dmxGCPrivateKeyRec;

+#define dmxGCPrivateKey (&dmxGCPrivateKeyRec) /**< Private index for GCs       */

+

+extern DevPrivateKeyRec dmxWinPrivateKeyRec;

+#define dmxWinPrivateKey (&dmxWinPrivateKeyRec) /**< Private index for Windows   */

+

+extern DevPrivateKeyRec dmxPixPrivateKeyRec;

+#define dmxPixPrivateKey (&dmxPixPrivateKeyRec) /**< Private index for Pixmaps   */

+

+extern int dmxFontPrivateIndex;        /**< Private index for Fonts     */

+

+extern DevPrivateKeyRec dmxScreenPrivateKeyRec;

+#define dmxScreenPrivateKey (&dmxScreenPrivateKeyRec) /**< Private index for Screens   */

+

+extern DevPrivateKeyRec dmxColormapPrivateKeyRec;

+#define dmxColormapPrivateKey (&dmxColormapPrivateKeyRec) /**< Private index for Colormaps */

+

+extern DevPrivateKeyRec dmxPictPrivateKeyRec;

+#define dmxPictPrivateKey (&dmxPictPrivateKeyRec) /**< Private index for Picts     */

+

+extern DevPrivateKeyRec dmxGlyphSetPrivateKeyRec;

+#define dmxGlyphSetPrivateKey (&dmxGlyphSetPrivateKeyRec) /**< Private index for GlyphSets */

+

+#endif /* DMX_H */

diff --git a/xorg-server/hw/dmx/dmx_glxvisuals.c b/xorg-server/hw/dmx/dmx_glxvisuals.c
index 50a23e30f..dd77bd23a 100644
--- a/xorg-server/hw/dmx/dmx_glxvisuals.c
+++ b/xorg-server/hw/dmx/dmx_glxvisuals.c
@@ -51,7 +51,7 @@ __GLXvisualConfig *GetGLXVisualConfigs(Display *dpy, int screen, int *nconfigs)
     int   num_good_visuals;

 

     if (!XQueryExtension(dpy, "GLX", &majorOpcode, &dummy, &dummy)) {

-       return(NULL);

+       return NULL;

     }

 

     /* Send the glXGetVisualConfigs request */

@@ -228,7 +228,7 @@ __GLXvisualConfig *GetGLXVisualConfigs(Display *dpy, int screen, int *nconfigs)
     SyncHandle();

 

     *nconfigs = nvisuals;

-    return( configs );

+    return configs;

 }

 

 

@@ -500,7 +500,7 @@ GetGLXVisualConfigsFromFBConfigs(__GLXFBConfig *fbconfigs, int nfbconfigs,
     __GLXvisualConfig *configs = NULL;

     int i;

     

-    if (!fbconfigs || !nfbconfigs || !nconfigs) return(NULL);

+    if (!fbconfigs || !nfbconfigs || !nconfigs) return NULL;

     *nconfigs = 0;

 

     /* Allocate memory for our config structure */

@@ -596,6 +596,6 @@ GetGLXVisualConfigsFromFBConfigs(__GLXFBConfig *fbconfigs, int nfbconfigs,
        }

     }

 

-    return( configs );

+    return configs;

 }

 

diff --git a/xorg-server/hw/dmx/dmxcmap.c b/xorg-server/hw/dmx/dmxcmap.c
index 5a56afda2..1cdc481f0 100644
--- a/xorg-server/hw/dmx/dmxcmap.c
+++ b/xorg-server/hw/dmx/dmxcmap.c
@@ -75,7 +75,7 @@ Bool dmxBECreateColormap(ColormapPtr pColormap)
                                          visual,

                                          (pVisual->class & DynamicClass ?

                                           AllocAll : AllocNone));

-       return (pCmapPriv->cmap != 0);

+       return pCmapPriv->cmap != 0;

     }

     else {

        dmxLog(dmxWarning, "dmxBECreateColormap: No visual found\n");

diff --git a/xorg-server/hw/dmx/dmxcmap.h b/xorg-server/hw/dmx/dmxcmap.h
index f968f8622..499ca7f66 100644
--- a/xorg-server/hw/dmx/dmxcmap.h
+++ b/xorg-server/hw/dmx/dmxcmap.h
@@ -1,69 +1,66 @@
-/*
- * Copyright 2002-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *
- */
-
-/** \file
- * Header file for colormap support.  \see dmxcmap.c. */
-
-#ifndef DMXCMAP_H
-#define DMXCMAP_H
-
-#include "colormapst.h"
-
-/** Colormap private area. */
-typedef struct _dmxColormapPriv {
-    Colormap  cmap;
-} dmxColormapPrivRec, *dmxColormapPrivPtr;
-
-
-extern Bool dmxCreateColormap(ColormapPtr pColormap);
-extern void dmxDestroyColormap(ColormapPtr pColormap);
-extern void dmxInstallColormap(ColormapPtr pColormap);
-extern void dmxStoreColors(ColormapPtr pColormap, int ndef, xColorItem *pdef);
-
-extern Bool dmxCreateDefColormap(ScreenPtr pScreen);
-
-extern Bool dmxBECreateColormap(ColormapPtr pColormap);
-extern Bool dmxBEFreeColormap(ColormapPtr pColormap);
-
-/** Private index.  \see dmxcmap.c \see dmxscrinit.c \see dmxwindow.c */
-extern DevPrivateKey dmxColormapPrivateKey;
-
-/** Set colormap private structure. */
-#define DMX_SET_COLORMAP_PRIV(_pCMap, _pCMapPriv)			\
-    dixSetPrivate(&(_pCMap)->devPrivates, dmxColormapPrivateKey, _pCMapPriv)
-
-/** Get colormap private structure. */
-#define DMX_GET_COLORMAP_PRIV(_pCMap) (dmxColormapPrivPtr)		\
-    dixLookupPrivate(&(_pCMap)->devPrivates, dmxColormapPrivateKey)
-
-#endif /* DMXCMAP_H */
+/*

+ * Copyright 2002-2004 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Kevin E. Martin <kem@redhat.com>

+ *

+ */

+

+/** \file

+ * Header file for colormap support.  \see dmxcmap.c. */

+

+#ifndef DMXCMAP_H

+#define DMXCMAP_H

+

+#include "colormapst.h"

+

+/** Colormap private area. */

+typedef struct _dmxColormapPriv {

+    Colormap  cmap;

+} dmxColormapPrivRec, *dmxColormapPrivPtr;

+

+

+extern Bool dmxCreateColormap(ColormapPtr pColormap);

+extern void dmxDestroyColormap(ColormapPtr pColormap);

+extern void dmxInstallColormap(ColormapPtr pColormap);

+extern void dmxStoreColors(ColormapPtr pColormap, int ndef, xColorItem *pdef);

+

+extern Bool dmxCreateDefColormap(ScreenPtr pScreen);

+

+extern Bool dmxBECreateColormap(ColormapPtr pColormap);

+extern Bool dmxBEFreeColormap(ColormapPtr pColormap);

+

+/** Set colormap private structure. */

+#define DMX_SET_COLORMAP_PRIV(_pCMap, _pCMapPriv)			\

+    dixSetPrivate(&(_pCMap)->devPrivates, dmxColormapPrivateKey, _pCMapPriv)

+

+/** Get colormap private structure. */

+#define DMX_GET_COLORMAP_PRIV(_pCMap) (dmxColormapPrivPtr)		\

+    dixLookupPrivate(&(_pCMap)->devPrivates, dmxColormapPrivateKey)

+

+#endif /* DMXCMAP_H */

diff --git a/xorg-server/hw/dmx/dmxcursor.c b/xorg-server/hw/dmx/dmxcursor.c
index 2d0243343..19f5a4139 100644
--- a/xorg-server/hw/dmx/dmxcursor.c
+++ b/xorg-server/hw/dmx/dmxcursor.c
@@ -230,7 +230,7 @@ static int dmxSLFindNext(int *list)
 /** Make one pass over all the screens and return the number updated. */

 static int dmxTryComputeScreenOrigins(int *screensLeft)

 {

-    ScreenPtr       pScreen;

+    ScreenPtr       pScreen, refScreen;

     DMXScreenInfo   *screen;

     int             i, ref;

     int             changed = 0;

@@ -239,54 +239,56 @@ static int dmxTryComputeScreenOrigins(int *screensLeft)
         if (!screensLeft[i])

             continue;

         screen  = &dmxScreens[i];

+        pScreen = screenInfo.screens[i];

         switch (screen->where) {

         case PosAbsolute:

-            dixScreenOrigins[i].x = screen->whereX;

-            dixScreenOrigins[i].y = screen->whereY;

+            pScreen->x = screen->whereX;

+            pScreen->y = screen->whereY;

             ++changed, screensLeft[i] = 0;

             break;

         case PosRelative:

             ref = screen->whereRefScreen;

             if (screensLeft[ref])

                 break;

-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x + screen->whereX;

-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y + screen->whereY;

+            refScreen = screenInfo.screens[ref];

+            pScreen->x = refScreen->x + screen->whereX;

+            pScreen->y = refScreen->y + screen->whereY;

             ++changed, screensLeft[i] = 0;

             break;

         case PosRightOf:

             ref = screen->whereRefScreen;

             if (screensLeft[ref])

                 break;

-            pScreen = screenInfo.screens[ref];

-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x + pScreen->width;

-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y;

+            refScreen = screenInfo.screens[ref];

+            pScreen->x = refScreen->x + refScreen->width;

+            pScreen->y = refScreen->y;

             ++changed, screensLeft[i] = 0;

             break;

         case PosLeftOf:

             ref = screen->whereRefScreen;

             if (screensLeft[ref])

                 break;

-            pScreen = screenInfo.screens[i];

-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x - pScreen->width;

-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y;

+            refScreen = screenInfo.screens[ref];

+            pScreen->x = refScreen->x - pScreen->width;

+            pScreen->y = refScreen->y;

             ++changed, screensLeft[i] = 0;

             break;

         case PosBelow:

             ref = screen->whereRefScreen;

             if (screensLeft[ref])

                 break;

-            pScreen = screenInfo.screens[ref];

-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x;

-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y + pScreen->height;

+            refScreen = screenInfo.screens[ref];

+            pScreen->x = refScreen->x;

+            pScreen->y = refScreen->y + refScreen->height;

             ++changed, screensLeft[i] = 0;

             break;

         case PosAbove:

             ref = screen->whereRefScreen;

             if (screensLeft[ref])

                 break;

-            pScreen = screenInfo.screens[i];

-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x;

-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y - pScreen->height;

+            refScreen = screenInfo.screens[ref];

+            pScreen->x = refScreen->x;

+            pScreen->y = refScreen->y - pScreen->height;

             ++changed, screensLeft[i] = 0;

             break;

         case PosNone:

@@ -298,6 +300,7 @@ static int dmxTryComputeScreenOrigins(int *screensLeft)
 

 static void dmxComputeScreenOrigins(void)

 {

+    ScreenPtr       pScreen;

     int             *screensLeft;

     int             i, ref;

     int             minX, minY;

@@ -313,8 +316,9 @@ static void dmxComputeScreenOrigins(void)
 	     * guarantees that we will eventually terminate.

 	     */

 	    ref                     = dmxScreens[i].whereRefScreen;

-	    dixScreenOrigins[ref].x = dixScreenOrigins[ref].y = 0;

-            screensLeft[ref]        = 0;

+	    pScreen                 = screenInfo.screens[ref];

+	    pScreen->x = pScreen->y = 0;

+	    screensLeft[ref]        = 0;

 	}

     }

     dmxSLFree(screensLeft);

@@ -322,18 +326,18 @@ static void dmxComputeScreenOrigins(void)
 

                                 /* Justify the topmost and leftmost to

                                  * (0,0). */

-    minX = dixScreenOrigins[0].x;

-    minY = dixScreenOrigins[0].y;

+    minX = screenInfo.screens[0]->x;

+    minY = screenInfo.screens[0]->y;

     for (i = 1; i < dmxNumScreens; i++) { /* Compute minX, minY */

-	if (dixScreenOrigins[i].x < minX)

-            minX = dixScreenOrigins[i].x;

-	if (dixScreenOrigins[i].y < minY)

-            minY = dixScreenOrigins[i].y;

+	if (screenInfo.screens[i]->x < minX)

+            minX = screenInfo.screens[i]->x;

+	if (screenInfo.screens[i]->y < minY)

+            minY = screenInfo.screens[i]->y;

     }

     if (minX || minY) {

 	for (i = 0; i < dmxNumScreens; i++) {

-	    dixScreenOrigins[i].x -= minX;

-	    dixScreenOrigins[i].y -= minY;

+	    screenInfo.screens[i]->x -= minX;

+	    screenInfo.screens[i]->y -= minY;

 	}

     }

 }

@@ -398,8 +402,8 @@ void dmxInitOrigins(void)
 

     for (i = 0; i < dmxNumScreens; i++) {

         DMXScreenInfo  *dmxScreen = &dmxScreens[i];

-        dmxScreen->rootXOrigin = dixScreenOrigins[i].x;

-        dmxScreen->rootYOrigin = dixScreenOrigins[i].y;

+        dmxScreen->rootXOrigin = screenInfo.screens[i]->x;

+        dmxScreen->rootYOrigin = screenInfo.screens[i]->y;

     }

 

     dmxReInitOrigins();

diff --git a/xorg-server/hw/dmx/dmxextension.c b/xorg-server/hw/dmx/dmxextension.c
index c8e8dae65..25a10c015 100644
--- a/xorg-server/hw/dmx/dmxextension.c
+++ b/xorg-server/hw/dmx/dmxextension.c
@@ -1,1616 +1,1616 @@
-/*
- * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Author:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *   Kevin E. Martin <kem@redhat.com>
- *
- */
-
-/** \file
- * This file provides the only interface to the X server extension support
- * in programs/Xserver/Xext.  Those programs should only include dmxext.h
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include <stdlib.h>
-
-#include "dmx.h"
-#include "dmxinit.h"
-#include "dmxextension.h"
-#include "dmxwindow.h"
-#include "dmxcb.h"
-#include "dmxcursor.h"
-#include "dmxpixmap.h"
-#include "dmxgc.h"
-#include "dmxfont.h"
-#include "dmxcmap.h"
-#include "dmxpict.h"
-#include "dmxinput.h"
-#include "dmxsync.h"
-#include "dmxscrinit.h"
-#include "input/dmxinputinit.h"
-
-#include "windowstr.h"
-#include "inputstr.h"                 /* For DeviceIntRec */
-#include <X11/extensions/dmxproto.h>  /* For DMX_BAD_* */
-#include "cursorstr.h"
-
-/* The default font is declared in dix/globals.c, but is not included in
- * _any_ header files. */
-extern FontPtr  defaultFont;
-    
-/** This routine provides information to the DMX protocol extension
- * about a particular screen. */
-Bool dmxGetScreenAttributes(int physical, DMXScreenAttributesPtr attr)
-{
-    DMXScreenInfo *dmxScreen;
-
-    if (physical < 0 || physical >= dmxNumScreens) return FALSE;
-
-    dmxScreen = &dmxScreens[physical];
-    attr->displayName         = dmxScreen->name;
-#ifdef PANORAMIX
-    attr->logicalScreen       = noPanoramiXExtension ? dmxScreen->index : 0;
-#else
-    attr->logicalScreen       = dmxScreen->index;
-#endif
-
-    attr->screenWindowWidth   = dmxScreen->scrnWidth;
-    attr->screenWindowHeight  = dmxScreen->scrnHeight;
-    attr->screenWindowXoffset = dmxScreen->scrnX;
-    attr->screenWindowYoffset = dmxScreen->scrnY;
-
-    attr->rootWindowWidth     = dmxScreen->rootWidth;
-    attr->rootWindowHeight    = dmxScreen->rootHeight;
-    attr->rootWindowXoffset   = dmxScreen->rootX;
-    attr->rootWindowYoffset   = dmxScreen->rootY;
-
-    attr->rootWindowXorigin   = dmxScreen->rootXOrigin;
-    attr->rootWindowYorigin   = dmxScreen->rootYOrigin;
-
-    return TRUE;
-}
-
-/** This routine provides information to the DMX protocol extension
- * about a particular window. */
-Bool dmxGetWindowAttributes(WindowPtr pWindow, DMXWindowAttributesPtr attr)
-{
-    dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);
-
-    attr->screen         = pWindow->drawable.pScreen->myNum;
-    attr->window         = pWinPriv->window;
-
-    attr->pos.x          = pWindow->drawable.x;
-    attr->pos.y          = pWindow->drawable.y;
-    attr->pos.width      = pWindow->drawable.width;
-    attr->pos.height     = pWindow->drawable.height;
-
-    if (!pWinPriv->window || pWinPriv->offscreen) {
-        attr->vis.x      = 0;
-        attr->vis.y      = 0;
-        attr->vis.height = 0;
-        attr->vis.width  = 0;
-        return pWinPriv->window ? TRUE : FALSE;
-    }
-
-                                /* Compute display-relative coordinates */
-    attr->vis.x          = pWindow->drawable.x;
-    attr->vis.y          = pWindow->drawable.y;
-    attr->vis.width      = pWindow->drawable.width;
-    attr->vis.height     = pWindow->drawable.height;
-
-    if (attr->pos.x < 0) {
-        attr->vis.x     -= attr->pos.x;
-        attr->vis.width  = attr->pos.x + attr->pos.width - attr->vis.x;
-    }
-    if (attr->pos.x + attr->pos.width > pWindow->drawable.pScreen->width) {
-        if (attr->pos.x < 0)
-            attr->vis.width  = pWindow->drawable.pScreen->width;
-        else
-            attr->vis.width  = pWindow->drawable.pScreen->width - attr->pos.x;
-    }
-    if (attr->pos.y < 0) {
-        attr->vis.y     -= attr->pos.y;
-        attr->vis.height = attr->pos.y + attr->pos.height - attr->vis.y;
-    }
-    if (attr->pos.y + attr->pos.height > pWindow->drawable.pScreen->height) {
-        if (attr->pos.y < 0)
-            attr->vis.height = pWindow->drawable.pScreen->height;
-        else
-            attr->vis.height = pWindow->drawable.pScreen->height - attr->pos.y;
-    }
-
-                                /* Convert to window-relative coordinates */
-    attr->vis.x -= attr->pos.x;
-    attr->vis.y -= attr->pos.y;
-
-    return TRUE;
-}
-
-void dmxGetDesktopAttributes(DMXDesktopAttributesPtr attr)
-{
-    attr->width  = dmxGlobalWidth;
-    attr->height = dmxGlobalHeight;
-    attr->shiftX = 0;            /* NOTE: The upper left hand corner of */
-    attr->shiftY = 0;            /*       the desktop is always <0,0>. */
-}
-
-/** Return the total number of devices, not just #dmxNumInputs.  The
- * number returned should be the same as that returned by
- * XListInputDevices. */
-int dmxGetInputCount(void)
-{
-    int i, total;
-    
-    for (total = i = 0; i < dmxNumInputs; i++) total += dmxInputs[i].numDevs;
-    return total;
-}
-
-/** Return information about the device with id = \a deviceId.  This
- * information is primarily for the #ProcDMXGetInputAttributes()
- * function, which does not have access to the appropriate data
- * structure. */
-int dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr)
-{
-    int          i, j;
-    DMXInputInfo *dmxInput;
-
-    if (deviceId < 0) return -1;
-    for (i = 0; i < dmxNumInputs; i++) {
-        dmxInput = &dmxInputs[i];
-        for (j = 0; j < dmxInput->numDevs; j++) {
-            DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[j];
-            if (deviceId != dmxLocal->pDevice->id) continue;
-            attr->isCore             = !!dmxLocal->isCore;
-            attr->sendsCore          = !!dmxLocal->sendsCore;
-            attr->detached           = !!dmxInput->detached;
-            attr->physicalScreen     = -1;
-            attr->physicalId         = -1;
-            attr->name               = NULL;
-            switch (dmxLocal->extType) {
-            case DMX_LOCAL_TYPE_LOCAL:
-                attr->inputType      = 0;
-                break;
-            case DMX_LOCAL_TYPE_CONSOLE:
-                attr->inputType      = 1;
-                attr->name           = dmxInput->name;
-                attr->physicalId     = dmxLocal->deviceId;
-                break;
-            case DMX_LOCAL_TYPE_BACKEND:
-            case DMX_LOCAL_TYPE_COMMON:
-                attr->inputType      = 2;
-                attr->physicalScreen = dmxInput->scrnIdx;
-                attr->name           = dmxInput->name;
-                attr->physicalId     = dmxLocal->deviceId;
-                break;
-            }
-            return 0;           /* Success */
-        }
-    }
-    return -1;                  /* Failure */
-}
-
-/** Reinitialized the cursor boundaries. */
-static void dmxAdjustCursorBoundaries(void)
-{
-    int           i;
-
-    dmxReInitOrigins();
-    dmxInitOverlap();
-    dmxComputeWidthHeight(DMX_NO_RECOMPUTE_BOUNDING_BOX);
-    dmxConnectionBlockCallback();
-    for (i = 0; i < dmxNumInputs; i++) {
-        DMXInputInfo *dmxInput = &dmxInputs[i];
-	if (!dmxInput->detached) dmxInputReInit(dmxInput);
-    }
-
-    dmxCheckCursor();
-
-    for (i = 0; i < dmxNumInputs; i++) {
-        DMXInputInfo *dmxInput = &dmxInputs[i];
-	if (!dmxInput->detached) dmxInputLateReInit(dmxInput);
-    }
-}
-
-/** Add an input with the specified attributes.  If the input is added,
- * the physical id is returned in \a deviceId. */
-int dmxAddInput(DMXInputAttributesPtr attr, int *id)
-{
-    int retcode = BadValue;
-
-    if (attr->inputType == 1)   /* console */
-        retcode = dmxInputAttachConsole(attr->name, attr->sendsCore, id);
-    else if (attr->inputType == 2)   /* backend */
-        retcode = dmxInputAttachBackend(attr->physicalScreen,
-                                        attr->sendsCore,id);
-
-    if (retcode == Success) {
-        /* Adjust the cursor boundaries */
-        dmxAdjustCursorBoundaries();
-
-        /* Force completion of the changes */
-        dmxSync(NULL, TRUE);
-    }
-
-    return retcode;
-}
-
-/** Remove the input with physical id \a id. */
-int dmxRemoveInput(int id)
-{
-    return dmxInputDetachId(id);
-}
-
-/** Return the value of #dmxNumScreens -- the total number of backend
- * screens in use (these are logical screens and may be larger than the
- * number of backend displays). */
-unsigned long dmxGetNumScreens(void)
-{
-    return dmxNumScreens;
-}
-
-/** Make sure that #dmxCreateAndRealizeWindow has been called for \a
- * pWindow. */
-void dmxForceWindowCreation(WindowPtr pWindow)
-{
-    dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);
-    if (!pWinPriv->window) dmxCreateAndRealizeWindow(pWindow, TRUE);
-}
-
-/** Flush pending syncs for all screens. */
-void dmxFlushPendingSyncs(void)
-{
-    dmxSync(NULL, TRUE);
-}
-
-/** Update DMX's screen resources to match those of the newly moved
- *  and/or resized "root" window. */
-void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
-    WindowPtr      pRoot     = WindowTable[pScreen->myNum];
-    WindowPtr      pChild;
-    Bool           anyMarked = FALSE;
-
-    /* Handle special case where width and/or height are zero */
-    if (w == 0 || h == 0) {
-	w = 1;
-	h = 1;
-    }
-
-    /* Change screen size */
-    pScreen->width  = w;
-    pScreen->height = h;
-
-    /* Reset the root window's drawable's size */
-    pRoot->drawable.width  = w;
-    pRoot->drawable.height = h;
-
-    /* Set the root window's new winSize and borderSize */
-    pRoot->winSize.extents.x1 = 0;
-    pRoot->winSize.extents.y1 = 0;
-    pRoot->winSize.extents.x2 = w;
-    pRoot->winSize.extents.y2 = h;
-
-    pRoot->borderSize.extents.x1 = 0;
-    pRoot->borderSize.extents.y1 = 0;
-    pRoot->borderSize.extents.x2 = w;
-    pRoot->borderSize.extents.y2 = h;
-
-    /* Recompute this screen's mmWidth & mmHeight */
-    pScreen->mmWidth =
-	(w * 254 + dmxScreen->beXDPI * 5) / (dmxScreen->beXDPI * 10);
-    pScreen->mmHeight =
-	(h * 254 + dmxScreen->beYDPI * 5) / (dmxScreen->beYDPI * 10);
-
-    /* Recompute this screen's window's clip rects as follows: */
-    /*   1. Mark all of root's children's windows */
-    for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib)
-	anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild,
-						    (WindowPtr *)NULL);
-
-    /*   2. Set the root window's borderClip */
-    pRoot->borderClip.extents.x1 = 0;
-    pRoot->borderClip.extents.y1 = 0;
-    pRoot->borderClip.extents.x2 = w;
-    pRoot->borderClip.extents.y2 = h;
-
-    /*   3. Set the root window's clipList */
-    if (anyMarked) {
-	/* If any windows have been marked, set the root window's
-	 * clipList to be broken since it will be recalculated in
-	 * ValidateTree()
-	 */
-	REGION_BREAK(pScreen, &pRoot->clipList);
-    } else {
-	/* Otherwise, we just set it directly since there are no
-	 * windows visible on this screen
-	 */
-	pRoot->clipList.extents.x1 = 0;
-	pRoot->clipList.extents.y1 = 0;
-	pRoot->clipList.extents.x2 = w;
-	pRoot->clipList.extents.y2 = h;
-    }
-
-    /*   4. Revalidate all clip rects and generate expose events */
-    if (anyMarked) {
-	pScreen->ValidateTree(pRoot, NULL, VTBroken);
-	pScreen->HandleExposures(pRoot);
-	if (pScreen->PostValidateTree)
-	    pScreen->PostValidateTree(pRoot, NULL, VTBroken);
-    }
-}
-
-#ifdef PANORAMIX
-#include "panoramiXsrv.h"
-
-/** Change the "screen" window attributes by resizing the actual window
- *  on the back-end display (if necessary). */
-static void dmxConfigureScreenWindow(int idx,
-				     int x, int y, int w, int h)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    ScreenPtr      pScreen   = screenInfo.screens[idx];
-
-    /* Resize "screen" window */
-    if (dmxScreen->scrnX      != x ||
-	dmxScreen->scrnY      != y ||
-	dmxScreen->scrnWidth  != w ||
-	dmxScreen->scrnHeight != h) {
-	dmxResizeScreenWindow(pScreen, x, y, w, h);
-    }
-
-    /* Change "screen" window values */
-    dmxScreen->scrnX      = x;
-    dmxScreen->scrnY      = y;
-    dmxScreen->scrnWidth  = w;
-    dmxScreen->scrnHeight = h;
-}
-				     
-/** Change the "root" window position and size by resizing the actual
- *  window on the back-end display (if necessary) and updating all of
- *  DMX's resources by calling #dmxUpdateScreenResources. */
-static void dmxConfigureRootWindow(int idx, int x, int y, int w, int h)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    WindowPtr      pRoot     = WindowTable[idx];
-
-    /* NOTE: Either this function or the ones that it calls must handle
-     * the case where w == 0 || h == 0.  Currently, the functions that
-     * this one calls handle that case. */
-
-    /* 1. Resize "root" window */
-    if (dmxScreen->rootX      != x ||
-	dmxScreen->rootY      != y ||
-	dmxScreen->rootWidth  != w ||
-	dmxScreen->rootHeight != h) {
-	dmxResizeRootWindow(pRoot, x, y, w, h);
-    }
-
-    /* 2. Update all of the screen's resources associated with this root
-     *    window */
-    if (dmxScreen->rootWidth  != w ||
-	dmxScreen->rootHeight != h) {
-	dmxUpdateScreenResources(screenInfo.screens[idx], x, y, w, h);
-    }
-
-    /* Change "root" window values */
-    dmxScreen->rootX      = x;
-    dmxScreen->rootY      = y;
-    dmxScreen->rootWidth  = w;
-    dmxScreen->rootHeight = h;
-}
-
-/** Change the "root" window's origin by updating DMX's internal data
- *  structures (dix and Xinerama) to use the new origin and adjust the
- *  positions of windows that overlap this "root" window. */
-static void dmxSetRootWindowOrigin(int idx, int x, int y)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    ScreenPtr      pScreen   = screenInfo.screens[idx];
-    WindowPtr      pRoot     = WindowTable[idx];
-    WindowPtr      pChild;
-    int            xoff;
-    int            yoff;
-
-    /* Change "root" window's origin */
-    dmxScreen->rootXOrigin = x;
-    dmxScreen->rootYOrigin = y;
-
-    /* Compute offsets here in case <x,y> has been changed above */
-    xoff = x - dixScreenOrigins[idx].x;
-    yoff = y - dixScreenOrigins[idx].y;
-
-    /* Adjust the root window's position in dixScreenOrigins */
-    dixScreenOrigins[idx].x = dmxScreen->rootXOrigin;
-    dixScreenOrigins[idx].y = dmxScreen->rootYOrigin;
-
-    /* Recalculate the Xinerama regions and data structs */
-    XineramaReinitData(pScreen);
-
-    /* Adjust each of the root window's children */
-    if (!idx) ReinitializeRootWindow(WindowTable[0], xoff, yoff);
-    pChild = pRoot->firstChild;
-    while (pChild) {
-	/* Adjust child window's position */
-	pScreen->MoveWindow(pChild,
-			    pChild->origin.x - wBorderWidth(pChild) - xoff,
-			    pChild->origin.y - wBorderWidth(pChild) - yoff,
-			    pChild->nextSib,
-			    VTMove);
-
-	/* Note that the call to MoveWindow will eventually call
-	 * dmxPositionWindow which will automatically create a
-	 * window if it is now exposed on screen (for lazy window
-	 * creation optimization) and it will properly set the
-	 * offscreen flag.
-	 */
-
-	pChild = pChild->nextSib;
-    }
-}
-
-/** Configure the attributes of each "screen" and "root" window. */
-int dmxConfigureScreenWindows(int nscreens,
-			      CARD32 *screens,
-			      DMXScreenAttributesPtr attribs,
-			      int *errorScreen)
-{
-    int           i;
-
-    for (i = 0; i < nscreens; i++) {
-	DMXScreenAttributesPtr  attr      = &attribs[i];
-	int                     idx       = screens[i];
-	DMXScreenInfo          *dmxScreen = &dmxScreens[idx];
-
-	if (errorScreen) *errorScreen = i;
-
-	if (!dmxScreen->beDisplay) return DMX_BAD_VALUE;
-
-	/* Check for illegal values */
-	if (idx < 0 || idx >= dmxNumScreens) return BadValue;
-
-	/* The "screen" and "root" windows must have valid sizes */
-	if (attr->screenWindowWidth <= 0 || attr->screenWindowHeight <= 0 ||
-	    attr->rootWindowWidth   <  0 || attr->rootWindowHeight   <  0)
-	    return DMX_BAD_VALUE;
-
-	/* The "screen" window must fit entirely within the BE display */
-	if (attr->screenWindowXoffset < 0 ||
-	    attr->screenWindowYoffset < 0 ||
-	    attr->screenWindowXoffset
-	    + attr->screenWindowWidth  > (unsigned)dmxScreen->beWidth ||
-	    attr->screenWindowYoffset
-	    + attr->screenWindowHeight > (unsigned)dmxScreen->beHeight)
-	    return DMX_BAD_VALUE;
-
-	/* The "root" window must fit entirely within the "screen" window */
-	if (attr->rootWindowXoffset < 0 ||
-	    attr->rootWindowYoffset < 0 ||
-	    attr->rootWindowXoffset
-	    + attr->rootWindowWidth  > attr->screenWindowWidth ||
-	    attr->rootWindowYoffset
-	    + attr->rootWindowHeight > attr->screenWindowHeight)
-	    return DMX_BAD_VALUE;
-
-	/* The "root" window must not expose unaddressable coordinates */
-	if (attr->rootWindowXorigin < 0 ||
-	    attr->rootWindowYorigin < 0 ||
-	    attr->rootWindowXorigin + attr->rootWindowWidth  > 32767 ||
-	    attr->rootWindowYorigin + attr->rootWindowHeight > 32767)
-	    return DMX_BAD_VALUE;
-
-	/* The "root" window must fit within the global bounding box */
-	if (attr->rootWindowXorigin
-	    + attr->rootWindowWidth > (unsigned)dmxGlobalWidth ||
-	    attr->rootWindowYorigin
-	    + attr->rootWindowHeight > (unsigned)dmxGlobalHeight)
-	    return DMX_BAD_VALUE;
-
-	/* FIXME: Handle the rest of the illegal value checking */
-    }
-
-    /* No illegal values found */
-    if (errorScreen) *errorScreen = 0;
-
-    for (i = 0; i < nscreens; i++) {
-	DMXScreenAttributesPtr  attr      = &attribs[i];
-	int                     idx       = screens[i];
-	DMXScreenInfo          *dmxScreen = &dmxScreens[idx];
-
-	dmxLog(dmxInfo, "Changing screen #%d attributes "
-	       "from %dx%d+%d+%d %dx%d+%d+%d +%d+%d "
-	       "to %dx%d+%d+%d %dx%d+%d+%d +%d+%d\n",
-	       idx,
-	       dmxScreen->scrnWidth,      dmxScreen->scrnHeight,
-	       dmxScreen->scrnX,          dmxScreen->scrnY,
-	       dmxScreen->rootWidth,      dmxScreen->rootHeight,
-	       dmxScreen->rootX,          dmxScreen->rootY,
-	       dmxScreen->rootXOrigin,    dmxScreen->rootYOrigin,
-	       attr->screenWindowWidth,   attr->screenWindowHeight,
-	       attr->screenWindowXoffset, attr->screenWindowYoffset,
-	       attr->rootWindowWidth,     attr->rootWindowHeight,
-	       attr->rootWindowXoffset,   attr->rootWindowYoffset,
-	       attr->rootWindowXorigin,   attr->rootWindowYorigin);
-
-	/* Configure "screen" window */
-	dmxConfigureScreenWindow(idx,
-				 attr->screenWindowXoffset,
-				 attr->screenWindowYoffset,
-				 attr->screenWindowWidth,
-				 attr->screenWindowHeight);
-
-	/* Configure "root" window */
-	dmxConfigureRootWindow(idx,
-			       attr->rootWindowXoffset,
-			       attr->rootWindowYoffset,
-			       attr->rootWindowWidth,
-			       attr->rootWindowHeight);
-
-
-	/* Set "root" window's origin */
-	dmxSetRootWindowOrigin(idx,
-			       attr->rootWindowXorigin,
-			       attr->rootWindowYorigin);
-    }
-
-    /* Adjust the cursor boundaries */
-    dmxAdjustCursorBoundaries();
-
-    /* Force completion of the changes */
-    dmxSync(NULL, TRUE);
-
-    return Success;
-}
-
-/** Configure the attributes of the global desktop. */
-int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)
-{
-    if (attribs->width  <= 0 || attribs->width  >= 32767 ||
-	attribs->height <= 0 || attribs->height >= 32767)
-	return DMX_BAD_VALUE;
-
-    /* If the desktop is shrinking, adjust the "root" windows on each
-     * "screen" window to only show the visible desktop.  Also, handle
-     * the special case where the desktop shrinks such that the it no
-     * longer overlaps an portion of a "screen" window. */
-    if (attribs->width < dmxGlobalWidth || attribs->height < dmxGlobalHeight) {
-	int   i;
-	for (i = 0; i < dmxNumScreens; i++) {
-	    DMXScreenInfo *dmxScreen = &dmxScreens[i];
-	    if (dmxScreen->rootXOrigin
-		+ dmxScreen->rootWidth  > attribs->width ||
-		dmxScreen->rootYOrigin
-		+ dmxScreen->rootHeight > attribs->height) {
-		int  w, h;
-		if ((w = attribs->width  - dmxScreen->rootXOrigin) < 0) w = 0;
-		if ((h = attribs->height - dmxScreen->rootYOrigin) < 0) h = 0;
-		if (w > dmxScreen->scrnWidth)  w = dmxScreen->scrnWidth;
-		if (h > dmxScreen->scrnHeight) h = dmxScreen->scrnHeight;
-		if (w > dmxScreen->rootWidth)  w = dmxScreen->rootWidth;
-		if (h > dmxScreen->rootHeight) h = dmxScreen->rootHeight;
-		dmxConfigureRootWindow(i,
-				       dmxScreen->rootX,
-				       dmxScreen->rootY,
-				       w, h);
-	    }
-	}
-    }
-
-    /* Set the global width/height */
-    dmxSetWidthHeight(attribs->width, attribs->height);
-
-    /* Handle shift[XY] changes */
-    if (attribs->shiftX || attribs->shiftY) {
-	int   i;
-	for (i = 0; i < dmxNumScreens; i++) {
-	    ScreenPtr  pScreen = screenInfo.screens[i];
-	    WindowPtr  pChild  = WindowTable[i]->firstChild;
-	    while (pChild) {
-		/* Adjust child window's position */
-		pScreen->MoveWindow(pChild,
-				    pChild->origin.x - wBorderWidth(pChild)
-				    - attribs->shiftX,
-				    pChild->origin.y - wBorderWidth(pChild)
-				    - attribs->shiftY,
-				    pChild->nextSib,
-				    VTMove);
-
-		/* Note that the call to MoveWindow will eventually call
-		 * dmxPositionWindow which will automatically create a
-		 * window if it is now exposed on screen (for lazy
-		 * window creation optimization) and it will properly
-		 * set the offscreen flag.
-		 */
-
-		pChild = pChild->nextSib;
-	    }
-	}
-    }
-
-    /* Update connection block, Xinerama, etc. -- these appears to
-     * already be handled in dmxConnectionBlockCallback(), which is
-     * called from dmxAdjustCursorBoundaries() [below]. */
-
-    /* Adjust the cursor boundaries */
-    dmxAdjustCursorBoundaries();
-
-    /* Force completion of the changes */
-    dmxSync(NULL, TRUE);
-
-    return Success;
-}
-#endif
-
-/** Create the scratch GCs per depth. */
-static void dmxBECreateScratchGCs(int scrnNum)
-{
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
-    GCPtr     *ppGC    = pScreen->GCperDepth;
-    int        i;
-
-    for (i = 0; i <= pScreen->numDepths; i++)
-	dmxBECreateGC(pScreen, ppGC[i]);
-}
-
-#ifdef PANORAMIX
-static Bool FoundPixImage;
-
-/** Search the Xinerama XRT_PIXMAP resources for the pixmap that needs
- *  to have its image restored.  When it is found, see if there is
- *  another screen with the same image.  If so, copy the pixmap image
- *  from the existing screen to the newly created pixmap. */
-static void dmxBERestorePixmapImage(pointer value, XID id, RESTYPE type,
-				    pointer p)
-{
-    if ((type & TypeMask) == (XRT_PIXMAP & TypeMask)) {
-	PixmapPtr      pDst     = (PixmapPtr)p;
-	int            idx      = pDst->drawable.pScreen->myNum;
-	PanoramiXRes  *pXinPix  = (PanoramiXRes *)value;
-	PixmapPtr      pPix;
-	int            i;
-
-	pPix = (PixmapPtr)LookupIDByType(pXinPix->info[idx].id, RT_PIXMAP);
-	if (pPix != pDst) return; /* Not a match.... Next! */
-
-	for (i = 0; i < PanoramiXNumScreens; i++) {
-	    PixmapPtr      pSrc;
-	    dmxPixPrivPtr  pSrcPriv = NULL;
-
-	    if (i == idx) continue; /* Self replication is bad */
-
-	    pSrc =
-		(PixmapPtr)LookupIDByType(pXinPix->info[i].id, RT_PIXMAP);
-	    pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
-	    if (pSrcPriv->pixmap) {
-		DMXScreenInfo *dmxSrcScreen = &dmxScreens[i];
-		DMXScreenInfo *dmxDstScreen = &dmxScreens[idx];
-		dmxPixPrivPtr  pDstPriv = DMX_GET_PIXMAP_PRIV(pDst);
-		XImage        *img;
-		int            j;
-		XlibGC         gc = NULL;
-
-		/* This should never happen, but just in case.... */
-		if (pSrc->drawable.width  != pDst->drawable.width ||
-		    pSrc->drawable.height != pDst->drawable.height)
-		    return;
-
-		/* Copy from src pixmap to dst pixmap */
-		img = XGetImage(dmxSrcScreen->beDisplay,
-				pSrcPriv->pixmap,
-				0, 0,
-				pSrc->drawable.width, pSrc->drawable.height,
-				-1,
-				ZPixmap);
-
-		for (j = 0; j < dmxDstScreen->beNumPixmapFormats; j++) {
-		    if (dmxDstScreen->bePixmapFormats[j].depth == img->depth) {
-			unsigned long  m;
-			XGCValues      v;
-
-			m = GCFunction | GCPlaneMask | GCClipMask;
-			v.function = GXcopy;
-			v.plane_mask = AllPlanes;
-			v.clip_mask = None;
-
-			gc = XCreateGC(dmxDstScreen->beDisplay,
-				       dmxDstScreen->scrnDefDrawables[j],
-				       m, &v);
-			break;
-		    }
-		}
-
-		if (gc) {
-		    XPutImage(dmxDstScreen->beDisplay,
-			      pDstPriv->pixmap,
-			      gc, img, 0, 0, 0, 0,
-			      pDst->drawable.width, pDst->drawable.height);
-		    XFreeGC(dmxDstScreen->beDisplay, gc);
-		    FoundPixImage = True;
-		} else {
-		    dmxLog(dmxWarning, "Could not create GC\n");
-		}
-
-		XDestroyImage(img);
-		return;
-	    }
-	}
-    }
-}
-#endif
-
-/** Restore the pixmap image either from another screen or from an image
- *  that was saved when the screen was previously detached. */
-static void dmxBERestorePixmap(PixmapPtr pPixmap)
-{
-#ifdef PANORAMIX
-    int i;
-
-    /* If Xinerama is not active, there's nothing we can do (see comment
-     * in #else below for more info). */
-    if (noPanoramiXExtension) {
-	dmxLog(dmxWarning, "Cannot restore pixmap image\n");
-	return;
-    }
-
-    FoundPixImage = False;
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindAllClientResources(clients[i], dmxBERestorePixmapImage,
-				   (pointer)pPixmap);
-
-    /* No corresponding pixmap image was found on other screens, so we
-     * need to copy it from the saved image when the screen was detached
-     * (if available). */
-    if (!FoundPixImage) {
-	dmxPixPrivPtr  pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap);
-
-	if (pPixPriv->detachedImage) {
-	    ScreenPtr      pScreen   = pPixmap->drawable.pScreen;
-	    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
-	    XlibGC         gc        = NULL;
-
-	    for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) {
-		if (dmxScreen->bePixmapFormats[i].depth ==
-		    pPixPriv->detachedImage->depth) {
-		    unsigned long  m;
-		    XGCValues      v;
-
-		    m = GCFunction | GCPlaneMask | GCClipMask;
-		    v.function = GXcopy;
-		    v.plane_mask = AllPlanes;
-		    v.clip_mask = None;
-
-		    gc = XCreateGC(dmxScreen->beDisplay,
-				   dmxScreen->scrnDefDrawables[i],
-				   m, &v);
-		    break;
-		}
-	    }
-
-	    if (gc) {
-		XPutImage(dmxScreen->beDisplay,
-			  pPixPriv->pixmap,
-			  gc,
-			  pPixPriv->detachedImage,
-			  0, 0, 0, 0,
-		      pPixmap->drawable.width, pPixmap->drawable.height);
-		XFreeGC(dmxScreen->beDisplay, gc);
-	    } else {
-		dmxLog(dmxWarning, "Cannot restore pixmap image\n");
-	    }
-
-	    XDestroyImage(pPixPriv->detachedImage);
-	    pPixPriv->detachedImage = NULL;
-	} else {
-	    dmxLog(dmxWarning, "Cannot restore pixmap image\n");
-	}
-    }
-#else
-    /* If Xinerama is not enabled, then there is no other copy of the
-     * pixmap image that we can restore.  Saving all pixmap data is not
-     * a feasible option since there is no mechanism for updating pixmap
-     * data when a screen is detached, which means that the data that
-     * was previously saved would most likely be out of date. */
-    dmxLog(dmxWarning, "Cannot restore pixmap image\n");
-    return;
-#endif
-}
-
-/** Create resources on the back-end server.  This function is called
- *  from #dmxAttachScreen() via the dix layer's FindAllResources
- *  function.  It walks all resources, compares them to the screen
- *  number passed in as \a n and calls the appropriate DMX function to
- *  create the associated resource on the back-end server. */
-static void dmxBECreateResources(pointer value, XID id, RESTYPE type,
-				 pointer n)
-{
-    int        scrnNum = (int)n;
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
-
-    if ((type & TypeMask) == (RT_WINDOW & TypeMask)) {
-	/* Window resources are created below in dmxBECreateWindowTree */
-    } else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) {
-	PixmapPtr  pPix = value;
-	if (pPix->drawable.pScreen->myNum == scrnNum) {
-	    dmxBECreatePixmap(pPix);
-	    dmxBERestorePixmap(pPix);
-	}
-    } else if ((type & TypeMask) == (RT_GC & TypeMask)) {
-	GCPtr  pGC = value;
-	if (pGC->pScreen->myNum == scrnNum) {
-	    /* Create the GC on the back-end server */
-	    dmxBECreateGC(pScreen, pGC);
-	    /* Create any pixmaps associated with this GC */
-	    if (!pGC->tileIsPixel) {
-		dmxBECreatePixmap(pGC->tile.pixmap);
-		dmxBERestorePixmap(pGC->tile.pixmap);
-	    }
-	    if (pGC->stipple != pScreen->PixmapPerDepth[0]) {
-		dmxBECreatePixmap(pGC->stipple);
-		dmxBERestorePixmap(pGC->stipple);
-	    }
-	    if (pGC->font != defaultFont) {
-		(void)dmxBELoadFont(pScreen, pGC->font);
-	    }
-	    /* Update the GC on the back-end server */
-	    dmxChangeGC(pGC, -1L);
-	}
-    } else if ((type & TypeMask) == (RT_FONT & TypeMask)) {
-	(void)dmxBELoadFont(pScreen, (FontPtr)value);
-    } else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) {
-	dmxBECreateCursor(pScreen, (CursorPtr)value);
-    } else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) {
-	ColormapPtr  pCmap = value;
-	if (pCmap->pScreen->myNum == scrnNum)
-	    (void)dmxBECreateColormap((ColormapPtr)value);
-#if 0
-    /* TODO: Recreate Picture and GlyphSet resources */
-    } else if ((type & TypeMask) == (PictureType & TypeMask)) {
-	/* Picture resources are created when windows are created */
-    } else if ((type & TypeMask) == (GlyphSetType & TypeMask)) {
-	dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr)value);
-#endif
-    } else {
-	/* Other resource types??? */
-    }
-}
-
-/** Create window hierachy on back-end server.  The window tree is
- *  created in a special order (bottom most subwindow first) so that the
- *  #dmxCreateNonRootWindow() function does not need to recursively call
- *  itself to create each window's parents.  This is required so that we
- *  have the opportunity to create each window's border and background
- *  pixmaps (where appropriate) before the window is created. */
-static void dmxBECreateWindowTree(int idx)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    WindowPtr      pRoot     = WindowTable[idx];
-    dmxWinPrivPtr  pWinPriv  = DMX_GET_WINDOW_PRIV(pRoot);
-    WindowPtr      pWin;
-
-    /* Create the pixmaps associated with the root window */
-    if (!pRoot->borderIsPixel) {
-	dmxBECreatePixmap(pRoot->border.pixmap);
-	dmxBERestorePixmap(pRoot->border.pixmap);
-    }
-    if (pRoot->backgroundState == BackgroundPixmap) {
-	dmxBECreatePixmap(pRoot->background.pixmap);
-	dmxBERestorePixmap(pRoot->background.pixmap);
-    }
-
-    /* Create root window first */
-    dmxScreen->rootWin = pWinPriv->window = dmxCreateRootWindow(pRoot);
-    XMapWindow(dmxScreen->beDisplay, dmxScreen->rootWin);
-
-    pWin = pRoot->lastChild;
-    while (pWin) {
-	pWinPriv = DMX_GET_WINDOW_PRIV(pWin);
-
-	/* Create the pixmaps regardless of whether or not the
-	 * window is created or not due to lazy window creation.
-	 */
-	if (!pWin->borderIsPixel) {
-	    dmxBECreatePixmap(pWin->border.pixmap);
-	    dmxBERestorePixmap(pWin->border.pixmap);
-	}
-	if (pWin->backgroundState == BackgroundPixmap) {
-	    dmxBECreatePixmap(pWin->background.pixmap);
-	    dmxBERestorePixmap(pWin->background.pixmap);
-	}
-
-	/* Reset the window attributes */
-	dmxGetDefaultWindowAttributes(pWin,
-				      &pWinPriv->cmap,
-				      &pWinPriv->visual);
-
-	/* Create the window */
-	if (pWinPriv->mapped && !pWinPriv->offscreen)
-	    dmxCreateAndRealizeWindow(pWin, TRUE);
-
-	/* Next, create the bottom-most child */
-	if (pWin->lastChild) {
-	    pWin = pWin->lastChild;
-	    continue;
-	}
-
-	/* If the window has no children, move on to the next higher window */
-	while (!pWin->prevSib && (pWin != pRoot))
-	    pWin = pWin->parent;
-
-	if (pWin->prevSib) {
-	    pWin = pWin->prevSib;
-	    continue;
-	}
-
-	/* When we reach the root window, we are finished */
-	if (pWin == pRoot)
-	    break;
-    }
-}
-
-/* Refresh screen by generating exposure events for all windows */
-static void dmxForceExposures(int idx)
-{
-    ScreenPtr      pScreen   = screenInfo.screens[idx];
-    WindowPtr  pRoot     = WindowTable[idx];
-    Bool       anyMarked = FALSE;
-    WindowPtr  pChild;
-
-    for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib)
-	anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild,
-						    (WindowPtr *)NULL);
-    if (anyMarked) {
-	/* If any windows have been marked, set the root window's
-	 * clipList to be broken since it will be recalculated in
-	 * ValidateTree()
-	 */
-	REGION_BREAK(pScreen, &pRoot->clipList);
-	pScreen->ValidateTree(pRoot, NULL, VTBroken);
-	pScreen->HandleExposures(pRoot);
-	if (pScreen->PostValidateTree)
-	    pScreen->PostValidateTree(pRoot, NULL, VTBroken);
-    }
-}
-
-/** Compare the new and old screens to see if they are compatible. */
-static Bool dmxCompareScreens(DMXScreenInfo *new, DMXScreenInfo *old)
-{
-    int i;
-
-    if (new->beWidth != old->beWidth) return FALSE;
-    if (new->beHeight != old->beHeight) return FALSE;
-    if (new->beDepth != old->beDepth) return FALSE;
-    if (new->beBPP != old->beBPP) return FALSE;
-
-    if (new->beNumDepths != old->beNumDepths) return FALSE;
-    for (i = 0; i < old->beNumDepths; i++)
-	if (new->beDepths[i] != old->beDepths[i]) return FALSE;
-
-    if (new->beNumPixmapFormats != old->beNumPixmapFormats) return FALSE;
-    for (i = 0; i < old->beNumPixmapFormats; i++) {
-	if (new->bePixmapFormats[i].depth !=
-	    old->bePixmapFormats[i].depth) return FALSE;
-	if (new->bePixmapFormats[i].bits_per_pixel !=
-	    old->bePixmapFormats[i].bits_per_pixel) return FALSE;
-	if (new->bePixmapFormats[i].scanline_pad !=
-	    old->bePixmapFormats[i].scanline_pad) return FALSE;
-    }
-
-    if (new->beNumVisuals != old->beNumVisuals) return FALSE;
-    for (i = 0; i < old->beNumVisuals; i++) {
-	if (new->beVisuals[i].visualid !=
-	    old->beVisuals[i].visualid) return FALSE;
-	if (new->beVisuals[i].screen !=
-	    old->beVisuals[i].screen) return FALSE;
-	if (new->beVisuals[i].depth !=
-	    old->beVisuals[i].depth) return FALSE;
-	if (new->beVisuals[i].class !=
-	    old->beVisuals[i].class) return FALSE;
-	if (new->beVisuals[i].red_mask !=
-	    old->beVisuals[i].red_mask) return FALSE;
-	if (new->beVisuals[i].green_mask !=
-	    old->beVisuals[i].green_mask) return FALSE;
-	if (new->beVisuals[i].blue_mask !=
-	    old->beVisuals[i].blue_mask) return FALSE;
-	if (new->beVisuals[i].colormap_size !=
-	    old->beVisuals[i].colormap_size) return FALSE;
-	if (new->beVisuals[i].bits_per_rgb !=
-	    old->beVisuals[i].bits_per_rgb) return FALSE;
-    }
-
-    if (new->beDefVisualIndex != old->beDefVisualIndex) return FALSE;
-
-    return TRUE;
-}
-
-/** Restore Render's picture */
-static void dmxBERestoreRenderPict(pointer value, XID id, pointer n)
-{
-    PicturePtr   pPicture = value;               /* The picture */
-    DrawablePtr  pDraw    = pPicture->pDrawable; /* The picture's drawable */
-    int          scrnNum  = (int)n;
-
-    if (pDraw->pScreen->myNum != scrnNum) {
-	/* Picture not on the screen we are restoring*/
-	return;
-    }
-
-    if (pDraw->type == DRAWABLE_PIXMAP) {
-	PixmapPtr  pPixmap = (PixmapPtr)pDraw;
-	
-	/* Create and restore the pixmap drawable */
-	dmxBECreatePixmap(pPixmap);
-	dmxBERestorePixmap(pPixmap);
-    }
-
-    dmxBECreatePicture(pPicture);
-}
-
-/** Restore Render's glyphs */
-static void dmxBERestoreRenderGlyph(pointer value, XID id, pointer n)
-{
-    GlyphSetPtr      glyphSet   = value;
-    int              scrnNum    = (int)n;
-    dmxGlyphPrivPtr  glyphPriv  = DMX_GET_GLYPH_PRIV(glyphSet);
-    DMXScreenInfo   *dmxScreen  = &dmxScreens[scrnNum];
-    GlyphRefPtr      table;
-    char            *images;
-    Glyph           *gids;
-    XGlyphInfo      *glyphs;
-    char            *pos;
-    int              beret;
-    int              len_images = 0;
-    int              i;
-    int              ctr;
-
-    if (glyphPriv->glyphSets[scrnNum]) {
-	/* Only restore glyphs on the screen we are attaching */
-	return;
-    }
-
-    /* First we must create the glyph set on the backend. */
-    if ((beret = dmxBECreateGlyphSet(scrnNum, glyphSet)) != Success) {
-	dmxLog(dmxWarning,
-	       "\tdmxBERestoreRenderGlyph failed to create glyphset!\n");
-	return;
-    }
-
-    /* Now for the complex part, restore the glyph data */
-    table = glyphSet->hash.table;
-
-    /* We need to know how much memory to allocate for this part */
-    for (i = 0; i < glyphSet->hash.hashSet->size; i++) {
-	GlyphRefPtr  gr = &table[i];
-	GlyphPtr     gl = gr->glyph;
-
-	if (!gl || gl == DeletedGlyph) continue;
-	len_images += gl->size - sizeof(gl->info);
-    }
-
-    /* Now allocate the memory we need */
-    images = calloc(len_images, sizeof(char));
-    gids   = malloc(glyphSet->hash.tableEntries*sizeof(Glyph));
-    glyphs = malloc(glyphSet->hash.tableEntries*sizeof(XGlyphInfo));
-
-    pos = images;
-    ctr = 0;
-    
-    /* Fill the allocated memory with the proper data */
-    for (i = 0; i < glyphSet->hash.hashSet->size; i++) {
-	GlyphRefPtr  gr = &table[i];
-	GlyphPtr     gl = gr->glyph;
-
-	if (!gl || gl == DeletedGlyph) continue;
-
-	/* First lets put the data into gids */
-	gids[ctr] = gr->signature;
-
-	/* Next do the glyphs data structures */
-	glyphs[ctr].width  = gl->info.width;
-	glyphs[ctr].height = gl->info.height;
-	glyphs[ctr].x      = gl->info.x;
-	glyphs[ctr].y      = gl->info.y;
-	glyphs[ctr].xOff   = gl->info.xOff;
-	glyphs[ctr].yOff   = gl->info.yOff;
-
-	/* Copy the images from the DIX's data into the buffer */
-	memcpy(pos, gl+1, gl->size - sizeof(gl->info));
-	pos += gl->size - sizeof(gl->info);
-	ctr++;
-    }
-    
-    /* Now restore the glyph data */
-    XRenderAddGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[scrnNum],
-		     gids,glyphs, glyphSet->hash.tableEntries, images,
-		     len_images);
-
-    /* Clean up */
-    free(images);
-    free(gids);
-    free(glyphs);    
-}
-
-/** Reattach previously detached back-end screen. */
-int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
-{
-    ScreenPtr      pScreen;
-    DMXScreenInfo *dmxScreen;
-    CARD32         scrnNum   = idx;
-    DMXScreenInfo  oldDMXScreen;
-    int            i;
-
-    /* Return failure if dynamic addition/removal of screens is disabled */
-    if (!dmxAddRemoveScreens) {
-	dmxLog(dmxWarning,
-	       "Attempting to add a screen, but the AddRemoveScreen\n");
-	dmxLog(dmxWarning,
-	       "extension has not been enabled.  To enable this extension\n");
-	dmxLog(dmxWarning,
-	       "add the \"-addremovescreens\" option either to the command\n");
-	dmxLog(dmxWarning,
-	       "line or in the configuration file.\n");
-	return 1;
-    }
-
-    /* Cannot add a screen that does not exist */
-    if (idx < 0 || idx >= dmxNumScreens) return 1;
-    pScreen = screenInfo.screens[idx];
-    dmxScreen = &dmxScreens[idx];
-
-    /* Cannot attach to a screen that is already opened */
-    if (dmxScreen->beDisplay) {
-	dmxLog(dmxWarning,
-	       "Attempting to add screen #%d but a screen already exists\n",
-	       idx);
-	return 1;
-    }
-
-    dmxLogOutput(dmxScreen, "Attaching screen #%d\n", idx);
-
-    /* Save old info */
-    oldDMXScreen = *dmxScreen;
-
-    /* Copy the name to the new screen */
-    dmxScreen->name = strdup(attr->displayName);
-
-    /* Open display and get all of the screen info */
-    if (!dmxOpenDisplay(dmxScreen)) {
-	dmxLog(dmxWarning,
-               "dmxOpenDisplay: Unable to open display %s\n",
-               dmxScreen->name);
-
-	/* Restore the old screen */
-	*dmxScreen = oldDMXScreen;
-	return 1;
-    }
-
-    dmxSetErrorHandler(dmxScreen);
-    dmxCheckForWM(dmxScreen);
-    dmxGetScreenAttribs(dmxScreen);
-
-    if (!dmxGetVisualInfo(dmxScreen)) {
-	dmxLog(dmxWarning, "dmxGetVisualInfo: No matching visuals found\n");
-	XFree(dmxScreen->beVisuals);
-	XCloseDisplay(dmxScreen->beDisplay);
-
-	/* Restore the old screen */
-	*dmxScreen = oldDMXScreen;
-	return 1;
-    }
-
-    dmxGetColormaps(dmxScreen);
-    dmxGetPixmapFormats(dmxScreen);
-
-    /* Verify that the screen to be added has the same info as the
-     * previously added screen. */
-    if (!dmxCompareScreens(dmxScreen, &oldDMXScreen)) {
-	dmxLog(dmxWarning,
-	       "New screen data (%s) does not match previously\n",
-	       dmxScreen->name);
-	dmxLog(dmxWarning,
-	       "attached screen data (%s)\n",
-	       oldDMXScreen.name);
-	dmxLog(dmxWarning,
-	       "All data must match in order to attach to screen #%d\n",
-	       idx);
-	XFree(dmxScreen->beVisuals);
-	XFree(dmxScreen->beDepths);
-	XFree(dmxScreen->bePixmapFormats);
-	XCloseDisplay(dmxScreen->beDisplay);
-
-	/* Restore the old screen */
-	*dmxScreen = oldDMXScreen;
-	return 1;
-    }
-
-    /* Initialize the BE screen resources */
-    dmxBEScreenInit(idx, screenInfo.screens[idx]);
-
-    /* TODO: Handle GLX visual initialization.  GLXProxy needs to be
-     * updated to handle dynamic addition/removal of screens. */
-
-    /* Create default stipple */
-    dmxBECreatePixmap(pScreen->PixmapPerDepth[0]);
-    dmxBERestorePixmap(pScreen->PixmapPerDepth[0]);
-
-    /* Create the scratch GCs */
-    dmxBECreateScratchGCs(idx);
-
-    /* Create the default font */
-    (void)dmxBELoadFont(pScreen, defaultFont);
-
-    /* Create all resources that don't depend on windows */
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindAllClientResources(clients[i], dmxBECreateResources,
-				   (pointer)idx);
-
-    /* Create window hierarchy (top down) */
-    dmxBECreateWindowTree(idx);
-
-    /* Restore the picture state for RENDER */
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindClientResourcesByType(clients[i],PictureType, 
-				      dmxBERestoreRenderPict,(pointer)idx);
-
-    /* Restore the glyph state for RENDER */
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindClientResourcesByType(clients[i],GlyphSetType, 
-				      dmxBERestoreRenderGlyph,(pointer)idx);
-
-    /* Refresh screen by generating exposure events for all windows */
-    dmxForceExposures(idx);
-
-    dmxSync(&dmxScreens[idx], TRUE);
-
-    /* We used these to compare the old and new screens.  They are no
-     * longer needed since we have a newly attached screen, so we can
-     * now free the old screen's resources. */
-    XFree(oldDMXScreen.beVisuals);
-    XFree(oldDMXScreen.beDepths);
-    XFree(oldDMXScreen.bePixmapFormats);
-    /* TODO: should oldDMXScreen.name be freed?? */
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension)
-	return dmxConfigureScreenWindows(1, &scrnNum, attr, NULL);
-    else
-#endif
-	return 0; /* Success */
-}
-
-/*
- * Resources that may have state on the BE server and need to be freed:
- *
- * RT_NONE
- * RT_WINDOW
- * RT_PIXMAP
- * RT_GC
- * RT_FONT
- * RT_CURSOR
- * RT_COLORMAP
- * RT_CMAPENTRY
- * RT_OTHERCLIENT
- * RT_PASSIVEGRAB
- * XRT_WINDOW
- * XRT_PIXMAP
- * XRT_GC
- * XRT_COLORMAP
- * XRT_PICTURE
- * PictureType
- * PictFormatType
- * GlyphSetType
- * ClientType
- * EventType
- * RT_INPUTCLIENT
- * XETrapType
- * RTCounter
- * RTAwait
- * RTAlarmClient
- * RT_XKBCLIENT
- * RTContext
- * TagResType
- * StalledResType
- * SecurityAuthorizationResType
- * RTEventClient
- * __glXContextRes
- * __glXClientRes
- * __glXPixmapRes
- * __glXWindowRes
- * __glXPbufferRes
- */
-
-#ifdef PANORAMIX
-/** Search the Xinerama XRT_PIXMAP resources for the pixmap that needs
- *  to have its image saved. */
-static void dmxBEFindPixmapImage(pointer value, XID id, RESTYPE type,
-				 pointer p)
-{
-    if ((type & TypeMask) == (XRT_PIXMAP & TypeMask)) {
-	PixmapPtr      pDst     = (PixmapPtr)p;
-	int            idx      = pDst->drawable.pScreen->myNum;
-	PanoramiXRes  *pXinPix  = (PanoramiXRes *)value;
-	PixmapPtr      pPix;
-	int            i;
-
-	pPix = (PixmapPtr)LookupIDByType(pXinPix->info[idx].id, RT_PIXMAP);
-	if (pPix != pDst) return; /* Not a match.... Next! */
-
-	for (i = 0; i < PanoramiXNumScreens; i++) {
-	    PixmapPtr      pSrc;
-	    dmxPixPrivPtr  pSrcPriv = NULL;
-
-	    if (i == idx) continue; /* Self replication is bad */
-
-	    pSrc =
-		(PixmapPtr)LookupIDByType(pXinPix->info[i].id, RT_PIXMAP);
-	    pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
-	    if (pSrcPriv->pixmap) {
-		FoundPixImage = True;
-		return;
-	    }
-	}
-    }
-}
-#endif
-
-/** Save the pixmap image only when there is not another screen with
- *  that pixmap from which the image can be read when the screen is
- *  reattached.  To do this, we first try to find a pixmap on another
- *  screen corresponding to the one we are trying to save.  If we find
- *  one, then we do not need to save the image data since during
- *  reattachment, the image data can be read from that other pixmap.
- *  However, if we do not find one, then we need to save the image data.
- *  The common case for these are for the default stipple and root
- *  tile. */
-static void dmxBESavePixmap(PixmapPtr pPixmap)
-{
-#ifdef PANORAMIX
-    int i;
-
-    /* If Xinerama is not active, there's nothing we can do (see comment
-     * in #else below for more info). */
-    if (noPanoramiXExtension) return;
-
-    FoundPixImage = False;
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindAllClientResources(clients[i], dmxBEFindPixmapImage,
-				   (pointer)pPixmap);
-
-    /* Save the image only if there is no other screens that have a
-     * pixmap that corresponds to the one we are trying to save. */
-    if (!FoundPixImage) {
-	dmxPixPrivPtr  pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap);
-
-	if (!pPixPriv->detachedImage) {
-	    ScreenPtr      pScreen   = pPixmap->drawable.pScreen;
-	    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
-
-	    pPixPriv->detachedImage = XGetImage(dmxScreen->beDisplay,
-						pPixPriv->pixmap,
-						0, 0,
-						pPixmap->drawable.width,
-						pPixmap->drawable.height,
-						-1,
-						ZPixmap);
-	    if (!pPixPriv->detachedImage)
-		dmxLog(dmxWarning, "Cannot save pixmap image\n");
-	}
-    }
-#else
-    /* NOTE: The only time there is a pixmap on another screen that
-     * corresponds to the one we are trying to save is when Xinerama is
-     * active.  Otherwise, the pixmap image data is only stored on a
-     * single screen, which means that once it is detached, that data is
-     * lost.  We could save the data here, but then that would require
-     * us to implement the ability for Xdmx to keep the pixmap up to
-     * date while the screen is detached, which is beyond the scope of
-     * the current project. */
-    return;
-#endif
-}
-
-/** Destroy resources on the back-end server.  This function is called
- *  from #dmxDetachScreen() via the dix layer's FindAllResources
- *  function.  It walks all resources, compares them to the screen
- *  number passed in as \a n and calls the appropriate DMX function to
- *  free the associated resource on the back-end server. */
-static void dmxBEDestroyResources(pointer value, XID id, RESTYPE type,
-				  pointer n)
-{
-    int        scrnNum = (int)n;
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
-
-    if ((type & TypeMask) == (RT_WINDOW & TypeMask)) {
-	/* Window resources are destroyed below in dmxBEDestroyWindowTree */
-    } else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) {
-	PixmapPtr  pPix = value;
-	if (pPix->drawable.pScreen->myNum == scrnNum) {
-	    dmxBESavePixmap(pPix);
-	    dmxBEFreePixmap(pPix);
-	}
-    } else if ((type & TypeMask) == (RT_GC & TypeMask)) {
-	GCPtr  pGC = value;
-	if (pGC->pScreen->myNum == scrnNum)
-	    dmxBEFreeGC(pGC);
-    } else if ((type & TypeMask) == (RT_FONT & TypeMask)) {
-	dmxBEFreeFont(pScreen, (FontPtr)value);
-    } else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) {
-	dmxBEFreeCursor(pScreen, (CursorPtr)value);
-    } else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) {
-	ColormapPtr  pCmap = value;
-	if (pCmap->pScreen->myNum == scrnNum)
-	    dmxBEFreeColormap((ColormapPtr)value);
-    } else if ((type & TypeMask) == (PictureType & TypeMask)) {
-	PicturePtr  pPict = value;
-	if (pPict->pDrawable->pScreen->myNum == scrnNum) {
-	    /* Free the pixmaps on the backend if needed */
-	    if (pPict->pDrawable->type == DRAWABLE_PIXMAP) {
-		PixmapPtr pPixmap = (PixmapPtr)(pPict->pDrawable);
-		dmxBESavePixmap(pPixmap);
-		dmxBEFreePixmap(pPixmap);
-	    }
-	    dmxBEFreePicture((PicturePtr)value);
-	}
-    } else if ((type & TypeMask) == (GlyphSetType & TypeMask)) {
-	dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr)value);
-    } else {
-	/* Other resource types??? */
-    }
-}
-
-/** Destroy the scratch GCs that are created per depth. */
-static void dmxBEDestroyScratchGCs(int scrnNum)
-{
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
-    GCPtr     *ppGC    = pScreen->GCperDepth;
-    int        i;
-
-    for (i = 0; i <= pScreen->numDepths; i++)
-	dmxBEFreeGC(ppGC[i]);
-}
-
-/** Destroy window hierachy on back-end server.  To ensure that all
- *  XDestroyWindow() calls succeed, they must be performed in a bottom
- *  up order so that windows are not destroyed before their children.
- *  XDestroyWindow(), which is called from #dmxBEDestroyWindow(), will
- *  destroy a window as well as all of it's children. */
-static void dmxBEDestroyWindowTree(int idx)
-{
-    WindowPtr  pWin   = WindowTable[idx];
-    WindowPtr  pChild = pWin;
-
-    while (1) {
-	if (pChild->firstChild) {
-	    pChild = pChild->firstChild;
-	    continue;
-	}
-
-	/* Destroy the window */
-	dmxBEDestroyWindow(pChild);
-
-	/* Make sure we destroy the window's border and background
-	 * pixmaps if they exist */
-	if (!pChild->borderIsPixel) {
-	    dmxBESavePixmap(pChild->border.pixmap);
-	    dmxBEFreePixmap(pChild->border.pixmap);
-	}
-	if (pChild->backgroundState == BackgroundPixmap) {
-	    dmxBESavePixmap(pChild->background.pixmap);
-	    dmxBEFreePixmap(pChild->background.pixmap);
-	}
-
-	while (!pChild->nextSib && (pChild != pWin)) {
-	    pChild = pChild->parent;
-	    dmxBEDestroyWindow(pChild);
-	    if (!pChild->borderIsPixel) {
-		dmxBESavePixmap(pChild->border.pixmap);
-		dmxBEFreePixmap(pChild->border.pixmap);
-	    }
-	    if (pChild->backgroundState == BackgroundPixmap) {
-		dmxBESavePixmap(pChild->background.pixmap);
-		dmxBEFreePixmap(pChild->background.pixmap);
-	    }
-	}
-
-	if (pChild == pWin)
-	    break;
-
-	pChild = pChild->nextSib;
-    }
-}
-
-/** Detach back-end screen. */
-int dmxDetachScreen(int idx)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    int            i;
-
-    /* Return failure if dynamic addition/removal of screens is disabled */
-    if (!dmxAddRemoveScreens) {
-	dmxLog(dmxWarning,
-	       "Attempting to remove a screen, but the AddRemoveScreen\n");
-	dmxLog(dmxWarning,
-	       "extension has not been enabled.  To enable this extension\n");
-	dmxLog(dmxWarning,
-	       "add the \"-addremovescreens\" option either to the command\n");
-	dmxLog(dmxWarning,
-	       "line or in the configuration file.\n");
-	return 1;
-    }
-
-    /* Cannot remove a screen that does not exist */
-    if (idx < 0 || idx >= dmxNumScreens) return 1;
-
-    /* Cannot detach from a screen that is not opened */
-    if (!dmxScreen->beDisplay) {
-	dmxLog(dmxWarning,
-	       "Attempting to remove screen #%d but it has not been opened\n",
-	       idx);
-	return 1;
-    }
-
-    dmxLogOutput(dmxScreen, "Detaching screen #%d\n", idx);
-
-    /* Detach input */
-    dmxInputDetachAll(dmxScreen);
-
-    /* Save all relevant state (TODO) */
-
-    /* Free all non-window resources related to this screen */
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindAllClientResources(clients[i], dmxBEDestroyResources,
-				   (pointer)idx);
-
-    /* Free scratch GCs */
-    dmxBEDestroyScratchGCs(idx);
-
-    /* Free window resources related to this screen */
-    dmxBEDestroyWindowTree(idx);
-
-    /* Free default stipple */
-    dmxBESavePixmap(screenInfo.screens[idx]->PixmapPerDepth[0]);
-    dmxBEFreePixmap(screenInfo.screens[idx]->PixmapPerDepth[0]);
-
-    /* Free the remaining screen resources and close the screen */
-    dmxBECloseScreen(screenInfo.screens[idx]);
-
-    /* Adjust the cursor boundaries (paints detached console window) */
-    dmxAdjustCursorBoundaries();
-
-    return 0; /* Success */
-}
+/*

+ * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Author:

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *   Kevin E. Martin <kem@redhat.com>

+ *

+ */

+

+/** \file

+ * This file provides the only interface to the X server extension support

+ * in programs/Xserver/Xext.  Those programs should only include dmxext.h

+ */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include <stdlib.h>

+

+#include "dmx.h"

+#include "dmxinit.h"

+#include "dmxextension.h"

+#include "dmxwindow.h"

+#include "dmxcb.h"

+#include "dmxcursor.h"

+#include "dmxpixmap.h"

+#include "dmxgc.h"

+#include "dmxfont.h"

+#include "dmxcmap.h"

+#include "dmxpict.h"

+#include "dmxinput.h"

+#include "dmxsync.h"

+#include "dmxscrinit.h"

+#include "input/dmxinputinit.h"

+

+#include "windowstr.h"

+#include "inputstr.h"                 /* For DeviceIntRec */

+#include <X11/extensions/dmxproto.h>  /* For DMX_BAD_* */

+#include "cursorstr.h"

+

+/* The default font is declared in dix/globals.c, but is not included in

+ * _any_ header files. */

+extern FontPtr  defaultFont;

+    

+/** This routine provides information to the DMX protocol extension

+ * about a particular screen. */

+Bool dmxGetScreenAttributes(int physical, DMXScreenAttributesPtr attr)

+{

+    DMXScreenInfo *dmxScreen;

+

+    if (physical < 0 || physical >= dmxNumScreens) return FALSE;

+

+    dmxScreen = &dmxScreens[physical];

+    attr->displayName         = dmxScreen->name;

+#ifdef PANORAMIX

+    attr->logicalScreen       = noPanoramiXExtension ? dmxScreen->index : 0;

+#else

+    attr->logicalScreen       = dmxScreen->index;

+#endif

+

+    attr->screenWindowWidth   = dmxScreen->scrnWidth;

+    attr->screenWindowHeight  = dmxScreen->scrnHeight;

+    attr->screenWindowXoffset = dmxScreen->scrnX;

+    attr->screenWindowYoffset = dmxScreen->scrnY;

+

+    attr->rootWindowWidth     = dmxScreen->rootWidth;

+    attr->rootWindowHeight    = dmxScreen->rootHeight;

+    attr->rootWindowXoffset   = dmxScreen->rootX;

+    attr->rootWindowYoffset   = dmxScreen->rootY;

+

+    attr->rootWindowXorigin   = dmxScreen->rootXOrigin;

+    attr->rootWindowYorigin   = dmxScreen->rootYOrigin;

+

+    return TRUE;

+}

+

+/** This routine provides information to the DMX protocol extension

+ * about a particular window. */

+Bool dmxGetWindowAttributes(WindowPtr pWindow, DMXWindowAttributesPtr attr)

+{

+    dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);

+

+    attr->screen         = pWindow->drawable.pScreen->myNum;

+    attr->window         = pWinPriv->window;

+

+    attr->pos.x          = pWindow->drawable.x;

+    attr->pos.y          = pWindow->drawable.y;

+    attr->pos.width      = pWindow->drawable.width;

+    attr->pos.height     = pWindow->drawable.height;

+

+    if (!pWinPriv->window || pWinPriv->offscreen) {

+        attr->vis.x      = 0;

+        attr->vis.y      = 0;

+        attr->vis.height = 0;

+        attr->vis.width  = 0;

+        return pWinPriv->window ? TRUE : FALSE;

+    }

+

+                                /* Compute display-relative coordinates */

+    attr->vis.x          = pWindow->drawable.x;

+    attr->vis.y          = pWindow->drawable.y;

+    attr->vis.width      = pWindow->drawable.width;

+    attr->vis.height     = pWindow->drawable.height;

+

+    if (attr->pos.x < 0) {

+        attr->vis.x     -= attr->pos.x;

+        attr->vis.width  = attr->pos.x + attr->pos.width - attr->vis.x;

+    }

+    if (attr->pos.x + attr->pos.width > pWindow->drawable.pScreen->width) {

+        if (attr->pos.x < 0)

+            attr->vis.width  = pWindow->drawable.pScreen->width;

+        else

+            attr->vis.width  = pWindow->drawable.pScreen->width - attr->pos.x;

+    }

+    if (attr->pos.y < 0) {

+        attr->vis.y     -= attr->pos.y;

+        attr->vis.height = attr->pos.y + attr->pos.height - attr->vis.y;

+    }

+    if (attr->pos.y + attr->pos.height > pWindow->drawable.pScreen->height) {

+        if (attr->pos.y < 0)

+            attr->vis.height = pWindow->drawable.pScreen->height;

+        else

+            attr->vis.height = pWindow->drawable.pScreen->height - attr->pos.y;

+    }

+

+                                /* Convert to window-relative coordinates */

+    attr->vis.x -= attr->pos.x;

+    attr->vis.y -= attr->pos.y;

+

+    return TRUE;

+}

+

+void dmxGetDesktopAttributes(DMXDesktopAttributesPtr attr)

+{

+    attr->width  = dmxGlobalWidth;

+    attr->height = dmxGlobalHeight;

+    attr->shiftX = 0;            /* NOTE: The upper left hand corner of */

+    attr->shiftY = 0;            /*       the desktop is always <0,0>. */

+}

+

+/** Return the total number of devices, not just #dmxNumInputs.  The

+ * number returned should be the same as that returned by

+ * XListInputDevices. */

+int dmxGetInputCount(void)

+{

+    int i, total;

+    

+    for (total = i = 0; i < dmxNumInputs; i++) total += dmxInputs[i].numDevs;

+    return total;

+}

+

+/** Return information about the device with id = \a deviceId.  This

+ * information is primarily for the #ProcDMXGetInputAttributes()

+ * function, which does not have access to the appropriate data

+ * structure. */

+int dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr)

+{

+    int          i, j;

+    DMXInputInfo *dmxInput;

+

+    if (deviceId < 0) return -1;

+    for (i = 0; i < dmxNumInputs; i++) {

+        dmxInput = &dmxInputs[i];

+        for (j = 0; j < dmxInput->numDevs; j++) {

+            DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[j];

+            if (deviceId != dmxLocal->pDevice->id) continue;

+            attr->isCore             = !!dmxLocal->isCore;

+            attr->sendsCore          = !!dmxLocal->sendsCore;

+            attr->detached           = !!dmxInput->detached;

+            attr->physicalScreen     = -1;

+            attr->physicalId         = -1;

+            attr->name               = NULL;

+            switch (dmxLocal->extType) {

+            case DMX_LOCAL_TYPE_LOCAL:

+                attr->inputType      = 0;

+                break;

+            case DMX_LOCAL_TYPE_CONSOLE:

+                attr->inputType      = 1;

+                attr->name           = dmxInput->name;

+                attr->physicalId     = dmxLocal->deviceId;

+                break;

+            case DMX_LOCAL_TYPE_BACKEND:

+            case DMX_LOCAL_TYPE_COMMON:

+                attr->inputType      = 2;

+                attr->physicalScreen = dmxInput->scrnIdx;

+                attr->name           = dmxInput->name;

+                attr->physicalId     = dmxLocal->deviceId;

+                break;

+            }

+            return 0;           /* Success */

+        }

+    }

+    return -1;                  /* Failure */

+}

+

+/** Reinitialized the cursor boundaries. */

+static void dmxAdjustCursorBoundaries(void)

+{

+    int           i;

+

+    dmxReInitOrigins();

+    dmxInitOverlap();

+    dmxComputeWidthHeight(DMX_NO_RECOMPUTE_BOUNDING_BOX);

+    dmxConnectionBlockCallback();

+    for (i = 0; i < dmxNumInputs; i++) {

+        DMXInputInfo *dmxInput = &dmxInputs[i];

+	if (!dmxInput->detached) dmxInputReInit(dmxInput);

+    }

+

+    dmxCheckCursor();

+

+    for (i = 0; i < dmxNumInputs; i++) {

+        DMXInputInfo *dmxInput = &dmxInputs[i];

+	if (!dmxInput->detached) dmxInputLateReInit(dmxInput);

+    }

+}

+

+/** Add an input with the specified attributes.  If the input is added,

+ * the physical id is returned in \a deviceId. */

+int dmxAddInput(DMXInputAttributesPtr attr, int *id)

+{

+    int retcode = BadValue;

+

+    if (attr->inputType == 1)   /* console */

+        retcode = dmxInputAttachConsole(attr->name, attr->sendsCore, id);

+    else if (attr->inputType == 2)   /* backend */

+        retcode = dmxInputAttachBackend(attr->physicalScreen,

+                                        attr->sendsCore,id);

+

+    if (retcode == Success) {

+        /* Adjust the cursor boundaries */

+        dmxAdjustCursorBoundaries();

+

+        /* Force completion of the changes */

+        dmxSync(NULL, TRUE);

+    }

+

+    return retcode;

+}

+

+/** Remove the input with physical id \a id. */

+int dmxRemoveInput(int id)

+{

+    return dmxInputDetachId(id);

+}

+

+/** Return the value of #dmxNumScreens -- the total number of backend

+ * screens in use (these are logical screens and may be larger than the

+ * number of backend displays). */

+unsigned long dmxGetNumScreens(void)

+{

+    return dmxNumScreens;

+}

+

+/** Make sure that #dmxCreateAndRealizeWindow has been called for \a

+ * pWindow. */

+void dmxForceWindowCreation(WindowPtr pWindow)

+{

+    dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);

+    if (!pWinPriv->window) dmxCreateAndRealizeWindow(pWindow, TRUE);

+}

+

+/** Flush pending syncs for all screens. */

+void dmxFlushPendingSyncs(void)

+{

+    dmxSync(NULL, TRUE);

+}

+

+/** Update DMX's screen resources to match those of the newly moved

+ *  and/or resized "root" window. */

+void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];

+    WindowPtr      pRoot     = pScreen->root;

+    WindowPtr      pChild;

+    Bool           anyMarked = FALSE;

+

+    /* Handle special case where width and/or height are zero */

+    if (w == 0 || h == 0) {

+	w = 1;

+	h = 1;

+    }

+

+    /* Change screen size */

+    pScreen->width  = w;

+    pScreen->height = h;

+

+    /* Reset the root window's drawable's size */

+    pRoot->drawable.width  = w;

+    pRoot->drawable.height = h;

+

+    /* Set the root window's new winSize and borderSize */

+    pRoot->winSize.extents.x1 = 0;

+    pRoot->winSize.extents.y1 = 0;

+    pRoot->winSize.extents.x2 = w;

+    pRoot->winSize.extents.y2 = h;

+

+    pRoot->borderSize.extents.x1 = 0;

+    pRoot->borderSize.extents.y1 = 0;

+    pRoot->borderSize.extents.x2 = w;

+    pRoot->borderSize.extents.y2 = h;

+

+    /* Recompute this screen's mmWidth & mmHeight */

+    pScreen->mmWidth =

+	(w * 254 + dmxScreen->beXDPI * 5) / (dmxScreen->beXDPI * 10);

+    pScreen->mmHeight =

+	(h * 254 + dmxScreen->beYDPI * 5) / (dmxScreen->beYDPI * 10);

+

+    /* Recompute this screen's window's clip rects as follows: */

+    /*   1. Mark all of root's children's windows */

+    for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib)

+	anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild,

+						    (WindowPtr *)NULL);

+

+    /*   2. Set the root window's borderClip */

+    pRoot->borderClip.extents.x1 = 0;

+    pRoot->borderClip.extents.y1 = 0;

+    pRoot->borderClip.extents.x2 = w;

+    pRoot->borderClip.extents.y2 = h;

+

+    /*   3. Set the root window's clipList */

+    if (anyMarked) {

+	/* If any windows have been marked, set the root window's

+	 * clipList to be broken since it will be recalculated in

+	 * ValidateTree()

+	 */

+	RegionBreak(&pRoot->clipList);

+    } else {

+	/* Otherwise, we just set it directly since there are no

+	 * windows visible on this screen

+	 */

+	pRoot->clipList.extents.x1 = 0;

+	pRoot->clipList.extents.y1 = 0;

+	pRoot->clipList.extents.x2 = w;

+	pRoot->clipList.extents.y2 = h;

+    }

+

+    /*   4. Revalidate all clip rects and generate expose events */

+    if (anyMarked) {

+	pScreen->ValidateTree(pRoot, NULL, VTBroken);

+	pScreen->HandleExposures(pRoot);

+	if (pScreen->PostValidateTree)

+	    pScreen->PostValidateTree(pRoot, NULL, VTBroken);

+    }

+}

+

+#ifdef PANORAMIX

+#include "panoramiXsrv.h"

+

+/** Change the "screen" window attributes by resizing the actual window

+ *  on the back-end display (if necessary). */

+static void dmxConfigureScreenWindow(int idx,

+				     int x, int y, int w, int h)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[idx];

+    ScreenPtr      pScreen   = screenInfo.screens[idx];

+

+    /* Resize "screen" window */

+    if (dmxScreen->scrnX      != x ||

+	dmxScreen->scrnY      != y ||

+	dmxScreen->scrnWidth  != w ||

+	dmxScreen->scrnHeight != h) {

+	dmxResizeScreenWindow(pScreen, x, y, w, h);

+    }

+

+    /* Change "screen" window values */

+    dmxScreen->scrnX      = x;

+    dmxScreen->scrnY      = y;

+    dmxScreen->scrnWidth  = w;

+    dmxScreen->scrnHeight = h;

+}

+				     

+/** Change the "root" window position and size by resizing the actual

+ *  window on the back-end display (if necessary) and updating all of

+ *  DMX's resources by calling #dmxUpdateScreenResources. */

+static void dmxConfigureRootWindow(int idx, int x, int y, int w, int h)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[idx];

+    WindowPtr      pRoot     = screenInfo.screens[idx]->root;

+

+    /* NOTE: Either this function or the ones that it calls must handle

+     * the case where w == 0 || h == 0.  Currently, the functions that

+     * this one calls handle that case. */

+

+    /* 1. Resize "root" window */

+    if (dmxScreen->rootX      != x ||

+	dmxScreen->rootY      != y ||

+	dmxScreen->rootWidth  != w ||

+	dmxScreen->rootHeight != h) {

+	dmxResizeRootWindow(pRoot, x, y, w, h);

+    }

+

+    /* 2. Update all of the screen's resources associated with this root

+     *    window */

+    if (dmxScreen->rootWidth  != w ||

+	dmxScreen->rootHeight != h) {

+	dmxUpdateScreenResources(screenInfo.screens[idx], x, y, w, h);

+    }

+

+    /* Change "root" window values */

+    dmxScreen->rootX      = x;

+    dmxScreen->rootY      = y;

+    dmxScreen->rootWidth  = w;

+    dmxScreen->rootHeight = h;

+}

+

+/** Change the "root" window's origin by updating DMX's internal data

+ *  structures (dix and Xinerama) to use the new origin and adjust the

+ *  positions of windows that overlap this "root" window. */

+static void dmxSetRootWindowOrigin(int idx, int x, int y)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[idx];

+    ScreenPtr      pScreen   = screenInfo.screens[idx];

+    WindowPtr      pRoot     = pScreen->root;

+    WindowPtr      pChild;

+    int            xoff;

+    int            yoff;

+

+    /* Change "root" window's origin */

+    dmxScreen->rootXOrigin = x;

+    dmxScreen->rootYOrigin = y;

+

+    /* Compute offsets here in case <x,y> has been changed above */

+    xoff = x - pScreen->x;

+    yoff = y - pScreen->y;

+

+    /* Adjust the root window's position */

+    pScreen->x = dmxScreen->rootXOrigin;

+    pScreen->y = dmxScreen->rootYOrigin;

+

+    /* Recalculate the Xinerama regions and data structs */

+    XineramaReinitData(pScreen);

+

+    /* Adjust each of the root window's children */

+    if (!idx) ReinitializeRootWindow(screenInfo.screens[0]->root, xoff, yoff);

+    pChild = pRoot->firstChild;

+    while (pChild) {

+	/* Adjust child window's position */

+	pScreen->MoveWindow(pChild,

+			    pChild->origin.x - wBorderWidth(pChild) - xoff,

+			    pChild->origin.y - wBorderWidth(pChild) - yoff,

+			    pChild->nextSib,

+			    VTMove);

+

+	/* Note that the call to MoveWindow will eventually call

+	 * dmxPositionWindow which will automatically create a

+	 * window if it is now exposed on screen (for lazy window

+	 * creation optimization) and it will properly set the

+	 * offscreen flag.

+	 */

+

+	pChild = pChild->nextSib;

+    }

+}

+

+/** Configure the attributes of each "screen" and "root" window. */

+int dmxConfigureScreenWindows(int nscreens,

+			      CARD32 *screens,

+			      DMXScreenAttributesPtr attribs,

+			      int *errorScreen)

+{

+    int           i;

+

+    for (i = 0; i < nscreens; i++) {

+	DMXScreenAttributesPtr  attr      = &attribs[i];

+	int                     idx       = screens[i];

+	DMXScreenInfo          *dmxScreen = &dmxScreens[idx];

+

+	if (errorScreen) *errorScreen = i;

+

+	if (!dmxScreen->beDisplay) return DMX_BAD_VALUE;

+

+	/* Check for illegal values */

+	if (idx < 0 || idx >= dmxNumScreens) return BadValue;

+

+	/* The "screen" and "root" windows must have valid sizes */

+	if (attr->screenWindowWidth <= 0 || attr->screenWindowHeight <= 0 ||

+	    attr->rootWindowWidth   <  0 || attr->rootWindowHeight   <  0)

+	    return DMX_BAD_VALUE;

+

+	/* The "screen" window must fit entirely within the BE display */

+	if (attr->screenWindowXoffset < 0 ||

+	    attr->screenWindowYoffset < 0 ||

+	    attr->screenWindowXoffset

+	    + attr->screenWindowWidth  > (unsigned)dmxScreen->beWidth ||

+	    attr->screenWindowYoffset

+	    + attr->screenWindowHeight > (unsigned)dmxScreen->beHeight)

+	    return DMX_BAD_VALUE;

+

+	/* The "root" window must fit entirely within the "screen" window */

+	if (attr->rootWindowXoffset < 0 ||

+	    attr->rootWindowYoffset < 0 ||

+	    attr->rootWindowXoffset

+	    + attr->rootWindowWidth  > attr->screenWindowWidth ||

+	    attr->rootWindowYoffset

+	    + attr->rootWindowHeight > attr->screenWindowHeight)

+	    return DMX_BAD_VALUE;

+

+	/* The "root" window must not expose unaddressable coordinates */

+	if (attr->rootWindowXorigin < 0 ||

+	    attr->rootWindowYorigin < 0 ||

+	    attr->rootWindowXorigin + attr->rootWindowWidth  > 32767 ||

+	    attr->rootWindowYorigin + attr->rootWindowHeight > 32767)

+	    return DMX_BAD_VALUE;

+

+	/* The "root" window must fit within the global bounding box */

+	if (attr->rootWindowXorigin

+	    + attr->rootWindowWidth > (unsigned)dmxGlobalWidth ||

+	    attr->rootWindowYorigin

+	    + attr->rootWindowHeight > (unsigned)dmxGlobalHeight)

+	    return DMX_BAD_VALUE;

+

+	/* FIXME: Handle the rest of the illegal value checking */

+    }

+

+    /* No illegal values found */

+    if (errorScreen) *errorScreen = 0;

+

+    for (i = 0; i < nscreens; i++) {

+	DMXScreenAttributesPtr  attr      = &attribs[i];

+	int                     idx       = screens[i];

+	DMXScreenInfo          *dmxScreen = &dmxScreens[idx];

+

+	dmxLog(dmxInfo, "Changing screen #%d attributes "

+	       "from %dx%d+%d+%d %dx%d+%d+%d +%d+%d "

+	       "to %dx%d+%d+%d %dx%d+%d+%d +%d+%d\n",

+	       idx,

+	       dmxScreen->scrnWidth,      dmxScreen->scrnHeight,

+	       dmxScreen->scrnX,          dmxScreen->scrnY,

+	       dmxScreen->rootWidth,      dmxScreen->rootHeight,

+	       dmxScreen->rootX,          dmxScreen->rootY,

+	       dmxScreen->rootXOrigin,    dmxScreen->rootYOrigin,

+	       attr->screenWindowWidth,   attr->screenWindowHeight,

+	       attr->screenWindowXoffset, attr->screenWindowYoffset,

+	       attr->rootWindowWidth,     attr->rootWindowHeight,

+	       attr->rootWindowXoffset,   attr->rootWindowYoffset,

+	       attr->rootWindowXorigin,   attr->rootWindowYorigin);

+

+	/* Configure "screen" window */

+	dmxConfigureScreenWindow(idx,

+				 attr->screenWindowXoffset,

+				 attr->screenWindowYoffset,

+				 attr->screenWindowWidth,

+				 attr->screenWindowHeight);

+

+	/* Configure "root" window */

+	dmxConfigureRootWindow(idx,

+			       attr->rootWindowXoffset,

+			       attr->rootWindowYoffset,

+			       attr->rootWindowWidth,

+			       attr->rootWindowHeight);

+

+

+	/* Set "root" window's origin */

+	dmxSetRootWindowOrigin(idx,

+			       attr->rootWindowXorigin,

+			       attr->rootWindowYorigin);

+    }

+

+    /* Adjust the cursor boundaries */

+    dmxAdjustCursorBoundaries();

+

+    /* Force completion of the changes */

+    dmxSync(NULL, TRUE);

+

+    return Success;

+}

+

+/** Configure the attributes of the global desktop. */

+int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)

+{

+    if (attribs->width  <= 0 || attribs->width  >= 32767 ||

+	attribs->height <= 0 || attribs->height >= 32767)

+	return DMX_BAD_VALUE;

+

+    /* If the desktop is shrinking, adjust the "root" windows on each

+     * "screen" window to only show the visible desktop.  Also, handle

+     * the special case where the desktop shrinks such that the it no

+     * longer overlaps an portion of a "screen" window. */

+    if (attribs->width < dmxGlobalWidth || attribs->height < dmxGlobalHeight) {

+	int   i;

+	for (i = 0; i < dmxNumScreens; i++) {

+	    DMXScreenInfo *dmxScreen = &dmxScreens[i];

+	    if (dmxScreen->rootXOrigin

+		+ dmxScreen->rootWidth  > attribs->width ||

+		dmxScreen->rootYOrigin

+		+ dmxScreen->rootHeight > attribs->height) {

+		int  w, h;

+		if ((w = attribs->width  - dmxScreen->rootXOrigin) < 0) w = 0;

+		if ((h = attribs->height - dmxScreen->rootYOrigin) < 0) h = 0;

+		if (w > dmxScreen->scrnWidth)  w = dmxScreen->scrnWidth;

+		if (h > dmxScreen->scrnHeight) h = dmxScreen->scrnHeight;

+		if (w > dmxScreen->rootWidth)  w = dmxScreen->rootWidth;

+		if (h > dmxScreen->rootHeight) h = dmxScreen->rootHeight;

+		dmxConfigureRootWindow(i,

+				       dmxScreen->rootX,

+				       dmxScreen->rootY,

+				       w, h);

+	    }

+	}

+    }

+

+    /* Set the global width/height */

+    dmxSetWidthHeight(attribs->width, attribs->height);

+

+    /* Handle shift[XY] changes */

+    if (attribs->shiftX || attribs->shiftY) {

+	int   i;

+	for (i = 0; i < dmxNumScreens; i++) {

+	    ScreenPtr  pScreen = screenInfo.screens[i];

+	    WindowPtr  pChild  = pScreen->root->firstChild;

+	    while (pChild) {

+		/* Adjust child window's position */

+		pScreen->MoveWindow(pChild,

+				    pChild->origin.x - wBorderWidth(pChild)

+				    - attribs->shiftX,

+				    pChild->origin.y - wBorderWidth(pChild)

+				    - attribs->shiftY,

+				    pChild->nextSib,

+				    VTMove);

+

+		/* Note that the call to MoveWindow will eventually call

+		 * dmxPositionWindow which will automatically create a

+		 * window if it is now exposed on screen (for lazy

+		 * window creation optimization) and it will properly

+		 * set the offscreen flag.

+		 */

+

+		pChild = pChild->nextSib;

+	    }

+	}

+    }

+

+    /* Update connection block, Xinerama, etc. -- these appears to

+     * already be handled in dmxConnectionBlockCallback(), which is

+     * called from dmxAdjustCursorBoundaries() [below]. */

+

+    /* Adjust the cursor boundaries */

+    dmxAdjustCursorBoundaries();

+

+    /* Force completion of the changes */

+    dmxSync(NULL, TRUE);

+

+    return Success;

+}

+#endif

+

+/** Create the scratch GCs per depth. */

+static void dmxBECreateScratchGCs(int scrnNum)

+{

+    ScreenPtr  pScreen = screenInfo.screens[scrnNum];

+    GCPtr     *ppGC    = pScreen->GCperDepth;

+    int        i;

+

+    for (i = 0; i <= pScreen->numDepths; i++)

+	dmxBECreateGC(pScreen, ppGC[i]);

+}

+

+#ifdef PANORAMIX

+static Bool FoundPixImage;

+

+/** Search the Xinerama XRT_PIXMAP resources for the pixmap that needs

+ *  to have its image restored.  When it is found, see if there is

+ *  another screen with the same image.  If so, copy the pixmap image

+ *  from the existing screen to the newly created pixmap. */

+static void dmxBERestorePixmapImage(pointer value, XID id, RESTYPE type,

+				    pointer p)

+{

+    if ((type & TypeMask) == (XRT_PIXMAP & TypeMask)) {

+	PixmapPtr      pDst     = (PixmapPtr)p;

+	int            idx      = pDst->drawable.pScreen->myNum;

+	PanoramiXRes  *pXinPix  = (PanoramiXRes *)value;

+	PixmapPtr      pPix;

+	int            i;

+

+	pPix = (PixmapPtr)LookupIDByType(pXinPix->info[idx].id, RT_PIXMAP);

+	if (pPix != pDst) return; /* Not a match.... Next! */

+

+	for (i = 0; i < PanoramiXNumScreens; i++) {

+	    PixmapPtr      pSrc;

+	    dmxPixPrivPtr  pSrcPriv = NULL;

+

+	    if (i == idx) continue; /* Self replication is bad */

+

+	    pSrc =

+		(PixmapPtr)LookupIDByType(pXinPix->info[i].id, RT_PIXMAP);

+	    pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);

+	    if (pSrcPriv->pixmap) {

+		DMXScreenInfo *dmxSrcScreen = &dmxScreens[i];

+		DMXScreenInfo *dmxDstScreen = &dmxScreens[idx];

+		dmxPixPrivPtr  pDstPriv = DMX_GET_PIXMAP_PRIV(pDst);

+		XImage        *img;

+		int            j;

+		XlibGC         gc = NULL;

+

+		/* This should never happen, but just in case.... */

+		if (pSrc->drawable.width  != pDst->drawable.width ||

+		    pSrc->drawable.height != pDst->drawable.height)

+		    return;

+

+		/* Copy from src pixmap to dst pixmap */

+		img = XGetImage(dmxSrcScreen->beDisplay,

+				pSrcPriv->pixmap,

+				0, 0,

+				pSrc->drawable.width, pSrc->drawable.height,

+				-1,

+				ZPixmap);

+

+		for (j = 0; j < dmxDstScreen->beNumPixmapFormats; j++) {

+		    if (dmxDstScreen->bePixmapFormats[j].depth == img->depth) {

+			unsigned long  m;

+			XGCValues      v;

+

+			m = GCFunction | GCPlaneMask | GCClipMask;

+			v.function = GXcopy;

+			v.plane_mask = AllPlanes;

+			v.clip_mask = None;

+

+			gc = XCreateGC(dmxDstScreen->beDisplay,

+				       dmxDstScreen->scrnDefDrawables[j],

+				       m, &v);

+			break;

+		    }

+		}

+

+		if (gc) {

+		    XPutImage(dmxDstScreen->beDisplay,

+			      pDstPriv->pixmap,

+			      gc, img, 0, 0, 0, 0,

+			      pDst->drawable.width, pDst->drawable.height);

+		    XFreeGC(dmxDstScreen->beDisplay, gc);

+		    FoundPixImage = True;

+		} else {

+		    dmxLog(dmxWarning, "Could not create GC\n");

+		}

+

+		XDestroyImage(img);

+		return;

+	    }

+	}

+    }

+}

+#endif

+

+/** Restore the pixmap image either from another screen or from an image

+ *  that was saved when the screen was previously detached. */

+static void dmxBERestorePixmap(PixmapPtr pPixmap)

+{

+#ifdef PANORAMIX

+    int i;

+

+    /* If Xinerama is not active, there's nothing we can do (see comment

+     * in #else below for more info). */

+    if (noPanoramiXExtension) {

+	dmxLog(dmxWarning, "Cannot restore pixmap image\n");

+	return;

+    }

+

+    FoundPixImage = False;

+    for (i = currentMaxClients; --i >= 0; )

+	if (clients[i])

+	    FindAllClientResources(clients[i], dmxBERestorePixmapImage,

+				   (pointer)pPixmap);

+

+    /* No corresponding pixmap image was found on other screens, so we

+     * need to copy it from the saved image when the screen was detached

+     * (if available). */

+    if (!FoundPixImage) {

+	dmxPixPrivPtr  pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap);

+

+	if (pPixPriv->detachedImage) {

+	    ScreenPtr      pScreen   = pPixmap->drawable.pScreen;

+	    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];

+	    XlibGC         gc        = NULL;

+

+	    for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) {

+		if (dmxScreen->bePixmapFormats[i].depth ==

+		    pPixPriv->detachedImage->depth) {

+		    unsigned long  m;

+		    XGCValues      v;

+

+		    m = GCFunction | GCPlaneMask | GCClipMask;

+		    v.function = GXcopy;

+		    v.plane_mask = AllPlanes;

+		    v.clip_mask = None;

+

+		    gc = XCreateGC(dmxScreen->beDisplay,

+				   dmxScreen->scrnDefDrawables[i],

+				   m, &v);

+		    break;

+		}

+	    }

+

+	    if (gc) {

+		XPutImage(dmxScreen->beDisplay,

+			  pPixPriv->pixmap,

+			  gc,

+			  pPixPriv->detachedImage,

+			  0, 0, 0, 0,

+		      pPixmap->drawable.width, pPixmap->drawable.height);

+		XFreeGC(dmxScreen->beDisplay, gc);

+	    } else {

+		dmxLog(dmxWarning, "Cannot restore pixmap image\n");

+	    }

+

+	    XDestroyImage(pPixPriv->detachedImage);

+	    pPixPriv->detachedImage = NULL;

+	} else {

+	    dmxLog(dmxWarning, "Cannot restore pixmap image\n");

+	}

+    }

+#else

+    /* If Xinerama is not enabled, then there is no other copy of the

+     * pixmap image that we can restore.  Saving all pixmap data is not

+     * a feasible option since there is no mechanism for updating pixmap

+     * data when a screen is detached, which means that the data that

+     * was previously saved would most likely be out of date. */

+    dmxLog(dmxWarning, "Cannot restore pixmap image\n");

+    return;

+#endif

+}

+

+/** Create resources on the back-end server.  This function is called

+ *  from #dmxAttachScreen() via the dix layer's FindAllResources

+ *  function.  It walks all resources, compares them to the screen

+ *  number passed in as \a n and calls the appropriate DMX function to

+ *  create the associated resource on the back-end server. */

+static void dmxBECreateResources(pointer value, XID id, RESTYPE type,

+				 pointer n)

+{

+    int        scrnNum = (int)n;

+    ScreenPtr  pScreen = screenInfo.screens[scrnNum];

+

+    if ((type & TypeMask) == (RT_WINDOW & TypeMask)) {

+	/* Window resources are created below in dmxBECreateWindowTree */

+    } else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) {

+	PixmapPtr  pPix = value;

+	if (pPix->drawable.pScreen->myNum == scrnNum) {

+	    dmxBECreatePixmap(pPix);

+	    dmxBERestorePixmap(pPix);

+	}

+    } else if ((type & TypeMask) == (RT_GC & TypeMask)) {

+	GCPtr  pGC = value;

+	if (pGC->pScreen->myNum == scrnNum) {

+	    /* Create the GC on the back-end server */

+	    dmxBECreateGC(pScreen, pGC);

+	    /* Create any pixmaps associated with this GC */

+	    if (!pGC->tileIsPixel) {

+		dmxBECreatePixmap(pGC->tile.pixmap);

+		dmxBERestorePixmap(pGC->tile.pixmap);

+	    }

+	    if (pGC->stipple != pScreen->PixmapPerDepth[0]) {

+		dmxBECreatePixmap(pGC->stipple);

+		dmxBERestorePixmap(pGC->stipple);

+	    }

+	    if (pGC->font != defaultFont) {

+		(void)dmxBELoadFont(pScreen, pGC->font);

+	    }

+	    /* Update the GC on the back-end server */

+	    dmxChangeGC(pGC, -1L);

+	}

+    } else if ((type & TypeMask) == (RT_FONT & TypeMask)) {

+	(void)dmxBELoadFont(pScreen, (FontPtr)value);

+    } else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) {

+	dmxBECreateCursor(pScreen, (CursorPtr)value);

+    } else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) {

+	ColormapPtr  pCmap = value;

+	if (pCmap->pScreen->myNum == scrnNum)

+	    (void)dmxBECreateColormap((ColormapPtr)value);

+#if 0

+    /* TODO: Recreate Picture and GlyphSet resources */

+    } else if ((type & TypeMask) == (PictureType & TypeMask)) {

+	/* Picture resources are created when windows are created */

+    } else if ((type & TypeMask) == (GlyphSetType & TypeMask)) {

+	dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr)value);

+#endif

+    } else {

+	/* Other resource types??? */

+    }

+}

+

+/** Create window hierachy on back-end server.  The window tree is

+ *  created in a special order (bottom most subwindow first) so that the

+ *  #dmxCreateNonRootWindow() function does not need to recursively call

+ *  itself to create each window's parents.  This is required so that we

+ *  have the opportunity to create each window's border and background

+ *  pixmaps (where appropriate) before the window is created. */

+static void dmxBECreateWindowTree(int idx)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[idx];

+    WindowPtr      pRoot     = screenInfo.screens[idx]->root;

+    dmxWinPrivPtr  pWinPriv  = DMX_GET_WINDOW_PRIV(pRoot);

+    WindowPtr      pWin;

+

+    /* Create the pixmaps associated with the root window */

+    if (!pRoot->borderIsPixel) {

+	dmxBECreatePixmap(pRoot->border.pixmap);

+	dmxBERestorePixmap(pRoot->border.pixmap);

+    }

+    if (pRoot->backgroundState == BackgroundPixmap) {

+	dmxBECreatePixmap(pRoot->background.pixmap);

+	dmxBERestorePixmap(pRoot->background.pixmap);

+    }

+

+    /* Create root window first */

+    dmxScreen->rootWin = pWinPriv->window = dmxCreateRootWindow(pRoot);

+    XMapWindow(dmxScreen->beDisplay, dmxScreen->rootWin);

+

+    pWin = pRoot->lastChild;

+    while (pWin) {

+	pWinPriv = DMX_GET_WINDOW_PRIV(pWin);

+

+	/* Create the pixmaps regardless of whether or not the

+	 * window is created or not due to lazy window creation.

+	 */

+	if (!pWin->borderIsPixel) {

+	    dmxBECreatePixmap(pWin->border.pixmap);

+	    dmxBERestorePixmap(pWin->border.pixmap);

+	}

+	if (pWin->backgroundState == BackgroundPixmap) {

+	    dmxBECreatePixmap(pWin->background.pixmap);

+	    dmxBERestorePixmap(pWin->background.pixmap);

+	}

+

+	/* Reset the window attributes */

+	dmxGetDefaultWindowAttributes(pWin,

+				      &pWinPriv->cmap,

+				      &pWinPriv->visual);

+

+	/* Create the window */

+	if (pWinPriv->mapped && !pWinPriv->offscreen)

+	    dmxCreateAndRealizeWindow(pWin, TRUE);

+

+	/* Next, create the bottom-most child */

+	if (pWin->lastChild) {

+	    pWin = pWin->lastChild;

+	    continue;

+	}

+

+	/* If the window has no children, move on to the next higher window */

+	while (!pWin->prevSib && (pWin != pRoot))

+	    pWin = pWin->parent;

+

+	if (pWin->prevSib) {

+	    pWin = pWin->prevSib;

+	    continue;

+	}

+

+	/* When we reach the root window, we are finished */

+	if (pWin == pRoot)

+	    break;

+    }

+}

+

+/* Refresh screen by generating exposure events for all windows */

+static void dmxForceExposures(int idx)

+{

+    ScreenPtr      pScreen   = screenInfo.screens[idx];

+    WindowPtr  pRoot     = pScreen->root;

+    Bool       anyMarked = FALSE;

+    WindowPtr  pChild;

+

+    for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib)

+	anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild,

+						    (WindowPtr *)NULL);

+    if (anyMarked) {

+	/* If any windows have been marked, set the root window's

+	 * clipList to be broken since it will be recalculated in

+	 * ValidateTree()

+	 */

+	RegionBreak(&pRoot->clipList);

+	pScreen->ValidateTree(pRoot, NULL, VTBroken);

+	pScreen->HandleExposures(pRoot);

+	if (pScreen->PostValidateTree)

+	    pScreen->PostValidateTree(pRoot, NULL, VTBroken);

+    }

+}

+

+/** Compare the new and old screens to see if they are compatible. */

+static Bool dmxCompareScreens(DMXScreenInfo *new, DMXScreenInfo *old)

+{

+    int i;

+

+    if (new->beWidth != old->beWidth) return FALSE;

+    if (new->beHeight != old->beHeight) return FALSE;

+    if (new->beDepth != old->beDepth) return FALSE;

+    if (new->beBPP != old->beBPP) return FALSE;

+

+    if (new->beNumDepths != old->beNumDepths) return FALSE;

+    for (i = 0; i < old->beNumDepths; i++)

+	if (new->beDepths[i] != old->beDepths[i]) return FALSE;

+

+    if (new->beNumPixmapFormats != old->beNumPixmapFormats) return FALSE;

+    for (i = 0; i < old->beNumPixmapFormats; i++) {

+	if (new->bePixmapFormats[i].depth !=

+	    old->bePixmapFormats[i].depth) return FALSE;

+	if (new->bePixmapFormats[i].bits_per_pixel !=

+	    old->bePixmapFormats[i].bits_per_pixel) return FALSE;

+	if (new->bePixmapFormats[i].scanline_pad !=

+	    old->bePixmapFormats[i].scanline_pad) return FALSE;

+    }

+

+    if (new->beNumVisuals != old->beNumVisuals) return FALSE;

+    for (i = 0; i < old->beNumVisuals; i++) {

+	if (new->beVisuals[i].visualid !=

+	    old->beVisuals[i].visualid) return FALSE;

+	if (new->beVisuals[i].screen !=

+	    old->beVisuals[i].screen) return FALSE;

+	if (new->beVisuals[i].depth !=

+	    old->beVisuals[i].depth) return FALSE;

+	if (new->beVisuals[i].class !=

+	    old->beVisuals[i].class) return FALSE;

+	if (new->beVisuals[i].red_mask !=

+	    old->beVisuals[i].red_mask) return FALSE;

+	if (new->beVisuals[i].green_mask !=

+	    old->beVisuals[i].green_mask) return FALSE;

+	if (new->beVisuals[i].blue_mask !=

+	    old->beVisuals[i].blue_mask) return FALSE;

+	if (new->beVisuals[i].colormap_size !=

+	    old->beVisuals[i].colormap_size) return FALSE;

+	if (new->beVisuals[i].bits_per_rgb !=

+	    old->beVisuals[i].bits_per_rgb) return FALSE;

+    }

+

+    if (new->beDefVisualIndex != old->beDefVisualIndex) return FALSE;

+

+    return TRUE;

+}

+

+/** Restore Render's picture */

+static void dmxBERestoreRenderPict(pointer value, XID id, pointer n)

+{

+    PicturePtr   pPicture = value;               /* The picture */

+    DrawablePtr  pDraw    = pPicture->pDrawable; /* The picture's drawable */

+    int          scrnNum  = (int)n;

+

+    if (pDraw->pScreen->myNum != scrnNum) {

+	/* Picture not on the screen we are restoring*/

+	return;

+    }

+

+    if (pDraw->type == DRAWABLE_PIXMAP) {

+	PixmapPtr  pPixmap = (PixmapPtr)pDraw;

+	

+	/* Create and restore the pixmap drawable */

+	dmxBECreatePixmap(pPixmap);

+	dmxBERestorePixmap(pPixmap);

+    }

+

+    dmxBECreatePicture(pPicture);

+}

+

+/** Restore Render's glyphs */

+static void dmxBERestoreRenderGlyph(pointer value, XID id, pointer n)

+{

+    GlyphSetPtr      glyphSet   = value;

+    int              scrnNum    = (int)n;

+    dmxGlyphPrivPtr  glyphPriv  = DMX_GET_GLYPH_PRIV(glyphSet);

+    DMXScreenInfo   *dmxScreen  = &dmxScreens[scrnNum];

+    GlyphRefPtr      table;

+    char            *images;

+    Glyph           *gids;

+    XGlyphInfo      *glyphs;

+    char            *pos;

+    int              beret;

+    int              len_images = 0;

+    int              i;

+    int              ctr;

+

+    if (glyphPriv->glyphSets[scrnNum]) {

+	/* Only restore glyphs on the screen we are attaching */

+	return;

+    }

+

+    /* First we must create the glyph set on the backend. */

+    if ((beret = dmxBECreateGlyphSet(scrnNum, glyphSet)) != Success) {

+	dmxLog(dmxWarning,

+	       "\tdmxBERestoreRenderGlyph failed to create glyphset!\n");

+	return;

+    }

+

+    /* Now for the complex part, restore the glyph data */

+    table = glyphSet->hash.table;

+

+    /* We need to know how much memory to allocate for this part */

+    for (i = 0; i < glyphSet->hash.hashSet->size; i++) {

+	GlyphRefPtr  gr = &table[i];

+	GlyphPtr     gl = gr->glyph;

+

+	if (!gl || gl == DeletedGlyph) continue;

+	len_images += gl->size - sizeof(gl->info);

+    }

+

+    /* Now allocate the memory we need */

+    images = calloc(len_images, sizeof(char));

+    gids   = malloc(glyphSet->hash.tableEntries*sizeof(Glyph));

+    glyphs = malloc(glyphSet->hash.tableEntries*sizeof(XGlyphInfo));

+

+    pos = images;

+    ctr = 0;

+    

+    /* Fill the allocated memory with the proper data */

+    for (i = 0; i < glyphSet->hash.hashSet->size; i++) {

+	GlyphRefPtr  gr = &table[i];

+	GlyphPtr     gl = gr->glyph;

+

+	if (!gl || gl == DeletedGlyph) continue;

+

+	/* First lets put the data into gids */

+	gids[ctr] = gr->signature;

+

+	/* Next do the glyphs data structures */

+	glyphs[ctr].width  = gl->info.width;

+	glyphs[ctr].height = gl->info.height;

+	glyphs[ctr].x      = gl->info.x;

+	glyphs[ctr].y      = gl->info.y;

+	glyphs[ctr].xOff   = gl->info.xOff;

+	glyphs[ctr].yOff   = gl->info.yOff;

+

+	/* Copy the images from the DIX's data into the buffer */

+	memcpy(pos, gl+1, gl->size - sizeof(gl->info));

+	pos += gl->size - sizeof(gl->info);

+	ctr++;

+    }

+    

+    /* Now restore the glyph data */

+    XRenderAddGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[scrnNum],

+		     gids,glyphs, glyphSet->hash.tableEntries, images,

+		     len_images);

+

+    /* Clean up */

+    free(images);

+    free(gids);

+    free(glyphs);    

+}

+

+/** Reattach previously detached back-end screen. */

+int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)

+{

+    ScreenPtr      pScreen;

+    DMXScreenInfo *dmxScreen;

+    CARD32         scrnNum   = idx;

+    DMXScreenInfo  oldDMXScreen;

+    int            i;

+

+    /* Return failure if dynamic addition/removal of screens is disabled */

+    if (!dmxAddRemoveScreens) {

+	dmxLog(dmxWarning,

+	       "Attempting to add a screen, but the AddRemoveScreen\n");

+	dmxLog(dmxWarning,

+	       "extension has not been enabled.  To enable this extension\n");

+	dmxLog(dmxWarning,

+	       "add the \"-addremovescreens\" option either to the command\n");

+	dmxLog(dmxWarning,

+	       "line or in the configuration file.\n");

+	return 1;

+    }

+

+    /* Cannot add a screen that does not exist */

+    if (idx < 0 || idx >= dmxNumScreens) return 1;

+    pScreen = screenInfo.screens[idx];

+    dmxScreen = &dmxScreens[idx];

+

+    /* Cannot attach to a screen that is already opened */

+    if (dmxScreen->beDisplay) {

+	dmxLog(dmxWarning,

+	       "Attempting to add screen #%d but a screen already exists\n",

+	       idx);

+	return 1;

+    }

+

+    dmxLogOutput(dmxScreen, "Attaching screen #%d\n", idx);

+

+    /* Save old info */

+    oldDMXScreen = *dmxScreen;

+

+    /* Copy the name to the new screen */

+    dmxScreen->name = strdup(attr->displayName);

+

+    /* Open display and get all of the screen info */

+    if (!dmxOpenDisplay(dmxScreen)) {

+	dmxLog(dmxWarning,

+               "dmxOpenDisplay: Unable to open display %s\n",

+               dmxScreen->name);

+

+	/* Restore the old screen */

+	*dmxScreen = oldDMXScreen;

+	return 1;

+    }

+

+    dmxSetErrorHandler(dmxScreen);

+    dmxCheckForWM(dmxScreen);

+    dmxGetScreenAttribs(dmxScreen);

+

+    if (!dmxGetVisualInfo(dmxScreen)) {

+	dmxLog(dmxWarning, "dmxGetVisualInfo: No matching visuals found\n");

+	XFree(dmxScreen->beVisuals);

+	XCloseDisplay(dmxScreen->beDisplay);

+

+	/* Restore the old screen */

+	*dmxScreen = oldDMXScreen;

+	return 1;

+    }

+

+    dmxGetColormaps(dmxScreen);

+    dmxGetPixmapFormats(dmxScreen);

+

+    /* Verify that the screen to be added has the same info as the

+     * previously added screen. */

+    if (!dmxCompareScreens(dmxScreen, &oldDMXScreen)) {

+	dmxLog(dmxWarning,

+	       "New screen data (%s) does not match previously\n",

+	       dmxScreen->name);

+	dmxLog(dmxWarning,

+	       "attached screen data (%s)\n",

+	       oldDMXScreen.name);

+	dmxLog(dmxWarning,

+	       "All data must match in order to attach to screen #%d\n",

+	       idx);

+	XFree(dmxScreen->beVisuals);

+	XFree(dmxScreen->beDepths);

+	XFree(dmxScreen->bePixmapFormats);

+	XCloseDisplay(dmxScreen->beDisplay);

+

+	/* Restore the old screen */

+	*dmxScreen = oldDMXScreen;

+	return 1;

+    }

+

+    /* Initialize the BE screen resources */

+    dmxBEScreenInit(idx, screenInfo.screens[idx]);

+

+    /* TODO: Handle GLX visual initialization.  GLXProxy needs to be

+     * updated to handle dynamic addition/removal of screens. */

+

+    /* Create default stipple */

+    dmxBECreatePixmap(pScreen->PixmapPerDepth[0]);

+    dmxBERestorePixmap(pScreen->PixmapPerDepth[0]);

+

+    /* Create the scratch GCs */

+    dmxBECreateScratchGCs(idx);

+

+    /* Create the default font */

+    (void)dmxBELoadFont(pScreen, defaultFont);

+

+    /* Create all resources that don't depend on windows */

+    for (i = currentMaxClients; --i >= 0; )

+	if (clients[i])

+	    FindAllClientResources(clients[i], dmxBECreateResources,

+				   (pointer)idx);

+

+    /* Create window hierarchy (top down) */

+    dmxBECreateWindowTree(idx);

+

+    /* Restore the picture state for RENDER */

+    for (i = currentMaxClients; --i >= 0; )

+	if (clients[i])

+	    FindClientResourcesByType(clients[i],PictureType, 

+				      dmxBERestoreRenderPict,(pointer)idx);

+

+    /* Restore the glyph state for RENDER */

+    for (i = currentMaxClients; --i >= 0; )

+	if (clients[i])

+	    FindClientResourcesByType(clients[i],GlyphSetType, 

+				      dmxBERestoreRenderGlyph,(pointer)idx);

+

+    /* Refresh screen by generating exposure events for all windows */

+    dmxForceExposures(idx);

+

+    dmxSync(&dmxScreens[idx], TRUE);

+

+    /* We used these to compare the old and new screens.  They are no

+     * longer needed since we have a newly attached screen, so we can

+     * now free the old screen's resources. */

+    XFree(oldDMXScreen.beVisuals);

+    XFree(oldDMXScreen.beDepths);

+    XFree(oldDMXScreen.bePixmapFormats);

+    /* TODO: should oldDMXScreen.name be freed?? */

+

+#ifdef PANORAMIX

+    if (!noPanoramiXExtension)

+	return dmxConfigureScreenWindows(1, &scrnNum, attr, NULL);

+    else

+#endif

+	return 0; /* Success */

+}

+

+/*

+ * Resources that may have state on the BE server and need to be freed:

+ *

+ * RT_NONE

+ * RT_WINDOW

+ * RT_PIXMAP

+ * RT_GC

+ * RT_FONT

+ * RT_CURSOR

+ * RT_COLORMAP

+ * RT_CMAPENTRY

+ * RT_OTHERCLIENT

+ * RT_PASSIVEGRAB

+ * XRT_WINDOW

+ * XRT_PIXMAP

+ * XRT_GC

+ * XRT_COLORMAP

+ * XRT_PICTURE

+ * PictureType

+ * PictFormatType

+ * GlyphSetType

+ * ClientType

+ * EventType

+ * RT_INPUTCLIENT

+ * XETrapType

+ * RTCounter

+ * RTAwait

+ * RTAlarmClient

+ * RT_XKBCLIENT

+ * RTContext

+ * TagResType

+ * StalledResType

+ * SecurityAuthorizationResType

+ * RTEventClient

+ * __glXContextRes

+ * __glXClientRes

+ * __glXPixmapRes

+ * __glXWindowRes

+ * __glXPbufferRes

+ */

+

+#ifdef PANORAMIX

+/** Search the Xinerama XRT_PIXMAP resources for the pixmap that needs

+ *  to have its image saved. */

+static void dmxBEFindPixmapImage(pointer value, XID id, RESTYPE type,

+				 pointer p)

+{

+    if ((type & TypeMask) == (XRT_PIXMAP & TypeMask)) {

+	PixmapPtr      pDst     = (PixmapPtr)p;

+	int            idx      = pDst->drawable.pScreen->myNum;

+	PanoramiXRes  *pXinPix  = (PanoramiXRes *)value;

+	PixmapPtr      pPix;

+	int            i;

+

+	pPix = (PixmapPtr)LookupIDByType(pXinPix->info[idx].id, RT_PIXMAP);

+	if (pPix != pDst) return; /* Not a match.... Next! */

+

+	for (i = 0; i < PanoramiXNumScreens; i++) {

+	    PixmapPtr      pSrc;

+	    dmxPixPrivPtr  pSrcPriv = NULL;

+

+	    if (i == idx) continue; /* Self replication is bad */

+

+	    pSrc =

+		(PixmapPtr)LookupIDByType(pXinPix->info[i].id, RT_PIXMAP);

+	    pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);

+	    if (pSrcPriv->pixmap) {

+		FoundPixImage = True;

+		return;

+	    }

+	}

+    }

+}

+#endif

+

+/** Save the pixmap image only when there is not another screen with

+ *  that pixmap from which the image can be read when the screen is

+ *  reattached.  To do this, we first try to find a pixmap on another

+ *  screen corresponding to the one we are trying to save.  If we find

+ *  one, then we do not need to save the image data since during

+ *  reattachment, the image data can be read from that other pixmap.

+ *  However, if we do not find one, then we need to save the image data.

+ *  The common case for these are for the default stipple and root

+ *  tile. */

+static void dmxBESavePixmap(PixmapPtr pPixmap)

+{

+#ifdef PANORAMIX

+    int i;

+

+    /* If Xinerama is not active, there's nothing we can do (see comment

+     * in #else below for more info). */

+    if (noPanoramiXExtension) return;

+

+    FoundPixImage = False;

+    for (i = currentMaxClients; --i >= 0; )

+	if (clients[i])

+	    FindAllClientResources(clients[i], dmxBEFindPixmapImage,

+				   (pointer)pPixmap);

+

+    /* Save the image only if there is no other screens that have a

+     * pixmap that corresponds to the one we are trying to save. */

+    if (!FoundPixImage) {

+	dmxPixPrivPtr  pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap);

+

+	if (!pPixPriv->detachedImage) {

+	    ScreenPtr      pScreen   = pPixmap->drawable.pScreen;

+	    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];

+

+	    pPixPriv->detachedImage = XGetImage(dmxScreen->beDisplay,

+						pPixPriv->pixmap,

+						0, 0,

+						pPixmap->drawable.width,

+						pPixmap->drawable.height,

+						-1,

+						ZPixmap);

+	    if (!pPixPriv->detachedImage)

+		dmxLog(dmxWarning, "Cannot save pixmap image\n");

+	}

+    }

+#else

+    /* NOTE: The only time there is a pixmap on another screen that

+     * corresponds to the one we are trying to save is when Xinerama is

+     * active.  Otherwise, the pixmap image data is only stored on a

+     * single screen, which means that once it is detached, that data is

+     * lost.  We could save the data here, but then that would require

+     * us to implement the ability for Xdmx to keep the pixmap up to

+     * date while the screen is detached, which is beyond the scope of

+     * the current project. */

+    return;

+#endif

+}

+

+/** Destroy resources on the back-end server.  This function is called

+ *  from #dmxDetachScreen() via the dix layer's FindAllResources

+ *  function.  It walks all resources, compares them to the screen

+ *  number passed in as \a n and calls the appropriate DMX function to

+ *  free the associated resource on the back-end server. */

+static void dmxBEDestroyResources(pointer value, XID id, RESTYPE type,

+				  pointer n)

+{

+    int        scrnNum = (int)n;

+    ScreenPtr  pScreen = screenInfo.screens[scrnNum];

+

+    if ((type & TypeMask) == (RT_WINDOW & TypeMask)) {

+	/* Window resources are destroyed below in dmxBEDestroyWindowTree */

+    } else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) {

+	PixmapPtr  pPix = value;

+	if (pPix->drawable.pScreen->myNum == scrnNum) {

+	    dmxBESavePixmap(pPix);

+	    dmxBEFreePixmap(pPix);

+	}

+    } else if ((type & TypeMask) == (RT_GC & TypeMask)) {

+	GCPtr  pGC = value;

+	if (pGC->pScreen->myNum == scrnNum)

+	    dmxBEFreeGC(pGC);

+    } else if ((type & TypeMask) == (RT_FONT & TypeMask)) {

+	dmxBEFreeFont(pScreen, (FontPtr)value);

+    } else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) {

+	dmxBEFreeCursor(pScreen, (CursorPtr)value);

+    } else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) {

+	ColormapPtr  pCmap = value;

+	if (pCmap->pScreen->myNum == scrnNum)

+	    dmxBEFreeColormap((ColormapPtr)value);

+    } else if ((type & TypeMask) == (PictureType & TypeMask)) {

+	PicturePtr  pPict = value;

+	if (pPict->pDrawable->pScreen->myNum == scrnNum) {

+	    /* Free the pixmaps on the backend if needed */

+	    if (pPict->pDrawable->type == DRAWABLE_PIXMAP) {

+		PixmapPtr pPixmap = (PixmapPtr)(pPict->pDrawable);

+		dmxBESavePixmap(pPixmap);

+		dmxBEFreePixmap(pPixmap);

+	    }

+	    dmxBEFreePicture((PicturePtr)value);

+	}

+    } else if ((type & TypeMask) == (GlyphSetType & TypeMask)) {

+	dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr)value);

+    } else {

+	/* Other resource types??? */

+    }

+}

+

+/** Destroy the scratch GCs that are created per depth. */

+static void dmxBEDestroyScratchGCs(int scrnNum)

+{

+    ScreenPtr  pScreen = screenInfo.screens[scrnNum];

+    GCPtr     *ppGC    = pScreen->GCperDepth;

+    int        i;

+

+    for (i = 0; i <= pScreen->numDepths; i++)

+	dmxBEFreeGC(ppGC[i]);

+}

+

+/** Destroy window hierachy on back-end server.  To ensure that all

+ *  XDestroyWindow() calls succeed, they must be performed in a bottom

+ *  up order so that windows are not destroyed before their children.

+ *  XDestroyWindow(), which is called from #dmxBEDestroyWindow(), will

+ *  destroy a window as well as all of it's children. */

+static void dmxBEDestroyWindowTree(int idx)

+{

+    WindowPtr  pWin   = screenInfo.screens[idx]->root;

+    WindowPtr  pChild = pWin;

+

+    while (1) {

+	if (pChild->firstChild) {

+	    pChild = pChild->firstChild;

+	    continue;

+	}

+

+	/* Destroy the window */

+	dmxBEDestroyWindow(pChild);

+

+	/* Make sure we destroy the window's border and background

+	 * pixmaps if they exist */

+	if (!pChild->borderIsPixel) {

+	    dmxBESavePixmap(pChild->border.pixmap);

+	    dmxBEFreePixmap(pChild->border.pixmap);

+	}

+	if (pChild->backgroundState == BackgroundPixmap) {

+	    dmxBESavePixmap(pChild->background.pixmap);

+	    dmxBEFreePixmap(pChild->background.pixmap);

+	}

+

+	while (!pChild->nextSib && (pChild != pWin)) {

+	    pChild = pChild->parent;

+	    dmxBEDestroyWindow(pChild);

+	    if (!pChild->borderIsPixel) {

+		dmxBESavePixmap(pChild->border.pixmap);

+		dmxBEFreePixmap(pChild->border.pixmap);

+	    }

+	    if (pChild->backgroundState == BackgroundPixmap) {

+		dmxBESavePixmap(pChild->background.pixmap);

+		dmxBEFreePixmap(pChild->background.pixmap);

+	    }

+	}

+

+	if (pChild == pWin)

+	    break;

+

+	pChild = pChild->nextSib;

+    }

+}

+

+/** Detach back-end screen. */

+int dmxDetachScreen(int idx)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[idx];

+    int            i;

+

+    /* Return failure if dynamic addition/removal of screens is disabled */

+    if (!dmxAddRemoveScreens) {

+	dmxLog(dmxWarning,

+	       "Attempting to remove a screen, but the AddRemoveScreen\n");

+	dmxLog(dmxWarning,

+	       "extension has not been enabled.  To enable this extension\n");

+	dmxLog(dmxWarning,

+	       "add the \"-addremovescreens\" option either to the command\n");

+	dmxLog(dmxWarning,

+	       "line or in the configuration file.\n");

+	return 1;

+    }

+

+    /* Cannot remove a screen that does not exist */

+    if (idx < 0 || idx >= dmxNumScreens) return 1;

+

+    /* Cannot detach from a screen that is not opened */

+    if (!dmxScreen->beDisplay) {

+	dmxLog(dmxWarning,

+	       "Attempting to remove screen #%d but it has not been opened\n",

+	       idx);

+	return 1;

+    }

+

+    dmxLogOutput(dmxScreen, "Detaching screen #%d\n", idx);

+

+    /* Detach input */

+    dmxInputDetachAll(dmxScreen);

+

+    /* Save all relevant state (TODO) */

+

+    /* Free all non-window resources related to this screen */

+    for (i = currentMaxClients; --i >= 0; )

+	if (clients[i])

+	    FindAllClientResources(clients[i], dmxBEDestroyResources,

+				   (pointer)idx);

+

+    /* Free scratch GCs */

+    dmxBEDestroyScratchGCs(idx);

+

+    /* Free window resources related to this screen */

+    dmxBEDestroyWindowTree(idx);

+

+    /* Free default stipple */

+    dmxBESavePixmap(screenInfo.screens[idx]->PixmapPerDepth[0]);

+    dmxBEFreePixmap(screenInfo.screens[idx]->PixmapPerDepth[0]);

+

+    /* Free the remaining screen resources and close the screen */

+    dmxBECloseScreen(screenInfo.screens[idx]);

+

+    /* Adjust the cursor boundaries (paints detached console window) */

+    dmxAdjustCursorBoundaries();

+

+    return 0; /* Success */

+}

diff --git a/xorg-server/hw/dmx/dmxfont.c b/xorg-server/hw/dmx/dmxfont.c
index 3f0264edb..8b57b6f3b 100644
--- a/xorg-server/hw/dmx/dmxfont.c
+++ b/xorg-server/hw/dmx/dmxfont.c
@@ -108,7 +108,7 @@ static Bool dmxCheckFontPathElement(DMXScreenInfo *dmxScreen, char *fp)
     dmxSync(dmxScreen, TRUE);   /* Must complete before removing handler */

     XSetErrorHandler(oldErrorHandler);

 

-    return (dmxFontLastError == 0);

+    return dmxFontLastError == 0;

 }

 

 static int dmxSetFontPath(DMXScreenInfo *dmxScreen)

diff --git a/xorg-server/hw/dmx/dmxgc.c b/xorg-server/hw/dmx/dmxgc.c
index 82f74b6e6..10e93c110 100644
--- a/xorg-server/hw/dmx/dmxgc.c
+++ b/xorg-server/hw/dmx/dmxgc.c
@@ -85,7 +85,7 @@ static GCOps dmxGCOps = {
 /** Initialize the GC on \a pScreen */

 Bool dmxInitGC(ScreenPtr pScreen)

 {

-    if (!dixRequestPrivate(dmxGCPrivateKey, sizeof(dmxGCPrivRec)))

+    if (!dixRegisterPrivateKey(&dmxGCPrivateKeyRec, PRIVATE_GC, sizeof(dmxGCPrivRec)))

             return FALSE;

     return TRUE;

 }

@@ -363,9 +363,9 @@ void dmxChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects)
 

     case CT_REGION:

 	if (dmxScreen->beDisplay) {

-	    nRects = REGION_NUM_RECTS((RegionPtr)pGC->clientClip);

+	    nRects = RegionNumRects((RegionPtr)pGC->clientClip);

 	    pRects = malloc(nRects * sizeof(*pRects));

-	    pBox   = REGION_RECTS((RegionPtr)pGC->clientClip);

+	    pBox   = RegionRects((RegionPtr)pGC->clientClip);

 

 	    for (i = 0; i < nRects; i++) {

 		pRects[i].x      = pBox[i].x1;

diff --git a/xorg-server/hw/dmx/dmxgc.h b/xorg-server/hw/dmx/dmxgc.h
index 2da3ba85e..43a6296af 100644
--- a/xorg-server/hw/dmx/dmxgc.h
+++ b/xorg-server/hw/dmx/dmxgc.h
@@ -1,89 +1,86 @@
-/*
- * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *
- */
-
-/** \file
- * Interface for GC support.  \see dmxgc.c */
-
-#ifndef DMXGC_H
-#define DMXGC_H
-
-#include "gcstruct.h"
-
-/** GC private area. */
-typedef struct _dmxGCPriv {
-    GCOps   *ops;
-    GCFuncs *funcs;
-    XlibGC   gc;
-    Bool     msc;
-} dmxGCPrivRec, *dmxGCPrivPtr;
-
-
-extern Bool dmxInitGC(ScreenPtr pScreen);
-
-extern Bool dmxCreateGC(GCPtr pGC);
-extern void dmxValidateGC(GCPtr pGC, unsigned long changes,
-			  DrawablePtr pDrawable);
-extern void dmxChangeGC(GCPtr pGC, unsigned long mask);
-extern void dmxCopyGC(GCPtr pGCSrc, unsigned long changes, GCPtr pGCDst);
-extern void dmxDestroyGC(GCPtr pGC);
-extern void dmxChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects);
-extern void dmxDestroyClip(GCPtr pGC);
-extern void dmxCopyClip(GCPtr pGCDst, GCPtr pGCSrc);
-
-extern void dmxBECreateGC(ScreenPtr pScreen, GCPtr pGC);
-extern Bool dmxBEFreeGC(GCPtr pGC);
-
-/** Private index.  \see dmxgc.c \see dmxscrinit.c */
-extern DevPrivateKey dmxGCPrivateKey;
-
-/** Get private. */
-#define DMX_GET_GC_PRIV(_pGC)						\
-    (dmxGCPrivPtr)dixLookupPrivate(&(_pGC)->devPrivates, dmxGCPrivateKey)
-
-#define DMX_GC_FUNC_PROLOGUE(_pGC)					\
-do {									\
-    dmxGCPrivPtr _pGCPriv = DMX_GET_GC_PRIV(_pGC);			\
-    DMX_UNWRAP(funcs, _pGCPriv, (_pGC));				\
-    if (_pGCPriv->ops)							\
-	DMX_UNWRAP(ops, _pGCPriv, (_pGC));				\
-} while (0)
-
-#define DMX_GC_FUNC_EPILOGUE(_pGC)					\
-do {									\
-    dmxGCPrivPtr _pGCPriv = DMX_GET_GC_PRIV(_pGC);			\
-    DMX_WRAP(funcs, &dmxGCFuncs, _pGCPriv, (_pGC));			\
-    if (_pGCPriv->ops)							\
-	DMX_WRAP(ops, &dmxGCOps, _pGCPriv, (_pGC));			\
-} while (0)
-
-#endif /* DMXGC_H */
+/*

+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Kevin E. Martin <kem@redhat.com>

+ *

+ */

+

+/** \file

+ * Interface for GC support.  \see dmxgc.c */

+

+#ifndef DMXGC_H

+#define DMXGC_H

+

+#include "gcstruct.h"

+

+/** GC private area. */

+typedef struct _dmxGCPriv {

+    GCOps   *ops;

+    GCFuncs *funcs;

+    XlibGC   gc;

+    Bool     msc;

+} dmxGCPrivRec, *dmxGCPrivPtr;

+

+

+extern Bool dmxInitGC(ScreenPtr pScreen);

+

+extern Bool dmxCreateGC(GCPtr pGC);

+extern void dmxValidateGC(GCPtr pGC, unsigned long changes,

+			  DrawablePtr pDrawable);

+extern void dmxChangeGC(GCPtr pGC, unsigned long mask);

+extern void dmxCopyGC(GCPtr pGCSrc, unsigned long changes, GCPtr pGCDst);

+extern void dmxDestroyGC(GCPtr pGC);

+extern void dmxChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects);

+extern void dmxDestroyClip(GCPtr pGC);

+extern void dmxCopyClip(GCPtr pGCDst, GCPtr pGCSrc);

+

+extern void dmxBECreateGC(ScreenPtr pScreen, GCPtr pGC);

+extern Bool dmxBEFreeGC(GCPtr pGC);

+

+/** Get private. */

+#define DMX_GET_GC_PRIV(_pGC)						\

+    (dmxGCPrivPtr)dixLookupPrivate(&(_pGC)->devPrivates, dmxGCPrivateKey)

+

+#define DMX_GC_FUNC_PROLOGUE(_pGC)					\

+do {									\

+    dmxGCPrivPtr _pGCPriv = DMX_GET_GC_PRIV(_pGC);			\

+    DMX_UNWRAP(funcs, _pGCPriv, (_pGC));				\

+    if (_pGCPriv->ops)							\

+	DMX_UNWRAP(ops, _pGCPriv, (_pGC));				\

+} while (0)

+

+#define DMX_GC_FUNC_EPILOGUE(_pGC)					\

+do {									\

+    dmxGCPrivPtr _pGCPriv = DMX_GET_GC_PRIV(_pGC);			\

+    DMX_WRAP(funcs, &dmxGCFuncs, _pGCPriv, (_pGC));			\

+    if (_pGCPriv->ops)							\

+	DMX_WRAP(ops, &dmxGCOps, _pGCPriv, (_pGC));			\

+} while (0)

+

+#endif /* DMXGC_H */

diff --git a/xorg-server/hw/dmx/dmxgcops.c b/xorg-server/hw/dmx/dmxgcops.c
index 267a306db..02b45a213 100644
--- a/xorg-server/hw/dmx/dmxgcops.c
+++ b/xorg-server/hw/dmx/dmxgcops.c
@@ -1,603 +1,603 @@
-/*
- * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *
- */
-
-/** \file
- * This file provides support for GC operations. */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "dmx.h"
-#include "dmxsync.h"
-#include "dmxgc.h"
-#include "dmxgcops.h"
-#include "dmxwindow.h"
-#include "dmxpixmap.h"
-
-#include "mi.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-#include "dixfontstr.h"
-
-#ifdef PANORAMIX
-#include "panoramiXsrv.h"
-#endif
-
-#define DMX_GCOPS_SET_DRAWABLE(_pDraw, _draw)				\
-do {									\
-    if ((_pDraw)->type == DRAWABLE_WINDOW) {				\
-	dmxWinPrivPtr  pWinPriv =					\
-	    DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw));			\
-	(_draw) = (Drawable)pWinPriv->window;				\
-    } else {								\
-	dmxPixPrivPtr  pPixPriv =					\
-	    DMX_GET_PIXMAP_PRIV((PixmapPtr)(_pDraw));			\
-	(_draw) = (Drawable)pPixPriv->pixmap;				\
-    }									\
-} while (0)
-
-#define DMX_GCOPS_OFFSCREEN(_pDraw)					\
-    (!dmxScreens[(_pDraw)->pScreen->myNum].beDisplay ||			\
-     (dmxOffScreenOpt &&						\
-      (_pDraw)->type == DRAWABLE_WINDOW &&				\
-      (DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->offscreen ||		\
-       !DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->window)))
-
-/** Fill spans -- this function should never be called. */
-void dmxFillSpans(DrawablePtr pDrawable, GCPtr pGC,
-		  int nInit, DDXPointPtr pptInit, int *pwidthInit,
-		  int fSorted)
-{
-    /* Error -- this should never happen! */
-}
-
-/** Set spans -- this function should never be called. */
-void dmxSetSpans(DrawablePtr pDrawable, GCPtr pGC,
-		 char *psrc, DDXPointPtr ppt, int *pwidth, int nspans,
-		 int fSorted)
-{
-    /* Error -- this should never happen! */
-}
-
-/** Transfer \a pBits image to back-end server associated with \a
- *  pDrawable's screen.  If primitive subdivision optimization is
- *  enabled, then only transfer the sections of \a pBits that are
- *  visible (i.e., not-clipped) to the back-end server. */
-void dmxPutImage(DrawablePtr pDrawable, GCPtr pGC,
-		 int depth, int x, int y, int w, int h,
-		 int leftPad, int format, char *pBits)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    XImage        *img;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    img = XCreateImage(dmxScreen->beDisplay,
-		       dmxScreen->beVisuals[dmxScreen->beDefVisualIndex].visual,
-		       depth, format, leftPad, pBits, w, h,
-		       BitmapPad(dmxScreen->beDisplay),
-		       (format == ZPixmap) ?
-		       PixmapBytePad(w, depth) : BitmapBytePad(w+leftPad));
-
-    if (img) {
-	Drawable draw;
-
-	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-	if (dmxSubdividePrimitives && pGC->pCompositeClip) {
-	    RegionPtr  pSubImages;
-	    RegionPtr  pClip;
-	    BoxRec     box;
-	    BoxPtr     pBox;
-	    int        nBox;
-
-	    box.x1 = x;
-	    box.y1 = y;
-	    box.x2 = x + w;
-	    box.y2 = y + h;
-	    pSubImages = REGION_CREATE(pGC->pScreen, &box, 1);
-
-	    pClip = REGION_CREATE(pGC->pScreen, NullBox, 1);
-	    REGION_COPY(pGC->pScreen, pClip, pGC->pCompositeClip);
-	    REGION_TRANSLATE(pGC->pScreen, pClip,
-			     -pDrawable->x, -pDrawable->y);
-	    REGION_INTERSECT(pGC->pScreen, pSubImages, pSubImages, pClip);
-
-	    nBox = REGION_NUM_RECTS(pSubImages);
-	    pBox = REGION_RECTS(pSubImages);
-
-	    while (nBox--) {
-		XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc, img,
-			  pBox->x1 - box.x1,
-			  pBox->y1 - box.y1,
-			  pBox->x1,
-			  pBox->y1,
-			  pBox->x2 - pBox->x1,
-			  pBox->y2 - pBox->y1);
-		pBox++;
-	    }
-            REGION_DESTROY(pGC->pScreen, pClip);
-            REGION_DESTROY(pGC->pScreen, pSubImages);
-	} else {
-	    XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		      img, 0, 0, x, y, w, h);
-	}
-	XFree(img);             /* Use XFree instead of XDestroyImage
-                                 * because pBits is passed in from the
-                                 * caller. */
-
-	dmxSync(dmxScreen, FALSE);
-    } else {
-	/* Error -- this should not happen! */
-    }
-}
-
-/** Copy area from \a pSrc drawable to \a pDst drawable on the back-end
- *  server associated with \a pSrc drawable's screen.  If the offscreen
- *  optimization is enabled, only copy when both \a pSrc and \a pDst are
- *  at least partially visible. */
-RegionPtr dmxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		      int srcx, int srcy, int w, int h, int dstx, int dsty)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       srcDraw, dstDraw;
-
-    if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
-	return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,
-				 dstx, dsty, 0L);
-
-    DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
-    DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
-
-    XCopyArea(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,
-	      srcx, srcy, w, h, dstx, dsty);
-    dmxSync(dmxScreen, FALSE);
-
-    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,
-			     dstx, dsty, 0L);
-}
-
-/** Copy plane number \a bitPlane from \a pSrc drawable to \a pDst
- *  drawable on the back-end server associated with \a pSrc drawable's
- *  screen.  If the offscreen optimization is enabled, only copy when
- *  both \a pSrc and \a pDst are at least partially visible. */
-RegionPtr dmxCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		       int srcx, int srcy, int width, int height,
-		       int dstx, int dsty, unsigned long bitPlane)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       srcDraw, dstDraw;
-
-    if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
-	return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
-				 dstx, dsty, bitPlane);
-
-    DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
-    DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
-
-    XCopyPlane(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,
-	       srcx, srcy, width, height, dstx, dsty, bitPlane);
-    dmxSync(dmxScreen, FALSE);
-
-    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
-			     dstx, dsty, bitPlane);
-}
-
-/** Render list of points, \a pptInit in \a pDrawable on the back-end
- *  server associated with \a pDrawable's screen.  If the offscreen
- *  optimization is enabled, only draw when \a pDrawable is at least
- *  partially visible. */
-void dmxPolyPoint(DrawablePtr pDrawable, GCPtr pGC,
-		  int mode, int npt, DDXPointPtr pptInit)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawPoints(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		(XPoint *)pptInit, npt, mode);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of connected lines, \a pptInit in \a pDrawable on the
- *  back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolylines(DrawablePtr pDrawable, GCPtr pGC,
-		  int mode, int npt, DDXPointPtr pptInit)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawLines(dmxScreen->beDisplay, draw, pGCPriv->gc,
-	       (XPoint *)pptInit, npt, mode);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of disjoint segments, \a pSegs in \a pDrawable on the
- *  back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolySegment(DrawablePtr pDrawable, GCPtr pGC,
-		    int nseg, xSegment *pSegs)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawSegments(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		  (XSegment *)pSegs, nseg);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of rectangle outlines, \a pRects in \a pDrawable on the
- *  back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolyRectangle(DrawablePtr pDrawable, GCPtr pGC,
-		      int nrects, xRectangle *pRects)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		    (XRectangle *)pRects, nrects);
-
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of arc outlines, \a parcs in \a pDrawable on the
- *  back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolyArc(DrawablePtr pDrawable, GCPtr pGC,
-		int narcs, xArc *parcs)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawArcs(dmxScreen->beDisplay, draw, pGCPriv->gc,
-	      (XArc *)parcs, narcs);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render a filled polygons in \a pDrawable on the back-end server
- *  associated with \a pDrawable's screen.  If the offscreen
- *  optimization is enabled, only draw when \a pDrawable is at least
- *  partially visible. */
-void dmxFillPolygon(DrawablePtr pDrawable, GCPtr pGC,
-		    int shape, int mode, int count, DDXPointPtr pPts)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XFillPolygon(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		 (XPoint *)pPts, count, shape, mode);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of filled rectangles, \a prectInit in \a pDrawable on
- *  the back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
-		     int nrectFill, xRectangle *prectInit)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XFillRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		    (XRectangle *)prectInit, nrectFill);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of filled arcs, \a parcs in \a pDrawable on the back-end
- *  server associated with \a pDrawable's screen.  If the offscreen
- *  optimization is enabled, only draw when \a pDrawable is at least
- *  partially visible. */
-void dmxPolyFillArc(DrawablePtr pDrawable, GCPtr pGC,
-		    int narcs, xArc *parcs)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XFillArcs(dmxScreen->beDisplay, draw, pGCPriv->gc,
-	      (XArc *)parcs, narcs);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render string of 8-bit \a chars (foreground only) in \a pDrawable on
- *  the back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-int dmxPolyText8(DrawablePtr pDrawable, GCPtr pGC,
-		 int x, int y, int count, char *chars)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    unsigned long  n, i;
-    int            w;
-    CharInfoPtr    charinfo[255];
-    Drawable       draw;
-
-    GetGlyphs(pGC->font, (unsigned long)count, (unsigned char *)chars,
-	      Linear8Bit, &n, charinfo);
-
-    /* Calculate text width */
-    w = 0;
-    for (i = 0; i < n; i++) w += charinfo[i]->metrics.characterWidth;
-
-    if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {
-	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-	XDrawString(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		    x, y, chars, count);
-	dmxSync(dmxScreen, FALSE);
-    }
-
-    return x+w;
-}
-
-/** Render string of 16-bit \a chars (foreground only) in \a pDrawable
- *  on the back-end server associated with \a pDrawable's screen.  If
- *  the offscreen optimization is enabled, only draw when \a pDrawable
- *  is at least partially visible. */
-int dmxPolyText16(DrawablePtr pDrawable, GCPtr pGC,
-		  int x, int y, int count, unsigned short *chars)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    unsigned long  n, i;
-    int            w;
-    CharInfoPtr    charinfo[255];
-    Drawable       draw;
-
-    GetGlyphs(pGC->font, (unsigned long)count, (unsigned char *)chars,
-	      (FONTLASTROW(pGC->font) == 0) ? Linear16Bit : TwoD16Bit,
-	      &n, charinfo);
-
-    /* Calculate text width */
-    w = 0;
-    for (i = 0; i < n; i++) w += charinfo[i]->metrics.characterWidth;
-
-    if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {
-	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-	XDrawString16(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		      x, y, (XChar2b *)chars, count);
-	dmxSync(dmxScreen, FALSE);
-    }
-
-    return x+w;
-}
-
-/** Render string of 8-bit \a chars (both foreground and background) in
- *  \a pDrawable on the back-end server associated with \a pDrawable's
- *  screen.  If the offscreen optimization is enabled, only draw when \a
- *  pDrawable is at least partially visible. */
-void dmxImageText8(DrawablePtr pDrawable, GCPtr pGC,
-		   int x, int y, int count, char *chars)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawImageString(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		     x, y, chars, count);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render string of 16-bit \a chars (both foreground and background) in
- *  \a pDrawable on the back-end server associated with \a pDrawable's
- *  screen.  If the offscreen optimization is enabled, only draw when \a
- *  pDrawable is at least partially visible. */
-void dmxImageText16(DrawablePtr pDrawable, GCPtr pGC,
-		    int x, int y, int count, unsigned short *chars)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawImageString16(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		       x, y, (XChar2b *)chars, count);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Image Glyph Blt -- this function should never be called. */
-void dmxImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
-		      int x, int y, unsigned int nglyph,
-		      CharInfoPtr *ppci, pointer pglyphBase)
-{
-    /* Error -- this should never happen! */
-}
-
-/** Poly Glyph Blt -- this function should never be called. */
-void dmxPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
-		     int x, int y, unsigned int nglyph,
-		     CharInfoPtr *ppci, pointer pglyphBase)
-{
-    /* Error -- this should never happen! */
-}
-
-/** Push Pixels -- this function should never be called. */
-void dmxPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDst,
-		   int w, int h, int x, int y)
-{
-    /* Error -- this should never happen! */
-}
-
-/**********************************************************************
- * Miscellaneous drawing commands
- */
-
-/** When Xinerama is active, the client pixmaps are always obtained from
- * screen 0.  When screen 0 is detached, the pixmaps must be obtained
- * from any other screen that is not detached.  Usually, this is screen
- * 1. */
-static DMXScreenInfo *dmxFindAlternatePixmap(DrawablePtr pDrawable, XID *draw)
-{
-#ifdef PANORAMIX
-    PanoramiXRes  *pXinPix;
-    int           i;
-    DMXScreenInfo *dmxScreen;
-            
-    if (noPanoramiXExtension)               return NULL;
-    if (pDrawable->type != DRAWABLE_PIXMAP) return NULL;
-    
-    if (!(pXinPix = (PanoramiXRes *)LookupIDByType(pDrawable->id, XRT_PIXMAP)))
-        return NULL;
-
-    for (i = 1; i < PanoramiXNumScreens; i++) {
-        dmxScreen = &dmxScreens[i];
-        if (dmxScreen->beDisplay) {
-            PixmapPtr     pSrc;
-            dmxPixPrivPtr pSrcPriv;
-            
-            pSrc = (PixmapPtr)LookupIDByType(pXinPix->info[i].id,
-                                             RT_PIXMAP);
-            pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
-            if (pSrcPriv->pixmap) {
-                *draw = pSrcPriv->pixmap;
-                return dmxScreen;
-            }
-        }
-    }
-#endif
-    return NULL;
-}
-
-/** Get an image from the back-end server associated with \a pDrawable's
- *  screen.  If \a pDrawable is a window, it must be viewable to get an
- *  image from it.  If it is not viewable, then get the image from the
- *  first ancestor of \a pDrawable that is viewable.  If no viewable
- *  ancestor is found, then simply return without getting an image.  */
-void dmxGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,
-		 unsigned int format, unsigned long planeMask, char *pdstLine)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    XImage        *img;
-    Drawable       draw;
-
-    /* Cannot get image from unviewable window */
-    if (pDrawable->type == DRAWABLE_WINDOW) {
-	WindowPtr pWindow = (WindowPtr)pDrawable;
-	if (!pWindow->viewable) {
-	    while (!pWindow->viewable && pWindow->parent) {
-		sx += pWindow->origin.x - wBorderWidth(pWindow);
-		sx += pWindow->origin.y - wBorderWidth(pWindow);
-		pWindow = pWindow->parent;
-	    }
-	    if (!pWindow->viewable) {
-		return;
-	    }
-	}
-	DMX_GCOPS_SET_DRAWABLE(&pWindow->drawable, draw);
-	if (DMX_GCOPS_OFFSCREEN(&pWindow->drawable))
-	    return;
-    } else {
-	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-	if (DMX_GCOPS_OFFSCREEN(pDrawable)) {
-            /* Try to find the pixmap on a non-detached Xinerama screen */
-            dmxScreen = dmxFindAlternatePixmap(pDrawable, &draw);
-            if (!dmxScreen) return;
-        }
-    }
-
-    img = XGetImage(dmxScreen->beDisplay, draw,
-		    sx, sy, w, h, planeMask, format);
-    if (img) {
-	int len = img->bytes_per_line * img->height;
-	memmove(pdstLine, img->data, len);
-	XDestroyImage(img);
-    }
-
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Get Spans -- this function should never be called. */
-void dmxGetSpans(DrawablePtr pDrawable, int wMax,
-		 DDXPointPtr ppt, int *pwidth, int nspans,
-		 char *pdstStart)
-{
-    /* Error -- this should never happen! */
-}
+/*

+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Kevin E. Martin <kem@redhat.com>

+ *

+ */

+

+/** \file

+ * This file provides support for GC operations. */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include "dmx.h"

+#include "dmxsync.h"

+#include "dmxgc.h"

+#include "dmxgcops.h"

+#include "dmxwindow.h"

+#include "dmxpixmap.h"

+

+#include "mi.h"

+#include "gcstruct.h"

+#include "pixmapstr.h"

+#include "dixfontstr.h"

+

+#ifdef PANORAMIX

+#include "panoramiXsrv.h"

+#endif

+

+#define DMX_GCOPS_SET_DRAWABLE(_pDraw, _draw)				\

+do {									\

+    if ((_pDraw)->type == DRAWABLE_WINDOW) {				\

+	dmxWinPrivPtr  pWinPriv =					\

+	    DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw));			\

+	(_draw) = (Drawable)pWinPriv->window;				\

+    } else {								\

+	dmxPixPrivPtr  pPixPriv =					\

+	    DMX_GET_PIXMAP_PRIV((PixmapPtr)(_pDraw));			\

+	(_draw) = (Drawable)pPixPriv->pixmap;				\

+    }									\

+} while (0)

+

+#define DMX_GCOPS_OFFSCREEN(_pDraw)					\

+    (!dmxScreens[(_pDraw)->pScreen->myNum].beDisplay ||			\

+     (dmxOffScreenOpt &&						\

+      (_pDraw)->type == DRAWABLE_WINDOW &&				\

+      (DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->offscreen ||		\

+       !DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->window)))

+

+/** Fill spans -- this function should never be called. */

+void dmxFillSpans(DrawablePtr pDrawable, GCPtr pGC,

+		  int nInit, DDXPointPtr pptInit, int *pwidthInit,

+		  int fSorted)

+{

+    /* Error -- this should never happen! */

+}

+

+/** Set spans -- this function should never be called. */

+void dmxSetSpans(DrawablePtr pDrawable, GCPtr pGC,

+		 char *psrc, DDXPointPtr ppt, int *pwidth, int nspans,

+		 int fSorted)

+{

+    /* Error -- this should never happen! */

+}

+

+/** Transfer \a pBits image to back-end server associated with \a

+ *  pDrawable's screen.  If primitive subdivision optimization is

+ *  enabled, then only transfer the sections of \a pBits that are

+ *  visible (i.e., not-clipped) to the back-end server. */

+void dmxPutImage(DrawablePtr pDrawable, GCPtr pGC,

+		 int depth, int x, int y, int w, int h,

+		 int leftPad, int format, char *pBits)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    XImage        *img;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    img = XCreateImage(dmxScreen->beDisplay,

+		       dmxScreen->beVisuals[dmxScreen->beDefVisualIndex].visual,

+		       depth, format, leftPad, pBits, w, h,

+		       BitmapPad(dmxScreen->beDisplay),

+		       (format == ZPixmap) ?

+		       PixmapBytePad(w, depth) : BitmapBytePad(w+leftPad));

+

+    if (img) {

+	Drawable draw;

+

+	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+	if (dmxSubdividePrimitives && pGC->pCompositeClip) {

+	    RegionPtr  pSubImages;

+	    RegionPtr  pClip;

+	    BoxRec     box;

+	    BoxPtr     pBox;

+	    int        nBox;

+

+	    box.x1 = x;

+	    box.y1 = y;

+	    box.x2 = x + w;

+	    box.y2 = y + h;

+	    pSubImages = RegionCreate(&box, 1);

+

+	    pClip = RegionCreate(NullBox, 1);

+	    RegionCopy(pClip, pGC->pCompositeClip);

+	    RegionTranslate(pClip,

+			     -pDrawable->x, -pDrawable->y);

+	    RegionIntersect(pSubImages, pSubImages, pClip);

+

+	    nBox = RegionNumRects(pSubImages);

+	    pBox = RegionRects(pSubImages);

+

+	    while (nBox--) {

+		XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc, img,

+			  pBox->x1 - box.x1,

+			  pBox->y1 - box.y1,

+			  pBox->x1,

+			  pBox->y1,

+			  pBox->x2 - pBox->x1,

+			  pBox->y2 - pBox->y1);

+		pBox++;

+	    }

+            RegionDestroy(pClip);

+            RegionDestroy(pSubImages);

+	} else {

+	    XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		      img, 0, 0, x, y, w, h);

+	}

+	XFree(img);             /* Use XFree instead of XDestroyImage

+                                 * because pBits is passed in from the

+                                 * caller. */

+

+	dmxSync(dmxScreen, FALSE);

+    } else {

+	/* Error -- this should not happen! */

+    }

+}

+

+/** Copy area from \a pSrc drawable to \a pDst drawable on the back-end

+ *  server associated with \a pSrc drawable's screen.  If the offscreen

+ *  optimization is enabled, only copy when both \a pSrc and \a pDst are

+ *  at least partially visible. */

+RegionPtr dmxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,

+		      int srcx, int srcy, int w, int h, int dstx, int dsty)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       srcDraw, dstDraw;

+

+    if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))

+	return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,

+				 dstx, dsty, 0L);

+

+    DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);

+    DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);

+

+    XCopyArea(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,

+	      srcx, srcy, w, h, dstx, dsty);

+    dmxSync(dmxScreen, FALSE);

+

+    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,

+			     dstx, dsty, 0L);

+}

+

+/** Copy plane number \a bitPlane from \a pSrc drawable to \a pDst

+ *  drawable on the back-end server associated with \a pSrc drawable's

+ *  screen.  If the offscreen optimization is enabled, only copy when

+ *  both \a pSrc and \a pDst are at least partially visible. */

+RegionPtr dmxCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,

+		       int srcx, int srcy, int width, int height,

+		       int dstx, int dsty, unsigned long bitPlane)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       srcDraw, dstDraw;

+

+    if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))

+	return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,

+				 dstx, dsty, bitPlane);

+

+    DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);

+    DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);

+

+    XCopyPlane(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,

+	       srcx, srcy, width, height, dstx, dsty, bitPlane);

+    dmxSync(dmxScreen, FALSE);

+

+    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,

+			     dstx, dsty, bitPlane);

+}

+

+/** Render list of points, \a pptInit in \a pDrawable on the back-end

+ *  server associated with \a pDrawable's screen.  If the offscreen

+ *  optimization is enabled, only draw when \a pDrawable is at least

+ *  partially visible. */

+void dmxPolyPoint(DrawablePtr pDrawable, GCPtr pGC,

+		  int mode, int npt, DDXPointPtr pptInit)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XDrawPoints(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		(XPoint *)pptInit, npt, mode);

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Render list of connected lines, \a pptInit in \a pDrawable on the

+ *  back-end server associated with \a pDrawable's screen.  If the

+ *  offscreen optimization is enabled, only draw when \a pDrawable is at

+ *  least partially visible. */

+void dmxPolylines(DrawablePtr pDrawable, GCPtr pGC,

+		  int mode, int npt, DDXPointPtr pptInit)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XDrawLines(dmxScreen->beDisplay, draw, pGCPriv->gc,

+	       (XPoint *)pptInit, npt, mode);

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Render list of disjoint segments, \a pSegs in \a pDrawable on the

+ *  back-end server associated with \a pDrawable's screen.  If the

+ *  offscreen optimization is enabled, only draw when \a pDrawable is at

+ *  least partially visible. */

+void dmxPolySegment(DrawablePtr pDrawable, GCPtr pGC,

+		    int nseg, xSegment *pSegs)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XDrawSegments(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		  (XSegment *)pSegs, nseg);

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Render list of rectangle outlines, \a pRects in \a pDrawable on the

+ *  back-end server associated with \a pDrawable's screen.  If the

+ *  offscreen optimization is enabled, only draw when \a pDrawable is at

+ *  least partially visible. */

+void dmxPolyRectangle(DrawablePtr pDrawable, GCPtr pGC,

+		      int nrects, xRectangle *pRects)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XDrawRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		    (XRectangle *)pRects, nrects);

+

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Render list of arc outlines, \a parcs in \a pDrawable on the

+ *  back-end server associated with \a pDrawable's screen.  If the

+ *  offscreen optimization is enabled, only draw when \a pDrawable is at

+ *  least partially visible. */

+void dmxPolyArc(DrawablePtr pDrawable, GCPtr pGC,

+		int narcs, xArc *parcs)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XDrawArcs(dmxScreen->beDisplay, draw, pGCPriv->gc,

+	      (XArc *)parcs, narcs);

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Render a filled polygons in \a pDrawable on the back-end server

+ *  associated with \a pDrawable's screen.  If the offscreen

+ *  optimization is enabled, only draw when \a pDrawable is at least

+ *  partially visible. */

+void dmxFillPolygon(DrawablePtr pDrawable, GCPtr pGC,

+		    int shape, int mode, int count, DDXPointPtr pPts)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XFillPolygon(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		 (XPoint *)pPts, count, shape, mode);

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Render list of filled rectangles, \a prectInit in \a pDrawable on

+ *  the back-end server associated with \a pDrawable's screen.  If the

+ *  offscreen optimization is enabled, only draw when \a pDrawable is at

+ *  least partially visible. */

+void dmxPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,

+		     int nrectFill, xRectangle *prectInit)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XFillRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		    (XRectangle *)prectInit, nrectFill);

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Render list of filled arcs, \a parcs in \a pDrawable on the back-end

+ *  server associated with \a pDrawable's screen.  If the offscreen

+ *  optimization is enabled, only draw when \a pDrawable is at least

+ *  partially visible. */

+void dmxPolyFillArc(DrawablePtr pDrawable, GCPtr pGC,

+		    int narcs, xArc *parcs)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XFillArcs(dmxScreen->beDisplay, draw, pGCPriv->gc,

+	      (XArc *)parcs, narcs);

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Render string of 8-bit \a chars (foreground only) in \a pDrawable on

+ *  the back-end server associated with \a pDrawable's screen.  If the

+ *  offscreen optimization is enabled, only draw when \a pDrawable is at

+ *  least partially visible. */

+int dmxPolyText8(DrawablePtr pDrawable, GCPtr pGC,

+		 int x, int y, int count, char *chars)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    unsigned long  n, i;

+    int            w;

+    CharInfoPtr    charinfo[255];

+    Drawable       draw;

+

+    GetGlyphs(pGC->font, (unsigned long)count, (unsigned char *)chars,

+	      Linear8Bit, &n, charinfo);

+

+    /* Calculate text width */

+    w = 0;

+    for (i = 0; i < n; i++) w += charinfo[i]->metrics.characterWidth;

+

+    if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {

+	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+	XDrawString(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		    x, y, chars, count);

+	dmxSync(dmxScreen, FALSE);

+    }

+

+    return x+w;

+}

+

+/** Render string of 16-bit \a chars (foreground only) in \a pDrawable

+ *  on the back-end server associated with \a pDrawable's screen.  If

+ *  the offscreen optimization is enabled, only draw when \a pDrawable

+ *  is at least partially visible. */

+int dmxPolyText16(DrawablePtr pDrawable, GCPtr pGC,

+		  int x, int y, int count, unsigned short *chars)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    unsigned long  n, i;

+    int            w;

+    CharInfoPtr    charinfo[255];

+    Drawable       draw;

+

+    GetGlyphs(pGC->font, (unsigned long)count, (unsigned char *)chars,

+	      (FONTLASTROW(pGC->font) == 0) ? Linear16Bit : TwoD16Bit,

+	      &n, charinfo);

+

+    /* Calculate text width */

+    w = 0;

+    for (i = 0; i < n; i++) w += charinfo[i]->metrics.characterWidth;

+

+    if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {

+	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+	XDrawString16(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		      x, y, (XChar2b *)chars, count);

+	dmxSync(dmxScreen, FALSE);

+    }

+

+    return x+w;

+}

+

+/** Render string of 8-bit \a chars (both foreground and background) in

+ *  \a pDrawable on the back-end server associated with \a pDrawable's

+ *  screen.  If the offscreen optimization is enabled, only draw when \a

+ *  pDrawable is at least partially visible. */

+void dmxImageText8(DrawablePtr pDrawable, GCPtr pGC,

+		   int x, int y, int count, char *chars)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XDrawImageString(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		     x, y, chars, count);

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Render string of 16-bit \a chars (both foreground and background) in

+ *  \a pDrawable on the back-end server associated with \a pDrawable's

+ *  screen.  If the offscreen optimization is enabled, only draw when \a

+ *  pDrawable is at least partially visible. */

+void dmxImageText16(DrawablePtr pDrawable, GCPtr pGC,

+		    int x, int y, int count, unsigned short *chars)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);

+    Drawable       draw;

+

+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;

+

+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+

+    XDrawImageString16(dmxScreen->beDisplay, draw, pGCPriv->gc,

+		       x, y, (XChar2b *)chars, count);

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Image Glyph Blt -- this function should never be called. */

+void dmxImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,

+		      int x, int y, unsigned int nglyph,

+		      CharInfoPtr *ppci, pointer pglyphBase)

+{

+    /* Error -- this should never happen! */

+}

+

+/** Poly Glyph Blt -- this function should never be called. */

+void dmxPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,

+		     int x, int y, unsigned int nglyph,

+		     CharInfoPtr *ppci, pointer pglyphBase)

+{

+    /* Error -- this should never happen! */

+}

+

+/** Push Pixels -- this function should never be called. */

+void dmxPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDst,

+		   int w, int h, int x, int y)

+{

+    /* Error -- this should never happen! */

+}

+

+/**********************************************************************

+ * Miscellaneous drawing commands

+ */

+

+/** When Xinerama is active, the client pixmaps are always obtained from

+ * screen 0.  When screen 0 is detached, the pixmaps must be obtained

+ * from any other screen that is not detached.  Usually, this is screen

+ * 1. */

+static DMXScreenInfo *dmxFindAlternatePixmap(DrawablePtr pDrawable, XID *draw)

+{

+#ifdef PANORAMIX

+    PanoramiXRes  *pXinPix;

+    int           i;

+    DMXScreenInfo *dmxScreen;

+            

+    if (noPanoramiXExtension)               return NULL;

+    if (pDrawable->type != DRAWABLE_PIXMAP) return NULL;

+    

+    if (!(pXinPix = (PanoramiXRes *)LookupIDByType(pDrawable->id, XRT_PIXMAP)))

+        return NULL;

+

+    for (i = 1; i < PanoramiXNumScreens; i++) {

+        dmxScreen = &dmxScreens[i];

+        if (dmxScreen->beDisplay) {

+            PixmapPtr     pSrc;

+            dmxPixPrivPtr pSrcPriv;

+            

+            pSrc = (PixmapPtr)LookupIDByType(pXinPix->info[i].id,

+                                             RT_PIXMAP);

+            pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);

+            if (pSrcPriv->pixmap) {

+                *draw = pSrcPriv->pixmap;

+                return dmxScreen;

+            }

+        }

+    }

+#endif

+    return NULL;

+}

+

+/** Get an image from the back-end server associated with \a pDrawable's

+ *  screen.  If \a pDrawable is a window, it must be viewable to get an

+ *  image from it.  If it is not viewable, then get the image from the

+ *  first ancestor of \a pDrawable that is viewable.  If no viewable

+ *  ancestor is found, then simply return without getting an image.  */

+void dmxGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,

+		 unsigned int format, unsigned long planeMask, char *pdstLine)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];

+    XImage        *img;

+    Drawable       draw;

+

+    /* Cannot get image from unviewable window */

+    if (pDrawable->type == DRAWABLE_WINDOW) {

+	WindowPtr pWindow = (WindowPtr)pDrawable;

+	if (!pWindow->viewable) {

+	    while (!pWindow->viewable && pWindow->parent) {

+		sx += pWindow->origin.x - wBorderWidth(pWindow);

+		sx += pWindow->origin.y - wBorderWidth(pWindow);

+		pWindow = pWindow->parent;

+	    }

+	    if (!pWindow->viewable) {

+		return;

+	    }

+	}

+	DMX_GCOPS_SET_DRAWABLE(&pWindow->drawable, draw);

+	if (DMX_GCOPS_OFFSCREEN(&pWindow->drawable))

+	    return;

+    } else {

+	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);

+	if (DMX_GCOPS_OFFSCREEN(pDrawable)) {

+            /* Try to find the pixmap on a non-detached Xinerama screen */

+            dmxScreen = dmxFindAlternatePixmap(pDrawable, &draw);

+            if (!dmxScreen) return;

+        }

+    }

+

+    img = XGetImage(dmxScreen->beDisplay, draw,

+		    sx, sy, w, h, planeMask, format);

+    if (img) {

+	int len = img->bytes_per_line * img->height;

+	memmove(pdstLine, img->data, len);

+	XDestroyImage(img);

+    }

+

+    dmxSync(dmxScreen, FALSE);

+}

+

+/** Get Spans -- this function should never be called. */

+void dmxGetSpans(DrawablePtr pDrawable, int wMax,

+		 DDXPointPtr ppt, int *pwidth, int nspans,

+		 char *pdstStart)

+{

+    /* Error -- this should never happen! */

+}

diff --git a/xorg-server/hw/dmx/dmxinit.c b/xorg-server/hw/dmx/dmxinit.c
index 37b302a25..37fe0af21 100644
--- a/xorg-server/hw/dmx/dmxinit.c
+++ b/xorg-server/hw/dmx/dmxinit.c
@@ -404,7 +404,7 @@ Bool dmxGetVisualInfo(DMXScreenInfo *dmxScreen)
         dmxLogVisual(dmxScreen, &dmxScreen->beVisuals[i],

                      (i == dmxScreen->beDefVisualIndex));

 

-    return (dmxScreen->beDefVisualIndex >= 0);

+    return dmxScreen->beDefVisualIndex >= 0;

 }

 

 void dmxGetColormaps(DMXScreenInfo *dmxScreen)

@@ -606,8 +606,8 @@ void InitOutput(ScreenInfo *pScreenInfo, int argc, char *argv[])
             dmxScreens[i].stat = NULL;

         }

         for (i = 0; i < dmxNumInputs; i++) dmxInputFree(&dmxInputs[i]);

-        if (dmxScreens) free(dmxScreens);

-        if (dmxInputs)  free(dmxInputs);

+        free(dmxScreens);

+        free(dmxInputs);

         dmxScreens    = NULL;

         dmxInputs     = NULL;

         dmxNumScreens = 0;

diff --git a/xorg-server/hw/dmx/dmxpict.c b/xorg-server/hw/dmx/dmxpict.c
index c7bcd5b91..18ac85c03 100644
--- a/xorg-server/hw/dmx/dmxpict.c
+++ b/xorg-server/hw/dmx/dmxpict.c
@@ -145,7 +145,7 @@ Bool dmxPictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats)
     if (!miPictureInit(pScreen, formats, nformats))

 	return FALSE;

 

-    if (!dixRequestPrivate(dmxPictPrivateKey, sizeof(dmxPictPrivRec)))

+    if (!dixRegisterPrivateKey(&dmxPictPrivateKeyRec, PRIVATE_PICTURE, sizeof(dmxPictPrivRec)))

 	return FALSE;

 

     ps = GetPictureScreen(pScreen);

@@ -871,8 +871,8 @@ int dmxChangePictureClip(PicturePtr pPicture, int clipType,
 				       pPictPriv->pict, 0, 0, None);

 	} else if (pPicture->clientClip) {

 	    RegionPtr   pClip = pPicture->clientClip;

-	    BoxPtr      pBox  = REGION_RECTS(pClip);

-	    int         nBox  = REGION_NUM_RECTS(pClip);

+	    BoxPtr      pBox  = RegionRects(pClip);

+	    int         nBox  = RegionNumRects(pClip);

 	    XRectangle *pRects;

 	    XRectangle *pRect;

 	    int         nRects;

diff --git a/xorg-server/hw/dmx/dmxpict.h b/xorg-server/hw/dmx/dmxpict.h
index a81eb7d37..d196f639a 100644
--- a/xorg-server/hw/dmx/dmxpict.h
+++ b/xorg-server/hw/dmx/dmxpict.h
@@ -1,134 +1,130 @@
-/*
- * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *
- */
-
-/** \file
- *  This file provides access to the externally visible RENDER support
- *  functions, global variables and macros for DMX.
- *  
- *  FIXME: Move function definitions for non-externally visible function
- *  to .c file. */
-
-#ifndef DMXPICT_H
-#define DMXPICT_H
-
-/** Picture private structure */
-typedef struct _dmxPictPriv {
-    Picture  pict;		/**< Picture ID from back-end server */
-    Mask     savedMask;         /**< Mask of picture attributes saved for
-				 *   lazy window creation. */
-} dmxPictPrivRec, *dmxPictPrivPtr;
-
-
-/** Glyph Set private structure */
-typedef struct _dmxGlyphPriv {
-    GlyphSet  *glyphSets; /**< Glyph Set IDs from back-end server */
-} dmxGlyphPrivRec, *dmxGlyphPrivPtr;
-
-
-extern void dmxInitRender(void);
-extern void dmxResetRender(void);
-
-extern Bool dmxPictureInit(ScreenPtr pScreen,
-			   PictFormatPtr formats, int nformats);
-
-extern void dmxCreatePictureList(WindowPtr pWindow);
-extern Bool dmxDestroyPictureList(WindowPtr pWindow);
-
-extern int dmxCreatePicture(PicturePtr pPicture);
-extern void dmxDestroyPicture(PicturePtr pPicture);
-extern int dmxChangePictureClip(PicturePtr pPicture, int clipType,
-				pointer value, int n);
-extern void dmxDestroyPictureClip(PicturePtr pPicture);
-extern void dmxChangePicture(PicturePtr pPicture, Mask mask);
-extern void dmxValidatePicture(PicturePtr pPicture, Mask mask);
-extern void dmxComposite(CARD8 op,
-			 PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
-			 INT16 xSrc, INT16 ySrc,
-			 INT16 xMask, INT16 yMask,
-			 INT16 xDst, INT16 yDst,
-			 CARD16 width, CARD16 height);
-extern void dmxGlyphs(CARD8 op,
-		      PicturePtr pSrc, PicturePtr pDst,
-		      PictFormatPtr maskFormat,
-		      INT16 xSrc, INT16 ySrc,
-		      int nlists, GlyphListPtr lists, GlyphPtr *glyphs);
-extern void dmxCompositeRects(CARD8 op,
-			      PicturePtr pDst,
-			      xRenderColor *color,
-			      int nRect, xRectangle *rects);
-extern Bool dmxInitIndexed(ScreenPtr pScreen, PictFormatPtr pFormat);
-extern void dmxCloseIndexed(ScreenPtr pScreen, PictFormatPtr pFormat);
-extern void dmxUpdateIndexed(ScreenPtr pScreen, PictFormatPtr pFormat,
-			     int ndef, xColorItem *pdef);
-extern void dmxTrapezoids(CARD8 op,
-			  PicturePtr pSrc, PicturePtr pDst,
-			  PictFormatPtr maskFormat,
-			  INT16 xSrc, INT16 ySrc,
-			  int ntrap, xTrapezoid *traps);
-extern void dmxTriangles(CARD8 op,
-			 PicturePtr pSrc, PicturePtr pDst,
-			 PictFormatPtr maskFormat,
-			 INT16 xSrc, INT16 ySrc,
-			 int ntri, xTriangle *tris);
-extern void dmxTriStrip(CARD8 op,
-			PicturePtr pSrc, PicturePtr pDst,
-			PictFormatPtr maskFormat,
-			INT16 xSrc, INT16 ySrc,
-			int npoint, xPointFixed *points);
-extern void dmxTriFan(CARD8 op,
-		      PicturePtr pSrc, PicturePtr pDst,
-		      PictFormatPtr maskFormat,
-		      INT16 xSrc, INT16 ySrc,
-		      int npoint, xPointFixed *points);
-
-extern int dmxBECreateGlyphSet(int idx, GlyphSetPtr glyphSet);
-extern Bool dmxBEFreeGlyphSet(ScreenPtr pScreen, GlyphSetPtr glyphSet);
-extern int dmxBECreatePicture(PicturePtr pPicture);
-extern Bool dmxBEFreePicture(PicturePtr pPicture);
-
-extern DevPrivateKey dmxPictPrivateKey;	/**< Index for picture private data */
-extern DevPrivateKey dmxGlyphSetPrivateKey; /**< Index for glyphset private data */
-
-
-/** Get the picture private data given a picture pointer */
-#define DMX_GET_PICT_PRIV(_pPict)					\
-    (dmxPictPrivPtr)dixLookupPrivate(&(_pPict)->devPrivates, dmxPictPrivateKey)
-
-/** Set the glyphset private data given a glyphset pointer */
-#define DMX_SET_GLYPH_PRIV(_pGlyph, _pPriv)				\
-    GlyphSetSetPrivate((_pGlyph), dmxGlyphSetPrivateKey, (_pPriv))
-/** Get the glyphset private data given a glyphset pointer */
-#define DMX_GET_GLYPH_PRIV(_pGlyph)					\
-    (dmxGlyphPrivPtr)GlyphSetGetPrivate((_pGlyph), dmxGlyphSetPrivateKey)
-
-#endif /* DMXPICT_H */
+/*

+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Kevin E. Martin <kem@redhat.com>

+ *

+ */

+

+/** \file

+ *  This file provides access to the externally visible RENDER support

+ *  functions, global variables and macros for DMX.

+ *  

+ *  FIXME: Move function definitions for non-externally visible function

+ *  to .c file. */

+

+#ifndef DMXPICT_H

+#define DMXPICT_H

+

+/** Picture private structure */

+typedef struct _dmxPictPriv {

+    Picture  pict;		/**< Picture ID from back-end server */

+    Mask     savedMask;         /**< Mask of picture attributes saved for

+				 *   lazy window creation. */

+} dmxPictPrivRec, *dmxPictPrivPtr;

+

+

+/** Glyph Set private structure */

+typedef struct _dmxGlyphPriv {

+    GlyphSet  *glyphSets; /**< Glyph Set IDs from back-end server */

+} dmxGlyphPrivRec, *dmxGlyphPrivPtr;

+

+

+extern void dmxInitRender(void);

+extern void dmxResetRender(void);

+

+extern Bool dmxPictureInit(ScreenPtr pScreen,

+			   PictFormatPtr formats, int nformats);

+

+extern void dmxCreatePictureList(WindowPtr pWindow);

+extern Bool dmxDestroyPictureList(WindowPtr pWindow);

+

+extern int dmxCreatePicture(PicturePtr pPicture);

+extern void dmxDestroyPicture(PicturePtr pPicture);

+extern int dmxChangePictureClip(PicturePtr pPicture, int clipType,

+				pointer value, int n);

+extern void dmxDestroyPictureClip(PicturePtr pPicture);

+extern void dmxChangePicture(PicturePtr pPicture, Mask mask);

+extern void dmxValidatePicture(PicturePtr pPicture, Mask mask);

+extern void dmxComposite(CARD8 op,

+			 PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,

+			 INT16 xSrc, INT16 ySrc,

+			 INT16 xMask, INT16 yMask,

+			 INT16 xDst, INT16 yDst,

+			 CARD16 width, CARD16 height);

+extern void dmxGlyphs(CARD8 op,

+		      PicturePtr pSrc, PicturePtr pDst,

+		      PictFormatPtr maskFormat,

+		      INT16 xSrc, INT16 ySrc,

+		      int nlists, GlyphListPtr lists, GlyphPtr *glyphs);

+extern void dmxCompositeRects(CARD8 op,

+			      PicturePtr pDst,

+			      xRenderColor *color,

+			      int nRect, xRectangle *rects);

+extern Bool dmxInitIndexed(ScreenPtr pScreen, PictFormatPtr pFormat);

+extern void dmxCloseIndexed(ScreenPtr pScreen, PictFormatPtr pFormat);

+extern void dmxUpdateIndexed(ScreenPtr pScreen, PictFormatPtr pFormat,

+			     int ndef, xColorItem *pdef);

+extern void dmxTrapezoids(CARD8 op,

+			  PicturePtr pSrc, PicturePtr pDst,

+			  PictFormatPtr maskFormat,

+			  INT16 xSrc, INT16 ySrc,

+			  int ntrap, xTrapezoid *traps);

+extern void dmxTriangles(CARD8 op,

+			 PicturePtr pSrc, PicturePtr pDst,

+			 PictFormatPtr maskFormat,

+			 INT16 xSrc, INT16 ySrc,

+			 int ntri, xTriangle *tris);

+extern void dmxTriStrip(CARD8 op,

+			PicturePtr pSrc, PicturePtr pDst,

+			PictFormatPtr maskFormat,

+			INT16 xSrc, INT16 ySrc,

+			int npoint, xPointFixed *points);

+extern void dmxTriFan(CARD8 op,

+		      PicturePtr pSrc, PicturePtr pDst,

+		      PictFormatPtr maskFormat,

+		      INT16 xSrc, INT16 ySrc,

+		      int npoint, xPointFixed *points);

+

+extern int dmxBECreateGlyphSet(int idx, GlyphSetPtr glyphSet);

+extern Bool dmxBEFreeGlyphSet(ScreenPtr pScreen, GlyphSetPtr glyphSet);

+extern int dmxBECreatePicture(PicturePtr pPicture);

+extern Bool dmxBEFreePicture(PicturePtr pPicture);

+

+/** Get the picture private data given a picture pointer */

+#define DMX_GET_PICT_PRIV(_pPict)					\

+    (dmxPictPrivPtr)dixLookupPrivate(&(_pPict)->devPrivates, dmxPictPrivateKey)

+

+/** Set the glyphset private data given a glyphset pointer */

+#define DMX_SET_GLYPH_PRIV(_pGlyph, _pPriv)				\

+    GlyphSetSetPrivate((_pGlyph), dmxGlyphSetPrivateKey, (_pPriv))

+/** Get the glyphset private data given a glyphset pointer */

+#define DMX_GET_GLYPH_PRIV(_pGlyph)					\

+    (dmxGlyphPrivPtr)GlyphSetGetPrivate((_pGlyph), dmxGlyphSetPrivateKey)

+

+#endif /* DMXPICT_H */

diff --git a/xorg-server/hw/dmx/dmxpixmap.c b/xorg-server/hw/dmx/dmxpixmap.c
index bcbcc3a88..119dd1134 100644
--- a/xorg-server/hw/dmx/dmxpixmap.c
+++ b/xorg-server/hw/dmx/dmxpixmap.c
@@ -49,7 +49,7 @@
 /** Initialize a private area in \a pScreen for pixmap information. */

 Bool dmxInitPixmap(ScreenPtr pScreen)

 {

-    if (!dixRequestPrivate(dmxPixPrivateKey, sizeof(dmxPixPrivRec)))

+    if (!dixRegisterPrivateKey(&dmxPixPrivateKeyRec, PRIVATE_PIXMAP, sizeof(dmxPixPrivRec)))

 	return FALSE;

 

     return TRUE;

@@ -174,8 +174,7 @@ Bool dmxDestroyPixmap(PixmapPtr pPixmap)
 	    dmxSync(dmxScreen, FALSE);

 	}

     }

-    dixFreePrivates(pPixmap->devPrivates);

-    free(pPixmap);

+    FreePixmap(pPixmap);

 

 #if 0

     if (pScreen->DestroyPixmap)

@@ -190,8 +189,7 @@ Bool dmxDestroyPixmap(PixmapPtr pPixmap)
  *  pPixmap. */

 RegionPtr dmxBitmapToRegion(PixmapPtr pPixmap)

 {

-    ScreenPtr      pScreen = pPixmap->drawable.pScreen;

-    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];

+    DMXScreenInfo *dmxScreen = &dmxScreens[pPixmap->drawable.pScreen->myNum];

     dmxPixPrivPtr  pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap);

     XImage        *ximage;

     RegionPtr      pReg, pTmpReg;

@@ -201,7 +199,7 @@ RegionPtr dmxBitmapToRegion(PixmapPtr pPixmap)
     Bool           overlap;

   

     if (!dmxScreen->beDisplay) {

-	pReg = REGION_CREATE(pScreen, NullBox, 1);

+	pReg = RegionCreate(NullBox, 1);

 	return pReg;

     }

 

@@ -209,8 +207,8 @@ RegionPtr dmxBitmapToRegion(PixmapPtr pPixmap)
 		       pPixmap->drawable.width, pPixmap->drawable.height,

 		       1, XYPixmap);

 

-    pReg = REGION_CREATE(pScreen, NullBox, 1);

-    pTmpReg = REGION_CREATE(pScreen, NullBox, 1);

+    pReg = RegionCreate(NullBox, 1);

+    pTmpReg = RegionCreate(NullBox, 1);

     if(!pReg || !pTmpReg) {

 	XDestroyImage(ximage);

 	return NullRegion;

@@ -229,8 +227,8 @@ RegionPtr dmxBitmapToRegion(PixmapPtr pPixmap)
 		} else if (currentPixel == 0L) {

 		    /* right edge */

 		    Box.x2 = x;

-		    REGION_RESET(pScreen, pTmpReg, &Box);

-		    REGION_APPEND(pScreen, pReg, pTmpReg);

+		    RegionReset(pTmpReg, &Box);

+		    RegionAppend(pReg, pTmpReg);

 		}

 		previousPixel = currentPixel;

 	    }

@@ -238,16 +236,16 @@ RegionPtr dmxBitmapToRegion(PixmapPtr pPixmap)
 	if (previousPixel != 0L) {

 	    /* right edge because of the end of pixmap */

 	    Box.x2 = pPixmap->drawable.width;

-	    REGION_RESET(pScreen, pTmpReg, &Box);

-	    REGION_APPEND(pScreen, pReg, pTmpReg);

+	    RegionReset(pTmpReg, &Box);

+	    RegionAppend(pReg, pTmpReg);

 	}

     }

   

-    REGION_DESTROY(pScreen, pTmpReg);

+    RegionDestroy(pTmpReg);

     XDestroyImage(ximage);

 

-    REGION_VALIDATE(pScreen, pReg, &overlap);

+    RegionValidate(pReg, &overlap);

 

     dmxSync(dmxScreen, FALSE);

-    return(pReg);

+    return pReg;

 }

diff --git a/xorg-server/hw/dmx/dmxpixmap.h b/xorg-server/hw/dmx/dmxpixmap.h
index 64418340c..a41918ce4 100644
--- a/xorg-server/hw/dmx/dmxpixmap.h
+++ b/xorg-server/hw/dmx/dmxpixmap.h
@@ -1,67 +1,64 @@
-/*
- * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *
- */
-
-/** \file
- * Interface for pixmap support.  \see dmxpixmap.c */
-
-#ifndef DMXPIXMAP_H
-#define DMXPIXMAP_H
-
-#include "pixmapstr.h"
-
-/** Pixmap private area. */
-typedef struct _dmxPixPriv {
-    Pixmap   pixmap;
-    XImage  *detachedImage;
-} dmxPixPrivRec, *dmxPixPrivPtr;
-
-
-extern Bool      dmxInitPixmap(ScreenPtr pScreen);
-
-extern PixmapPtr dmxCreatePixmap(ScreenPtr pScreen,
-				 int width, int height, int depth,
-				 unsigned usage_hint);
-extern Bool      dmxDestroyPixmap(PixmapPtr pPixmap);
-extern RegionPtr dmxBitmapToRegion(PixmapPtr pPixmap);
-
-extern void      dmxBECreatePixmap(PixmapPtr pPixmap);
-extern Bool      dmxBEFreePixmap(PixmapPtr pPixmap);
-
-/** Private index.  \see dmxpicmap.h \see dmxscrinit.c */
-extern DevPrivateKey dmxPixPrivateKey;
-
-/** Get pixmap private pointer. */
-#define DMX_GET_PIXMAP_PRIV(_pPix)					\
-    (dmxPixPrivPtr)dixLookupPrivate(&(_pPix)->devPrivates, dmxPixPrivateKey)
-
-#endif /* DMXPIXMAP_H */
+/*

+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Kevin E. Martin <kem@redhat.com>

+ *

+ */

+

+/** \file

+ * Interface for pixmap support.  \see dmxpixmap.c */

+

+#ifndef DMXPIXMAP_H

+#define DMXPIXMAP_H

+

+#include "pixmapstr.h"

+

+/** Pixmap private area. */

+typedef struct _dmxPixPriv {

+    Pixmap   pixmap;

+    XImage  *detachedImage;

+} dmxPixPrivRec, *dmxPixPrivPtr;

+

+

+extern Bool      dmxInitPixmap(ScreenPtr pScreen);

+

+extern PixmapPtr dmxCreatePixmap(ScreenPtr pScreen,

+				 int width, int height, int depth,

+				 unsigned usage_hint);

+extern Bool      dmxDestroyPixmap(PixmapPtr pPixmap);

+extern RegionPtr dmxBitmapToRegion(PixmapPtr pPixmap);

+

+extern void      dmxBECreatePixmap(PixmapPtr pPixmap);

+extern Bool      dmxBEFreePixmap(PixmapPtr pPixmap);

+

+/** Get pixmap private pointer. */

+#define DMX_GET_PIXMAP_PRIV(_pPix)					\

+    (dmxPixPrivPtr)dixLookupPrivate(&(_pPix)->devPrivates, dmxPixPrivateKey)

+

+#endif /* DMXPIXMAP_H */

diff --git a/xorg-server/hw/dmx/dmxscrinit.c b/xorg-server/hw/dmx/dmxscrinit.c
index edb14a23a..7504610bd 100644
--- a/xorg-server/hw/dmx/dmxscrinit.c
+++ b/xorg-server/hw/dmx/dmxscrinit.c
@@ -65,21 +65,14 @@ static Bool dmxSaveScreen(ScreenPtr pScreen, int what);
 static unsigned long dmxGeneration;

 static unsigned long *dmxCursorGeneration;

 

-static int dmxGCPrivateKeyIndex;

-DevPrivateKey dmxGCPrivateKey = &dmxGCPrivateKeyIndex; /**< Private index for GCs       */

-static int dmxWinPrivateKeyIndex;

-DevPrivateKey dmxWinPrivateKey = &dmxWinPrivateKeyIndex; /**< Private index for Windows   */

-static int dmxPixPrivateKeyIndex;

-DevPrivateKey dmxPixPrivateKey = &dmxPixPrivateKeyIndex; /**< Private index for Pixmaps   */

+DevPrivateKeyRec dmxGCPrivateKeyRec;

+DevPrivateKeyRec dmxWinPrivateKeyRec;

+DevPrivateKeyRec dmxPixPrivateKeyRec;

 int dmxFontPrivateIndex;        /**< Private index for Fonts     */

-static int dmxScreenPrivateKeyIndex;

-DevPrivateKey dmxScreenPrivateKey = &dmxScreenPrivateKeyIndex; /**< Private index for Screens   */

-static int dmxColormapPrivateKeyIndex;

-DevPrivateKey dmxColormapPrivateKey = &dmxColormapPrivateKeyIndex; /**< Private index for Colormaps */

-static int dmxPictPrivateKeyIndex;

-DevPrivateKey dmxPictPrivateKey = &dmxPictPrivateKeyIndex; /**< Private index for Picts     */

-static int dmxGlyphSetPrivateKeyIndex;

-DevPrivateKey dmxGlyphSetPrivateKey = &dmxGlyphSetPrivateKeyIndex; /**< Private index for GlyphSets */

+DevPrivateKeyRec dmxScreenPrivateKeyRec;

+DevPrivateKeyRec dmxColormapPrivateKeyRec;

+DevPrivateKeyRec dmxPictPrivateKeyRec;

+DevPrivateKeyRec dmxGlyphSetPrivateKeyRec;

 

 /** Initialize the parts of screen \a idx that require access to the

  *  back-end server. */

@@ -210,6 +203,13 @@ Bool dmxScreenInit(int idx, ScreenPtr pScreen, int argc, char *argv[])
     DMXScreenInfo        *dmxScreen = &dmxScreens[idx];

     int                   i, j;

 

+    if (!dixRegisterPrivateKey(&dmxScreenPrivateKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+    if (!dixRegisterPrivateKey(&dmxColormapPrivateKeyRec, PRIVATE_COLORMAP, 0))

+	return FALSE;

+    if (!dixRegisterPrivateKey(&dmxGlyphSetPrivateKeyRec, PRIVATE_GLYPHSET, 0))

+	return FALSE;

+

     if (dmxGeneration != serverGeneration) {

 	/* Allocate font private index */

 	dmxFontPrivateIndex = AllocateFontPrivateIndex();

diff --git a/xorg-server/hw/dmx/dmxscrinit.h b/xorg-server/hw/dmx/dmxscrinit.h
index a4642350c..328e33272 100644
--- a/xorg-server/hw/dmx/dmxscrinit.h
+++ b/xorg-server/hw/dmx/dmxscrinit.h
@@ -1,51 +1,48 @@
-/*
- * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *   David H. Dawes <dawes@xfree86.org>
- *
- */
-
-/** \file
- * Interface for screen initialization.  \see dmxscrinit.c */
-
-#ifndef DMXSCRINIT_H
-#define DMXSCRINIT_H
-
-#include "scrnintstr.h"
-
-/** Private index.  \see dmxscrrinit.c \see input/dmxconcole.c */
-extern DevPrivateKey dmxScreenPrivateKey;
-
-extern Bool dmxScreenInit(int idx, ScreenPtr pScreen, int argc, char *argv[]);
-
-extern void dmxBEScreenInit(int idx, ScreenPtr pScreen);
-extern void dmxBECloseScreen(ScreenPtr pScreen);
-
-#endif /* DMXSCRINIT_H */
+/*

+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Kevin E. Martin <kem@redhat.com>

+ *   David H. Dawes <dawes@xfree86.org>

+ *

+ */

+

+/** \file

+ * Interface for screen initialization.  \see dmxscrinit.c */

+

+#ifndef DMXSCRINIT_H

+#define DMXSCRINIT_H

+

+#include "scrnintstr.h"

+

+extern Bool dmxScreenInit(int idx, ScreenPtr pScreen, int argc, char *argv[]);

+

+extern void dmxBEScreenInit(int idx, ScreenPtr pScreen);

+extern void dmxBECloseScreen(ScreenPtr pScreen);

+

+#endif /* DMXSCRINIT_H */

diff --git a/xorg-server/hw/dmx/dmxshadow.c b/xorg-server/hw/dmx/dmxshadow.c
index 461fd085b..e075dec2a 100644
--- a/xorg-server/hw/dmx/dmxshadow.c
+++ b/xorg-server/hw/dmx/dmxshadow.c
@@ -1,71 +1,71 @@
-/*
- * Copyright 2001 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *   David H. Dawes <dawes@xfree86.org>
- *
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "dmx.h"
-#include "dmxsync.h"
-#include "dmxshadow.h"
-
-/** \file
- * This file provides support for the shadow frame buffer. */
-
-/** Update the screen from the shadow frame buffer. */
-void dmxShadowUpdateProc(ScreenPtr pScreen, shadowBufPtr pBuf)
-{
-    RegionPtr      damage = &pBuf->damage;
-    int            nbox = REGION_NUM_RECTS(damage);
-    BoxPtr         pbox = REGION_RECTS(damage);
-    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
-
-    if (!dmxScreen->beDisplay)
-	return;
-
-    while (nbox--) {
-	XPutImage(dmxScreen->beDisplay,
-		  dmxScreen->scrnWin,
-		  dmxScreen->shadowGC,
-		  dmxScreen->shadowFBImage,
-		  pbox->x1, pbox->y1,
-		  pbox->x1, pbox->y1,
-		  pbox->x2 - pbox->x1,
-		  pbox->y2 - pbox->y1);
-
-	pbox++;
-    }
-
-    dmxSync(dmxScreen, FALSE);
-}
+/*

+ * Copyright 2001 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Kevin E. Martin <kem@redhat.com>

+ *   David H. Dawes <dawes@xfree86.org>

+ *

+ */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include "dmx.h"

+#include "dmxsync.h"

+#include "dmxshadow.h"

+

+/** \file

+ * This file provides support for the shadow frame buffer. */

+

+/** Update the screen from the shadow frame buffer. */

+void dmxShadowUpdateProc(ScreenPtr pScreen, shadowBufPtr pBuf)

+{

+    RegionPtr      damage = &pBuf->damage;

+    int            nbox = RegionNumRects(damage);

+    BoxPtr         pbox = RegionRects(damage);

+    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];

+

+    if (!dmxScreen->beDisplay)

+	return;

+

+    while (nbox--) {

+	XPutImage(dmxScreen->beDisplay,

+		  dmxScreen->scrnWin,

+		  dmxScreen->shadowGC,

+		  dmxScreen->shadowFBImage,

+		  pbox->x1, pbox->y1,

+		  pbox->x1, pbox->y1,

+		  pbox->x2 - pbox->x1,

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

+

+	pbox++;

+    }

+

+    dmxSync(dmxScreen, FALSE);

+}

diff --git a/xorg-server/hw/dmx/dmxstat.c b/xorg-server/hw/dmx/dmxstat.c
index 41b0eb27c..c08c6f4cd 100644
--- a/xorg-server/hw/dmx/dmxstat.c
+++ b/xorg-server/hw/dmx/dmxstat.c
@@ -1,221 +1,221 @@
-/*
- * Copyright 2002, 2003 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- *
- * The DMX server code is written to call #dmxSync() whenever an XSync()
- * might be necessary.  However, since XSync() requires a two way
- * communication with the other X server, eliminating unnecessary
- * XSync() calls is a key performance optimization.  Support for this
- * optimization is provided in \a dmxsync.c.  This file provides routines
- * that evaluate this optimization by counting the number of XSync()
- * calls and monitoring their latency.  This functionality can be turned
- * on using the -stat command-line parameter. */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "dmx.h"
-#include "dmxstat.h"
-#include "dmxlog.h"
-#include <X11/Xos.h>                /* For sys/time.h */
-
-/** Used to compute a running average of value. */
-typedef struct _DMXStatAvg {
-    int           pos;
-    int           count;
-    unsigned long value[DMX_STAT_LENGTH];
-} DMXStatAvg;
-
-/** Statistical information about XSync calls. */
-struct _DMXStatInfo {
-    unsigned long syncCount;
-    unsigned long oldSyncCount;
-
-    DMXStatAvg    usec;
-    DMXStatAvg    pending;
-
-    unsigned long bins[DMX_STAT_BINS];
-};
-
-/* Interval in mS between statistic message log entries. */
-       int        dmxStatInterval;
-static int        dmxStatDisplays;
-static OsTimerPtr dmxStatTimer;
-
-/** Return the number of microseconds as an unsigned long.
- * Unfortunately, this is only useful for intervals < about 4 sec.  */
-static unsigned long usec(struct timeval *stop, struct timeval *start)
-{
-    return (stop->tv_sec - start->tv_sec) * 1000000
-        + stop->tv_usec - start->tv_usec;
-}
-
-static unsigned long avg(DMXStatAvg *data, unsigned long *max)
-{
-    unsigned long sum;
-    int           i;
-
-    *max = 0;
-    if (!data->count) return 0;
-
-    for (i = 0, sum = 0; i < data->count; i++) {
-        if (data->value[i] > *max) *max = data->value[i];
-        sum += data->value[i];
-    }
-    return sum / data->count;
-}
-
-/** Turn on XSync statistic gathering and printing.  Print every \a
- * interval seconds, with lines for the first \a displays.  If \a
- * interval is NULL, 1 will be used.  If \a displays is NULL, 0 will be
- * used (meaning a line for every display will be printed).  Note that
- * this function takes string arguments because it will usually be
- * called from #ddxProcessArgument in \a dmxinit.c. */
-void dmxStatActivate(const char *interval, const char *displays)
-{
-    dmxStatInterval = (interval ? atoi(interval) : 1) * 1000;
-    dmxStatDisplays = (displays ? atoi(displays) : 0);
-
-    if (dmxStatInterval < 1000) dmxStatInterval = 1000;
-    if (dmxStatDisplays < 0)    dmxStatDisplays = 0;
-}
-
-/** Allocate a \a DMXStatInfo structure. */
-DMXStatInfo *dmxStatAlloc(void)
-{
-    DMXStatInfo *pt = calloc(1, sizeof(*pt));
-    return pt;
-}
-
-/** Free the memory used by a \a DMXStatInfo structure. */
-void dmxStatFree(DMXStatInfo *pt)
-{
-    if (pt) free(pt);
-}
-
-static void dmxStatValue(DMXStatAvg *data, unsigned long value)
-{
-    if (data->count != DMX_STAT_LENGTH) ++data->count;
-    if (data->pos >= DMX_STAT_LENGTH-1) data->pos = 0;
-    data->value[data->pos++] = value;
-}
-
-/** Note that a XSync() was just done on \a dmxScreen with the \a start
- * and \a stop times (from gettimeofday()) and the number of
- * pending-but-not-yet-processed XSync requests.  This routine is called
- * from #dmxDoSync in \a dmxsync.c */
-void dmxStatSync(DMXScreenInfo *dmxScreen,
-                 struct timeval *stop, struct timeval *start,
-                 unsigned long pending)
-{
-    DMXStatInfo   *s      = dmxScreen->stat;
-    unsigned long elapsed = usec(stop, start);
-    unsigned long thresh;
-    int           i;
-
-    ++s->syncCount;
-    dmxStatValue(&s->usec, elapsed);
-    dmxStatValue(&s->pending, pending);
-    
-    for (i = 0, thresh = DMX_STAT_BIN0; i < DMX_STAT_BINS-1; i++) {
-        if (elapsed < thresh) {
-            ++s->bins[i];
-            break;
-        }
-        thresh *= DMX_STAT_BINMULT;
-    }
-    if (i == DMX_STAT_BINS-1) ++s->bins[i];
-}
-
-/* Actually do the work of printing out the human-readable message. */
-static CARD32 dmxStatCallback(OsTimerPtr timer, CARD32 t, pointer arg)
-{
-    int         i, j;
-    static int  header = 0;
-    int         limit = dmxNumScreens;
-
-    if (!dmxNumScreens) {
-        header = 0;
-        return DMX_STAT_INTERVAL;
-    }
-
-    if (!header++ || !(header % 10)) {
-        dmxLog(dmxDebug,
-               " S SyncCount  Sync/s avSync mxSync avPend mxPend | "
-               "<10ms   <1s   >1s\n");
-    }
-
-    if (dmxStatDisplays && dmxStatDisplays < limit) limit = dmxStatDisplays;
-    for (i = 0; i < limit; i++) {
-        DMXScreenInfo *dmxScreen = &dmxScreens[i];
-        DMXStatInfo   *s         = dmxScreen->stat;
-        unsigned long aSync, mSync;
-        unsigned long aPend, mPend;
-        
-        if (!s) continue;
-
-        aSync = avg(&s->usec,    &mSync);
-        aPend = avg(&s->pending, &mPend);
-        dmxLog(dmxDebug, "%2d %9lu %7lu %6lu %6lu %6lu %6lu |",
-               i,                                               /* S */
-               s->syncCount,                                    /* SyncCount */
-               (s->syncCount
-                - s->oldSyncCount) * 1000 / dmxStatInterval,    /* Sync/s */
-               aSync,                                           /* us/Sync */
-               mSync,                                           /* max/Sync */
-               aPend,                                           /* avgPend */
-               mPend);                                          /* maxPend */
-        for (j = 0; j < DMX_STAT_BINS; j++)
-            dmxLogCont(dmxDebug, " %5lu", s->bins[j]);
-        dmxLogCont(dmxDebug, "\n");
-
-                                /* Reset/clear */
-        s->oldSyncCount = s->syncCount;
-        for (j = 0; j < DMX_STAT_BINS; j++) s->bins[j] = 0;
-    }
-    return DMX_STAT_INTERVAL;   /* Place on queue again */
-}
-
-/** Try to initialize the statistic gathering and printing routines.
- * Initialization only takes place if #dmxStatActivate has already been
- * called.  We don't need the same generation protection that we used in
- * dmxSyncInit because our timer is always on a queue -- hence, server
- * generation will always free it. */
-void dmxStatInit(void)
-{
-    if (dmxStatInterval)
-        dmxStatTimer = TimerSet(NULL, 0,
-                                dmxStatInterval, dmxStatCallback, NULL);
-}
+/*

+ * Copyright 2002, 2003 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ *

+ * The DMX server code is written to call #dmxSync() whenever an XSync()

+ * might be necessary.  However, since XSync() requires a two way

+ * communication with the other X server, eliminating unnecessary

+ * XSync() calls is a key performance optimization.  Support for this

+ * optimization is provided in \a dmxsync.c.  This file provides routines

+ * that evaluate this optimization by counting the number of XSync()

+ * calls and monitoring their latency.  This functionality can be turned

+ * on using the -stat command-line parameter. */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include "dmx.h"

+#include "dmxstat.h"

+#include "dmxlog.h"

+#include <X11/Xos.h>                /* For sys/time.h */

+

+/** Used to compute a running average of value. */

+typedef struct _DMXStatAvg {

+    int           pos;

+    int           count;

+    unsigned long value[DMX_STAT_LENGTH];

+} DMXStatAvg;

+

+/** Statistical information about XSync calls. */

+struct _DMXStatInfo {

+    unsigned long syncCount;

+    unsigned long oldSyncCount;

+

+    DMXStatAvg    usec;

+    DMXStatAvg    pending;

+

+    unsigned long bins[DMX_STAT_BINS];

+};

+

+/* Interval in mS between statistic message log entries. */

+       int        dmxStatInterval;

+static int        dmxStatDisplays;

+static OsTimerPtr dmxStatTimer;

+

+/** Return the number of microseconds as an unsigned long.

+ * Unfortunately, this is only useful for intervals < about 4 sec.  */

+static unsigned long usec(struct timeval *stop, struct timeval *start)

+{

+    return (stop->tv_sec - start->tv_sec) * 1000000

+        + stop->tv_usec - start->tv_usec;

+}

+

+static unsigned long avg(DMXStatAvg *data, unsigned long *max)

+{

+    unsigned long sum;

+    int           i;

+

+    *max = 0;

+    if (!data->count) return 0;

+

+    for (i = 0, sum = 0; i < data->count; i++) {

+        if (data->value[i] > *max) *max = data->value[i];

+        sum += data->value[i];

+    }

+    return sum / data->count;

+}

+

+/** Turn on XSync statistic gathering and printing.  Print every \a

+ * interval seconds, with lines for the first \a displays.  If \a

+ * interval is NULL, 1 will be used.  If \a displays is NULL, 0 will be

+ * used (meaning a line for every display will be printed).  Note that

+ * this function takes string arguments because it will usually be

+ * called from #ddxProcessArgument in \a dmxinit.c. */

+void dmxStatActivate(const char *interval, const char *displays)

+{

+    dmxStatInterval = (interval ? atoi(interval) : 1) * 1000;

+    dmxStatDisplays = (displays ? atoi(displays) : 0);

+

+    if (dmxStatInterval < 1000) dmxStatInterval = 1000;

+    if (dmxStatDisplays < 0)    dmxStatDisplays = 0;

+}

+

+/** Allocate a \a DMXStatInfo structure. */

+DMXStatInfo *dmxStatAlloc(void)

+{

+    DMXStatInfo *pt = calloc(1, sizeof(*pt));

+    return pt;

+}

+

+/** Free the memory used by a \a DMXStatInfo structure. */

+void dmxStatFree(DMXStatInfo *pt)

+{

+    free(pt);

+}

+

+static void dmxStatValue(DMXStatAvg *data, unsigned long value)

+{

+    if (data->count != DMX_STAT_LENGTH) ++data->count;

+    if (data->pos >= DMX_STAT_LENGTH-1) data->pos = 0;

+    data->value[data->pos++] = value;

+}

+

+/** Note that a XSync() was just done on \a dmxScreen with the \a start

+ * and \a stop times (from gettimeofday()) and the number of

+ * pending-but-not-yet-processed XSync requests.  This routine is called

+ * from #dmxDoSync in \a dmxsync.c */

+void dmxStatSync(DMXScreenInfo *dmxScreen,

+                 struct timeval *stop, struct timeval *start,

+                 unsigned long pending)

+{

+    DMXStatInfo   *s      = dmxScreen->stat;

+    unsigned long elapsed = usec(stop, start);

+    unsigned long thresh;

+    int           i;

+

+    ++s->syncCount;

+    dmxStatValue(&s->usec, elapsed);

+    dmxStatValue(&s->pending, pending);

+    

+    for (i = 0, thresh = DMX_STAT_BIN0; i < DMX_STAT_BINS-1; i++) {

+        if (elapsed < thresh) {

+            ++s->bins[i];

+            break;

+        }

+        thresh *= DMX_STAT_BINMULT;

+    }

+    if (i == DMX_STAT_BINS-1) ++s->bins[i];

+}

+

+/* Actually do the work of printing out the human-readable message. */

+static CARD32 dmxStatCallback(OsTimerPtr timer, CARD32 t, pointer arg)

+{

+    int         i, j;

+    static int  header = 0;

+    int         limit = dmxNumScreens;

+

+    if (!dmxNumScreens) {

+        header = 0;

+        return DMX_STAT_INTERVAL;

+    }

+

+    if (!header++ || !(header % 10)) {

+        dmxLog(dmxDebug,

+               " S SyncCount  Sync/s avSync mxSync avPend mxPend | "

+               "<10ms   <1s   >1s\n");

+    }

+

+    if (dmxStatDisplays && dmxStatDisplays < limit) limit = dmxStatDisplays;

+    for (i = 0; i < limit; i++) {

+        DMXScreenInfo *dmxScreen = &dmxScreens[i];

+        DMXStatInfo   *s         = dmxScreen->stat;

+        unsigned long aSync, mSync;

+        unsigned long aPend, mPend;

+        

+        if (!s) continue;

+

+        aSync = avg(&s->usec,    &mSync);

+        aPend = avg(&s->pending, &mPend);

+        dmxLog(dmxDebug, "%2d %9lu %7lu %6lu %6lu %6lu %6lu |",

+               i,                                               /* S */

+               s->syncCount,                                    /* SyncCount */

+               (s->syncCount

+                - s->oldSyncCount) * 1000 / dmxStatInterval,    /* Sync/s */

+               aSync,                                           /* us/Sync */

+               mSync,                                           /* max/Sync */

+               aPend,                                           /* avgPend */

+               mPend);                                          /* maxPend */

+        for (j = 0; j < DMX_STAT_BINS; j++)

+            dmxLogCont(dmxDebug, " %5lu", s->bins[j]);

+        dmxLogCont(dmxDebug, "\n");

+

+                                /* Reset/clear */

+        s->oldSyncCount = s->syncCount;

+        for (j = 0; j < DMX_STAT_BINS; j++) s->bins[j] = 0;

+    }

+    return DMX_STAT_INTERVAL;   /* Place on queue again */

+}

+

+/** Try to initialize the statistic gathering and printing routines.

+ * Initialization only takes place if #dmxStatActivate has already been

+ * called.  We don't need the same generation protection that we used in

+ * dmxSyncInit because our timer is always on a queue -- hence, server

+ * generation will always free it. */

+void dmxStatInit(void)

+{

+    if (dmxStatInterval)

+        dmxStatTimer = TimerSet(NULL, 0,

+                                dmxStatInterval, dmxStatCallback, NULL);

+}

diff --git a/xorg-server/hw/dmx/dmxwindow.c b/xorg-server/hw/dmx/dmxwindow.c
index 3466f074f..521f4af7d 100644
--- a/xorg-server/hw/dmx/dmxwindow.c
+++ b/xorg-server/hw/dmx/dmxwindow.c
@@ -60,7 +60,7 @@ static void dmxDoSetShape(WindowPtr pWindow);
 /** Initialize the private area for the window functions. */

 Bool dmxInitWindow(ScreenPtr pScreen)

 {

-    if (!dixRequestPrivate(dmxWinPrivateKey, sizeof(dmxWinPrivRec)))

+    if (!dixRegisterPrivateKey(&dmxWinPrivateKeyRec, PRIVATE_WINDOW, sizeof(dmxWinPrivRec)))

 	return FALSE;

 

     return TRUE;

@@ -940,8 +940,8 @@ static void dmxDoSetShape(WindowPtr pWindow)
 

     /* First, set the bounding shape */

     if (wBoundingShape(pWindow)) {

-	pBox = REGION_RECTS(wBoundingShape(pWindow));

-	nRect = nBox = REGION_NUM_RECTS(wBoundingShape(pWindow));

+	pBox = RegionRects(wBoundingShape(pWindow));

+	nRect = nBox = RegionNumRects(wBoundingShape(pWindow));

 	pRectFirst = pRect = malloc(nRect * sizeof(*pRect));

 	while (nBox--) {

 	    pRect->x      = pBox->x1;

@@ -963,8 +963,8 @@ static void dmxDoSetShape(WindowPtr pWindow)
 

     /* Next, set the clip shape */

     if (wClipShape(pWindow)) {

-	pBox = REGION_RECTS(wClipShape(pWindow));

-	nRect = nBox = REGION_NUM_RECTS(wClipShape(pWindow));

+	pBox = RegionRects(wClipShape(pWindow));

+	nRect = nBox = RegionNumRects(wClipShape(pWindow));

 	pRectFirst = pRect = malloc(nRect * sizeof(*pRect));

 	while (nBox--) {

 	    pRect->x      = pBox->x1;

@@ -991,7 +991,7 @@ static void dmxDoSetShape(WindowPtr pWindow)
 }

 

 /** Set shape of \a pWindow on the back-end server. */

-void dmxSetShape(WindowPtr pWindow)

+void dmxSetShape(WindowPtr pWindow, int kind)

 {

     ScreenPtr       pScreen = pWindow->drawable.pScreen;

     DMXScreenInfo  *dmxScreen = &dmxScreens[pScreen->myNum];

@@ -1000,7 +1000,7 @@ void dmxSetShape(WindowPtr pWindow)
     DMX_UNWRAP(SetShape, dmxScreen, pScreen);

 #if 1

     if (pScreen->SetShape)

-	pScreen->SetShape(pWindow);

+	pScreen->SetShape(pWindow, kind);

 #endif

 

     if (pWinPriv->window) {

diff --git a/xorg-server/hw/dmx/dmxwindow.h b/xorg-server/hw/dmx/dmxwindow.h
index 740a21f0b..43316d35b 100644
--- a/xorg-server/hw/dmx/dmxwindow.h
+++ b/xorg-server/hw/dmx/dmxwindow.h
@@ -1,138 +1,135 @@
-/*
- * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *
- */
-
-/** \file
- * Interface for window support.  \see dmxwindow.c */
-
-#ifndef DMXWINDOW_H
-#define DMXWINDOW_H
-
-#include "windowstr.h"
-
-/** Window private area. */
-typedef struct _dmxWinPriv {
-    Window         window;
-    Bool           offscreen;
-    Bool           mapped;
-    Bool           restacked;
-    unsigned long  attribMask;
-    Colormap       cmap;
-    Visual        *visual;
-    Bool           isShaped;
-    Bool           hasPict;
-#ifdef GLXEXT
-    void          *swapGroup;
-    int            barrier;
-    void         (*windowDestroyed)(WindowPtr);
-    void         (*windowUnmapped)(WindowPtr);
-#endif
-} dmxWinPrivRec, *dmxWinPrivPtr;
-
-
-extern Bool dmxInitWindow(ScreenPtr pScreen);
-
-extern Window dmxCreateRootWindow(WindowPtr pWindow);
-
-extern void dmxGetDefaultWindowAttributes(WindowPtr pWindow,
-					  Colormap *cmap,
-					  Visual **visual);
-extern void dmxCreateAndRealizeWindow(WindowPtr pWindow, Bool doSync);
-
-extern Bool dmxCreateWindow(WindowPtr pWindow);
-extern Bool dmxDestroyWindow(WindowPtr pWindow);
-extern Bool dmxPositionWindow(WindowPtr pWindow, int x, int y);
-extern Bool dmxChangeWindowAttributes(WindowPtr pWindow, unsigned long mask);
-extern Bool dmxRealizeWindow(WindowPtr pWindow);
-extern Bool dmxUnrealizeWindow(WindowPtr pWindow);
-extern void dmxRestackWindow(WindowPtr pWindow, WindowPtr pOldNextSib);
-extern void dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn,
-			       RegionPtr other_exposed);
-extern void dmxCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg,
-			  RegionPtr prgnSrc);
-
-extern void dmxResizeWindow(WindowPtr pWindow, int x, int y,
-			    unsigned int w, unsigned int h, WindowPtr pSib);
-extern void dmxReparentWindow(WindowPtr pWindow, WindowPtr pPriorParent);
-
-extern void dmxChangeBorderWidth(WindowPtr pWindow, unsigned int width);
-
-extern void dmxResizeScreenWindow(ScreenPtr pScreen,
-				  int x, int y, int w, int h);
-extern void dmxResizeRootWindow(WindowPtr pRoot,
-				int x, int y, int w, int h);
-
-extern Bool dmxBEDestroyWindow(WindowPtr pWindow);
-
-/* Support for shape extension */
-extern void dmxSetShape(WindowPtr pWindow);
-
-/** Private index.  \see dmxwindow.c \see dmxscrinit.c */
-extern DevPrivateKey dmxWinPrivateKey;
-
-/** Get window private pointer. */
-#define DMX_GET_WINDOW_PRIV(_pWin) ((dmxWinPrivPtr) \
-    dixLookupPrivate(&(_pWin)->devPrivates, dmxWinPrivateKey))
-
-/* All of these macros are only used in dmxwindow.c */
-#define DMX_WINDOW_FUNC_PROLOGUE(_pGC)					\
-do {									\
-    dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(_pGC);			\
-    DMX_UNWRAP(funcs, pGCPriv, (_pGC));					\
-    if (pGCPriv->ops)							\
-	DMX_UNWRAP(ops, pGCPriv, (_pGC));				\
-} while (0)
-
-#define DMX_WINDOW_FUNC_EPILOGUE(_pGC)					\
-do {									\
-    dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(_pGC);			\
-    DMX_WRAP(funcs, &dmxGCFuncs, pGCPriv, (_pGC));			\
-    if (pGCPriv->ops)							\
-	DMX_WRAP(ops, &dmxGCOps, pGCPriv, (_pGC));			\
-} while (0)
-
-#define DMX_WINDOW_X1(_pWin)						\
-    ((_pWin)->drawable.x - wBorderWidth(_pWin))
-#define DMX_WINDOW_Y1(_pWin)						\
-    ((_pWin)->drawable.y - wBorderWidth(_pWin))
-#define DMX_WINDOW_X2(_pWin)						\
-    ((_pWin)->drawable.x + wBorderWidth(_pWin) + (_pWin)->drawable.width) 
-#define DMX_WINDOW_Y2(_pWin)						\
-    ((_pWin)->drawable.y + wBorderWidth(_pWin) + (_pWin)->drawable.height) 
-
-#define DMX_WINDOW_OFFSCREEN(_pWin)					\
-    (DMX_WINDOW_X1(_pWin) >= (_pWin)->drawable.pScreen->width  ||	\
-     DMX_WINDOW_Y1(_pWin) >= (_pWin)->drawable.pScreen->height ||	\
-     DMX_WINDOW_X2(_pWin) <= 0                                 ||	\
-     DMX_WINDOW_Y2(_pWin) <= 0)
-
-#endif /* DMXWINDOW_H */
+/*

+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Kevin E. Martin <kem@redhat.com>

+ *

+ */

+

+/** \file

+ * Interface for window support.  \see dmxwindow.c */

+

+#ifndef DMXWINDOW_H

+#define DMXWINDOW_H

+

+#include "windowstr.h"

+

+/** Window private area. */

+typedef struct _dmxWinPriv {

+    Window         window;

+    Bool           offscreen;

+    Bool           mapped;

+    Bool           restacked;

+    unsigned long  attribMask;

+    Colormap       cmap;

+    Visual        *visual;

+    Bool           isShaped;

+    Bool           hasPict;

+#ifdef GLXEXT

+    void          *swapGroup;

+    int            barrier;

+    void         (*windowDestroyed)(WindowPtr);

+    void         (*windowUnmapped)(WindowPtr);

+#endif

+} dmxWinPrivRec, *dmxWinPrivPtr;

+

+

+extern Bool dmxInitWindow(ScreenPtr pScreen);

+

+extern Window dmxCreateRootWindow(WindowPtr pWindow);

+

+extern void dmxGetDefaultWindowAttributes(WindowPtr pWindow,

+					  Colormap *cmap,

+					  Visual **visual);

+extern void dmxCreateAndRealizeWindow(WindowPtr pWindow, Bool doSync);

+

+extern Bool dmxCreateWindow(WindowPtr pWindow);

+extern Bool dmxDestroyWindow(WindowPtr pWindow);

+extern Bool dmxPositionWindow(WindowPtr pWindow, int x, int y);

+extern Bool dmxChangeWindowAttributes(WindowPtr pWindow, unsigned long mask);

+extern Bool dmxRealizeWindow(WindowPtr pWindow);

+extern Bool dmxUnrealizeWindow(WindowPtr pWindow);

+extern void dmxRestackWindow(WindowPtr pWindow, WindowPtr pOldNextSib);

+extern void dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn,

+			       RegionPtr other_exposed);

+extern void dmxCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg,

+			  RegionPtr prgnSrc);

+

+extern void dmxResizeWindow(WindowPtr pWindow, int x, int y,

+			    unsigned int w, unsigned int h, WindowPtr pSib);

+extern void dmxReparentWindow(WindowPtr pWindow, WindowPtr pPriorParent);

+

+extern void dmxChangeBorderWidth(WindowPtr pWindow, unsigned int width);

+

+extern void dmxResizeScreenWindow(ScreenPtr pScreen,

+				  int x, int y, int w, int h);

+extern void dmxResizeRootWindow(WindowPtr pRoot,

+				int x, int y, int w, int h);

+

+extern Bool dmxBEDestroyWindow(WindowPtr pWindow);

+

+/* Support for shape extension */

+extern void dmxSetShape(WindowPtr pWindow, int kind);

+

+/** Get window private pointer. */

+#define DMX_GET_WINDOW_PRIV(_pWin) ((dmxWinPrivPtr) \

+    dixLookupPrivate(&(_pWin)->devPrivates, dmxWinPrivateKey))

+

+/* All of these macros are only used in dmxwindow.c */

+#define DMX_WINDOW_FUNC_PROLOGUE(_pGC)					\

+do {									\

+    dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(_pGC);			\

+    DMX_UNWRAP(funcs, pGCPriv, (_pGC));					\

+    if (pGCPriv->ops)							\

+	DMX_UNWRAP(ops, pGCPriv, (_pGC));				\

+} while (0)

+

+#define DMX_WINDOW_FUNC_EPILOGUE(_pGC)					\

+do {									\

+    dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(_pGC);			\

+    DMX_WRAP(funcs, &dmxGCFuncs, pGCPriv, (_pGC));			\

+    if (pGCPriv->ops)							\

+	DMX_WRAP(ops, &dmxGCOps, pGCPriv, (_pGC));			\

+} while (0)

+

+#define DMX_WINDOW_X1(_pWin)						\

+    ((_pWin)->drawable.x - wBorderWidth(_pWin))

+#define DMX_WINDOW_Y1(_pWin)						\

+    ((_pWin)->drawable.y - wBorderWidth(_pWin))

+#define DMX_WINDOW_X2(_pWin)						\

+    ((_pWin)->drawable.x + wBorderWidth(_pWin) + (_pWin)->drawable.width) 

+#define DMX_WINDOW_Y2(_pWin)						\

+    ((_pWin)->drawable.y + wBorderWidth(_pWin) + (_pWin)->drawable.height) 

+

+#define DMX_WINDOW_OFFSCREEN(_pWin)					\

+    (DMX_WINDOW_X1(_pWin) >= (_pWin)->drawable.pScreen->width  ||	\

+     DMX_WINDOW_Y1(_pWin) >= (_pWin)->drawable.pScreen->height ||	\

+     DMX_WINDOW_X2(_pWin) <= 0                                 ||	\

+     DMX_WINDOW_Y2(_pWin) <= 0)

+

+#endif /* DMXWINDOW_H */

diff --git a/xorg-server/hw/dmx/doc/dmx.xml b/xorg-server/hw/dmx/doc/dmx.xml
index 06716d1d7..c7eaf1333 100644
--- a/xorg-server/hw/dmx/doc/dmx.xml
+++ b/xorg-server/hw/dmx/doc/dmx.xml
@@ -1497,9 +1497,7 @@ PanoramiX prefix.
     <para>The Xinerama extension is registered by calling AddExtension().

     </para>

 

-    <para>A local per-screen array of data structures

-    (panoramiXdataPtr&lsqb;&rsqb;)

-    is allocated for each physical screen, and GC and Screen private

+    <para>GC and Screen private

     indexes are allocated, and both GC and Screen private areas are

     allocated for each physical screen.  These hold Xinerama-specific

     per-GC and per-Screen data.  Each screen's CreateGC and CloseScreen

@@ -1509,13 +1507,10 @@ PanoramiX prefix.
     Xinerama windows, pixmaps and colormaps.

     </para>

 

-    <para>A region (XineramaScreenRegions&lsqb;i&rsqb;) is initialized for each

-    physical screen, and single region (PanoramiXScreenRegion) is

-    initialized to be the union of the screen regions.  The

-    panoramiXdataPtr&lsqb;&rsqb; array is also initialized with the size and

-    origin of each screen.  The relative positioning information for the

-    physical screens is taken from the array

-    dixScreenOrigins&lsqb;&rsqb;, which

+    <para>A region (PanoramiXScreenRegion) is

+    initialized to be the union of the screen regions.

+    The relative positioning information for the

+    physical screens is taken from the ScreenRec x and y members, which

     the DDX layer must initialize in InitOutput().  The bounds of the

     combined screen is also calculated (PanoramiXPixWidth and

     PanoramiXPixHeight).

diff --git a/xorg-server/hw/dmx/glxProxy/compsize.c b/xorg-server/hw/dmx/glxProxy/compsize.c
index cae8fea3c..3bb562e05 100644
--- a/xorg-server/hw/dmx/glxProxy/compsize.c
+++ b/xorg-server/hw/dmx/glxProxy/compsize.c
@@ -1,558 +1,558 @@
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#include <GL/gl.h>
-
-GLint __glFogiv_size(GLenum pname)
-{
-    switch (pname) {
-      case GL_FOG_COLOR:	return 4;
-      case GL_FOG_DENSITY:	return 1;
-      case GL_FOG_END:		return 1;
-      case GL_FOG_MODE:		return 1;
-      case GL_FOG_INDEX:	return 1;
-      case GL_FOG_START:	return 1;
-      default:
-	return 0;
-    }
-}
-
-GLint __glFogfv_size(GLenum pname)
-{
-    return __glFogiv_size(pname);
-}
-
-GLint __glCallLists_size(GLsizei n, GLenum type)
-{
-    GLint size;
-
-    if (n < 0) return 0;
-    switch (type) {
-      case GL_BYTE:		size = 1; break;
-      case GL_UNSIGNED_BYTE:	size = 1; break;
-      case GL_SHORT:		size = 2; break;
-      case GL_UNSIGNED_SHORT:	size = 2; break;
-      case GL_INT:		size = 4; break;
-      case GL_UNSIGNED_INT:	size = 4; break;
-      case GL_FLOAT:		size = 4; break;
-      case GL_2_BYTES:		size = 2; break;
-      case GL_3_BYTES:		size = 3; break;
-      case GL_4_BYTES:		size = 4; break;
-      default:
-	return 0;
-    }
-    return n * size;
-}
-
-GLint __glDrawPixels_size(GLenum format, GLenum type, GLsizei w, GLsizei h)
-{
-    GLint elements, esize;
-    
-    switch (format) {
-      case GL_COLOR_INDEX:
-      case GL_STENCIL_INDEX:
-      case GL_DEPTH_COMPONENT:
-	elements = 1;
-	break;
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_LUMINANCE:
-	elements = 1;
-	break;
-      case GL_LUMINANCE_ALPHA:
-	elements = 2;
-	break;
-      case GL_RGB:
-	elements = 3;
-	break;
-      case GL_RGBA:
-      case GL_ABGR_EXT:
-	elements = 4;
-	break;
-      default:
-	return 0;
-    }
-    switch (type) {
-      case GL_BITMAP:
-	if (format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX) {
-	    return (h * ((w+7)/8));
-	} else {
-	    return 0;
-	}
-      case GL_BYTE:
-      case GL_UNSIGNED_BYTE:
-	esize = 1;
-	break;
-      case GL_UNSIGNED_BYTE_3_3_2:
-      case GL_UNSIGNED_BYTE_2_3_3_REV:
-	esize = 1;
-	elements = 1;
-	break;
-      case GL_SHORT:
-      case GL_UNSIGNED_SHORT:
-	esize = 2;
-	break;
-      case GL_UNSIGNED_SHORT_5_6_5:
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	esize = 2;
-	elements = 1;
-	break;
-      case GL_INT:
-      case GL_UNSIGNED_INT:
-      case GL_FLOAT:
-	esize = 4;
-	break;
-      case GL_UNSIGNED_INT_8_8_8_8:
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-      case GL_UNSIGNED_INT_10_10_10_2:
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-	esize = 4;
-	elements = 1;
-	break;
-      default:
-	return 0;
-    }
-    return (elements * esize * w * h);
-}
-
-GLint __glBitmap_size(GLsizei w, GLsizei h)
-{
-    return __glDrawPixels_size(GL_COLOR_INDEX, GL_BITMAP, w, h);
-}
-
-GLint __glTexGendv_size(GLenum e)
-{
-    switch (e) {
-      case GL_TEXTURE_GEN_MODE:
-	return 1;
-      case GL_OBJECT_PLANE:
-      case GL_EYE_PLANE:
-	return 4;
-      default:
-	return 0;
-    }
-}
-
-GLint __glTexGenfv_size(GLenum e)
-{
-    return __glTexGendv_size(e);
-}
-
-GLint __glTexGeniv_size(GLenum e)
-{
-    return __glTexGendv_size(e);
-}
-
-GLint __glTexParameterfv_size(GLenum e)
-{
-    switch (e) {
-      case GL_TEXTURE_WRAP_S:
-      case GL_TEXTURE_WRAP_T:
-      case GL_TEXTURE_WRAP_R:
-      case GL_TEXTURE_MIN_FILTER:
-      case GL_TEXTURE_MAG_FILTER:
-	return 1;
-      case GL_TEXTURE_BORDER_COLOR:
-	return 4;
-      case GL_TEXTURE_PRIORITY:
-	return 1;
-      case GL_TEXTURE_MIN_LOD:
-      case GL_TEXTURE_MAX_LOD:
-      case GL_TEXTURE_BASE_LEVEL:
-      case GL_TEXTURE_MAX_LEVEL:
-	return 1;
-      default:
-	return 0;
-    }
-}
-
-GLint __glTexParameteriv_size(GLenum e)
-{
-    return __glTexParameterfv_size(e);
-}
-
-GLint __glTexEnvfv_size(GLenum e)
-{
-    switch (e) {
-      case GL_TEXTURE_ENV_MODE:
-	return 1;
-      case GL_TEXTURE_ENV_COLOR:
-	return 4;
-      default:
-	return 0;
-    }
-}
-
-GLint __glTexEnviv_size(GLenum e)
-{
-    return __glTexEnvfv_size(e);
-}
-
-GLint __glTexImage1D_size(GLenum format, GLenum type, GLsizei w)
-{
-    GLint elements, esize;
-
-    if (w < 0) return 0;
-    switch (format) {
-      case GL_COLOR_INDEX:
-	elements = 1;
-	break;
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_LUMINANCE:
-	elements = 1;
-	break;
-      case GL_LUMINANCE_ALPHA:
-	elements = 2;
-	break;
-      case GL_RGB:
-	elements = 3;
-	break;
-      case GL_RGBA:
-      case GL_ABGR_EXT:
-	elements = 4;
-	break;
-      default:
-	return 0;
-    }
-    switch (type) {
-      case GL_BITMAP:
-	if (format == GL_COLOR_INDEX) {
-	    return (w+7)/8;
-	} else {
-	    return 0;
-	}
-      case GL_BYTE:
-      case GL_UNSIGNED_BYTE:
-	esize = 1;
-	break;
-      case GL_UNSIGNED_BYTE_3_3_2:
-      case GL_UNSIGNED_BYTE_2_3_3_REV:
-	esize = 1;
-	elements = 1;
-	break;
-      case GL_SHORT:
-      case GL_UNSIGNED_SHORT:
-	esize = 2;
-	break;
-      case GL_UNSIGNED_SHORT_5_6_5:
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	esize = 2;
-	elements = 1;
-	break;
-      case GL_INT:
-      case GL_UNSIGNED_INT:
-      case GL_FLOAT:
-	esize = 4;
-	break;
-      case GL_UNSIGNED_INT_8_8_8_8:
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-      case GL_UNSIGNED_INT_10_10_10_2:
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-	esize = 4;
-	elements = 1;
-	break;
-      default:
-	return 0;
-    }
-    return (elements * esize * w);
-}
-
-GLint __glTexImage2D_size(GLenum format, GLenum type, GLsizei w, GLsizei h)
-{
-    GLint elements, esize;
-
-    if (w < 0) return 0;
-    if (h < 0) return 0;
-    switch (format) {
-      case GL_COLOR_INDEX:
-	elements = 1;
-	break;
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_LUMINANCE:
-	elements = 1;
-	break;
-      case GL_LUMINANCE_ALPHA:
-	elements = 2;
-	break;
-      case GL_RGB:
-	elements = 3;
-	break;
-      case GL_RGBA:
-      case GL_ABGR_EXT:
-	elements = 4;
-	break;
-      default:
-	return 0;
-    }
-    switch (type) {
-      case GL_BITMAP:
-	if (format == GL_COLOR_INDEX) {
-	    return (h * ((w+7)/8));
-	} else {
-	    return 0;
-	}
-      case GL_BYTE:
-      case GL_UNSIGNED_BYTE:
-	esize = 1;
-	break;
-      case GL_UNSIGNED_BYTE_3_3_2:
-      case GL_UNSIGNED_BYTE_2_3_3_REV:
-	esize = 1;
-	elements = 1;
-	break;
-      case GL_SHORT:
-      case GL_UNSIGNED_SHORT:
-	esize = 2;
-	break;
-      case GL_UNSIGNED_SHORT_5_6_5:
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	esize = 2;
-	elements = 1;
-	break;
-      case GL_INT:
-      case GL_UNSIGNED_INT:
-      case GL_FLOAT:
-	esize = 4;
-	break;
-      case GL_UNSIGNED_INT_8_8_8_8:
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-      case GL_UNSIGNED_INT_10_10_10_2:
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-	esize = 4;
-	elements = 1;
-	break;
-      default:
-	return 0;
-    }
-    return (elements * esize * w * h);
-}
-
-GLint __glTexImage3D_size(GLenum format, GLenum type, GLsizei w, GLsizei h,
-			  GLsizei d)
-{
-    GLint elements, esize;
-
-    if (w < 0) return 0;
-    if (h < 0) return 0;
-    if (d < 0) return 0;
-    switch (format) {
-      case GL_COLOR_INDEX:
-	elements = 1;
-	break;
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_LUMINANCE:
-	elements = 1;
-	break;
-      case GL_LUMINANCE_ALPHA:
-	elements = 2;
-	break;
-      case GL_RGB:
-	elements = 3;
-	break;
-      case GL_RGBA:
-      case GL_ABGR_EXT:
-	elements = 4;
-	break;
-      default:
-	return 0;
-    }
-    switch (type) {
-      case GL_BITMAP:
-	if (format == GL_COLOR_INDEX) {
-	    return (d * (h * ((w+7)/8)));
-	} else {
-	    return 0;
-	}
-      case GL_BYTE:
-      case GL_UNSIGNED_BYTE:
-	esize = 1;
-	break;
-      case GL_UNSIGNED_BYTE_3_3_2:
-      case GL_UNSIGNED_BYTE_2_3_3_REV:
-	esize = 1;
-	elements = 1;
-	break;
-      case GL_SHORT:
-      case GL_UNSIGNED_SHORT:
-	esize = 2;
-	break;
-      case GL_UNSIGNED_SHORT_5_6_5:
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	esize = 2;
-	elements = 1;
-	break;
-      case GL_INT:
-      case GL_UNSIGNED_INT:
-      case GL_FLOAT:
-	esize = 4;
-	break;
-      case GL_UNSIGNED_INT_8_8_8_8:
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-      case GL_UNSIGNED_INT_10_10_10_2:
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-	esize = 4;
-	elements = 1;
-	break;
-      default:
-	return 0;
-    }
-    return (elements * esize * w * h * d);
-}
-
-GLint __glLightfv_size(GLenum pname)
-{
-    switch (pname) {
-      case GL_SPOT_EXPONENT:		return 1;
-      case GL_SPOT_CUTOFF:		return 1;
-      case GL_AMBIENT:			return 4;
-      case GL_DIFFUSE:			return 4;
-      case GL_SPECULAR:			return 4;
-      case GL_POSITION:			return 4;
-      case GL_SPOT_DIRECTION:		return 3;
-      case GL_CONSTANT_ATTENUATION:	return 1;
-      case GL_LINEAR_ATTENUATION:	return 1;
-      case GL_QUADRATIC_ATTENUATION:	return 1;
-      default:
-	return 0;
-    }
-}
-
-GLint __glLightiv_size(GLenum pname)
-{
-    return __glLightfv_size(pname);
-}
-
-GLint __glLightModelfv_size(GLenum pname)
-{
-    switch (pname) {
-      case GL_LIGHT_MODEL_AMBIENT:		return 4;
-      case GL_LIGHT_MODEL_LOCAL_VIEWER:		return 1;
-      case GL_LIGHT_MODEL_TWO_SIDE:		return 1;
-      case GL_LIGHT_MODEL_COLOR_CONTROL:	return 1;
-      default:
-	return 0;
-    }
-}
-
-GLint __glLightModeliv_size(GLenum pname)
-{
-    return __glLightModelfv_size(pname);
-}
-
-GLint __glMaterialfv_size(GLenum pname)
-{
-    switch (pname) {
-      case GL_SHININESS:		return 1;
-      case GL_EMISSION:			return 4;
-      case GL_AMBIENT:			return 4;
-      case GL_DIFFUSE:			return 4;
-      case GL_SPECULAR:			return 4;
-      case GL_AMBIENT_AND_DIFFUSE:	return 4;
-      case GL_COLOR_INDEXES:		return 3;
-      default:
-	return 0;
-    }
-}
-
-GLint __glMaterialiv_size(GLenum pname)
-{
-    return __glMaterialfv_size(pname);
-}
-
-GLint __glColorTableParameterfv_size(GLenum pname)
-{
-    switch (pname) {
-      case GL_COLOR_TABLE_FORMAT:
-      case GL_COLOR_TABLE_WIDTH:
-      case GL_COLOR_TABLE_RED_SIZE:
-      case GL_COLOR_TABLE_GREEN_SIZE:
-      case GL_COLOR_TABLE_BLUE_SIZE:
-      case GL_COLOR_TABLE_ALPHA_SIZE:
-      case GL_COLOR_TABLE_LUMINANCE_SIZE:
-      case GL_COLOR_TABLE_INTENSITY_SIZE:
-	return 1;
-      case GL_COLOR_TABLE_SCALE:
-      case GL_COLOR_TABLE_BIAS:
-	return 4;
-      default:
-	return -1;
-    }
-}
-
-GLint __glColorTableParameteriv_size(GLenum pname)
-{
-    return __glColorTableParameterfv_size(pname);
-}
-
-GLint __glConvolutionParameterfv_size(GLenum pname)
-{
-    switch(pname) {
-      case GL_CONVOLUTION_BORDER_MODE:
-	return 1;
-      case GL_CONVOLUTION_BORDER_COLOR:
-      case GL_CONVOLUTION_FILTER_SCALE:
-      case GL_CONVOLUTION_FILTER_BIAS:
-	return 4;
-      default: /* error: bad enum value */
-	return -1;
-    }
-}
-
-GLint __glConvolutionParameteriv_size(GLenum pname)
-{
-    return __glConvolutionParameterfv_size(pname);
-}
+/*

+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)

+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice including the dates of first publication and

+ * either this permission notice or a reference to

+ * http://oss.sgi.com/projects/FreeB/

+ * shall be included in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * Except as contained in this notice, the name of Silicon Graphics, Inc.

+ * shall not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization from

+ * Silicon Graphics, Inc.

+ */

+

+#include <GL/gl.h>

+

+GLint __glFogiv_size(GLenum pname)

+{

+    switch (pname) {

+      case GL_FOG_COLOR:	return 4;

+      case GL_FOG_DENSITY:	return 1;

+      case GL_FOG_END:		return 1;

+      case GL_FOG_MODE:		return 1;

+      case GL_FOG_INDEX:	return 1;

+      case GL_FOG_START:	return 1;

+      default:

+	return 0;

+    }

+}

+

+GLint __glFogfv_size(GLenum pname)

+{

+    return __glFogiv_size(pname);

+}

+

+GLint __glCallLists_size(GLsizei n, GLenum type)

+{

+    GLint size;

+

+    if (n < 0) return 0;

+    switch (type) {

+      case GL_BYTE:		size = 1; break;

+      case GL_UNSIGNED_BYTE:	size = 1; break;

+      case GL_SHORT:		size = 2; break;

+      case GL_UNSIGNED_SHORT:	size = 2; break;

+      case GL_INT:		size = 4; break;

+      case GL_UNSIGNED_INT:	size = 4; break;

+      case GL_FLOAT:		size = 4; break;

+      case GL_2_BYTES:		size = 2; break;

+      case GL_3_BYTES:		size = 3; break;

+      case GL_4_BYTES:		size = 4; break;

+      default:

+	return 0;

+    }

+    return n * size;

+}

+

+GLint __glDrawPixels_size(GLenum format, GLenum type, GLsizei w, GLsizei h)

+{

+    GLint elements, esize;

+    

+    switch (format) {

+      case GL_COLOR_INDEX:

+      case GL_STENCIL_INDEX:

+      case GL_DEPTH_COMPONENT:

+	elements = 1;

+	break;

+      case GL_RED:

+      case GL_GREEN:

+      case GL_BLUE:

+      case GL_ALPHA:

+      case GL_LUMINANCE:

+	elements = 1;

+	break;

+      case GL_LUMINANCE_ALPHA:

+	elements = 2;

+	break;

+      case GL_RGB:

+	elements = 3;

+	break;

+      case GL_RGBA:

+      case GL_ABGR_EXT:

+	elements = 4;

+	break;

+      default:

+	return 0;

+    }

+    switch (type) {

+      case GL_BITMAP:

+	if (format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX) {

+	    return (h * ((w+7)/8));

+	} else {

+	    return 0;

+	}

+      case GL_BYTE:

+      case GL_UNSIGNED_BYTE:

+	esize = 1;

+	break;

+      case GL_UNSIGNED_BYTE_3_3_2:

+      case GL_UNSIGNED_BYTE_2_3_3_REV:

+	esize = 1;

+	elements = 1;

+	break;

+      case GL_SHORT:

+      case GL_UNSIGNED_SHORT:

+	esize = 2;

+	break;

+      case GL_UNSIGNED_SHORT_5_6_5:

+      case GL_UNSIGNED_SHORT_5_6_5_REV:

+      case GL_UNSIGNED_SHORT_4_4_4_4:

+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+      case GL_UNSIGNED_SHORT_5_5_5_1:

+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	esize = 2;

+	elements = 1;

+	break;

+      case GL_INT:

+      case GL_UNSIGNED_INT:

+      case GL_FLOAT:

+	esize = 4;

+	break;

+      case GL_UNSIGNED_INT_8_8_8_8:

+      case GL_UNSIGNED_INT_8_8_8_8_REV:

+      case GL_UNSIGNED_INT_10_10_10_2:

+      case GL_UNSIGNED_INT_2_10_10_10_REV:

+	esize = 4;

+	elements = 1;

+	break;

+      default:

+	return 0;

+    }

+    return elements * esize * w * h;

+}

+

+GLint __glBitmap_size(GLsizei w, GLsizei h)

+{

+    return __glDrawPixels_size(GL_COLOR_INDEX, GL_BITMAP, w, h);

+}

+

+GLint __glTexGendv_size(GLenum e)

+{

+    switch (e) {

+      case GL_TEXTURE_GEN_MODE:

+	return 1;

+      case GL_OBJECT_PLANE:

+      case GL_EYE_PLANE:

+	return 4;

+      default:

+	return 0;

+    }

+}

+

+GLint __glTexGenfv_size(GLenum e)

+{

+    return __glTexGendv_size(e);

+}

+

+GLint __glTexGeniv_size(GLenum e)

+{

+    return __glTexGendv_size(e);

+}

+

+GLint __glTexParameterfv_size(GLenum e)

+{

+    switch (e) {

+      case GL_TEXTURE_WRAP_S:

+      case GL_TEXTURE_WRAP_T:

+      case GL_TEXTURE_WRAP_R:

+      case GL_TEXTURE_MIN_FILTER:

+      case GL_TEXTURE_MAG_FILTER:

+	return 1;

+      case GL_TEXTURE_BORDER_COLOR:

+	return 4;

+      case GL_TEXTURE_PRIORITY:

+	return 1;

+      case GL_TEXTURE_MIN_LOD:

+      case GL_TEXTURE_MAX_LOD:

+      case GL_TEXTURE_BASE_LEVEL:

+      case GL_TEXTURE_MAX_LEVEL:

+	return 1;

+      default:

+	return 0;

+    }

+}

+

+GLint __glTexParameteriv_size(GLenum e)

+{

+    return __glTexParameterfv_size(e);

+}

+

+GLint __glTexEnvfv_size(GLenum e)

+{

+    switch (e) {

+      case GL_TEXTURE_ENV_MODE:

+	return 1;

+      case GL_TEXTURE_ENV_COLOR:

+	return 4;

+      default:

+	return 0;

+    }

+}

+

+GLint __glTexEnviv_size(GLenum e)

+{

+    return __glTexEnvfv_size(e);

+}

+

+GLint __glTexImage1D_size(GLenum format, GLenum type, GLsizei w)

+{

+    GLint elements, esize;

+

+    if (w < 0) return 0;

+    switch (format) {

+      case GL_COLOR_INDEX:

+	elements = 1;

+	break;

+      case GL_RED:

+      case GL_GREEN:

+      case GL_BLUE:

+      case GL_ALPHA:

+      case GL_LUMINANCE:

+	elements = 1;

+	break;

+      case GL_LUMINANCE_ALPHA:

+	elements = 2;

+	break;

+      case GL_RGB:

+	elements = 3;

+	break;

+      case GL_RGBA:

+      case GL_ABGR_EXT:

+	elements = 4;

+	break;

+      default:

+	return 0;

+    }

+    switch (type) {

+      case GL_BITMAP:

+	if (format == GL_COLOR_INDEX) {

+	    return (w+7)/8;

+	} else {

+	    return 0;

+	}

+      case GL_BYTE:

+      case GL_UNSIGNED_BYTE:

+	esize = 1;

+	break;

+      case GL_UNSIGNED_BYTE_3_3_2:

+      case GL_UNSIGNED_BYTE_2_3_3_REV:

+	esize = 1;

+	elements = 1;

+	break;

+      case GL_SHORT:

+      case GL_UNSIGNED_SHORT:

+	esize = 2;

+	break;

+      case GL_UNSIGNED_SHORT_5_6_5:

+      case GL_UNSIGNED_SHORT_5_6_5_REV:

+      case GL_UNSIGNED_SHORT_4_4_4_4:

+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+      case GL_UNSIGNED_SHORT_5_5_5_1:

+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	esize = 2;

+	elements = 1;

+	break;

+      case GL_INT:

+      case GL_UNSIGNED_INT:

+      case GL_FLOAT:

+	esize = 4;

+	break;

+      case GL_UNSIGNED_INT_8_8_8_8:

+      case GL_UNSIGNED_INT_8_8_8_8_REV:

+      case GL_UNSIGNED_INT_10_10_10_2:

+      case GL_UNSIGNED_INT_2_10_10_10_REV:

+	esize = 4;

+	elements = 1;

+	break;

+      default:

+	return 0;

+    }

+    return elements * esize * w;

+}

+

+GLint __glTexImage2D_size(GLenum format, GLenum type, GLsizei w, GLsizei h)

+{

+    GLint elements, esize;

+

+    if (w < 0) return 0;

+    if (h < 0) return 0;

+    switch (format) {

+      case GL_COLOR_INDEX:

+	elements = 1;

+	break;

+      case GL_RED:

+      case GL_GREEN:

+      case GL_BLUE:

+      case GL_ALPHA:

+      case GL_LUMINANCE:

+	elements = 1;

+	break;

+      case GL_LUMINANCE_ALPHA:

+	elements = 2;

+	break;

+      case GL_RGB:

+	elements = 3;

+	break;

+      case GL_RGBA:

+      case GL_ABGR_EXT:

+	elements = 4;

+	break;

+      default:

+	return 0;

+    }

+    switch (type) {

+      case GL_BITMAP:

+	if (format == GL_COLOR_INDEX) {

+	    return (h * ((w+7)/8));

+	} else {

+	    return 0;

+	}

+      case GL_BYTE:

+      case GL_UNSIGNED_BYTE:

+	esize = 1;

+	break;

+      case GL_UNSIGNED_BYTE_3_3_2:

+      case GL_UNSIGNED_BYTE_2_3_3_REV:

+	esize = 1;

+	elements = 1;

+	break;

+      case GL_SHORT:

+      case GL_UNSIGNED_SHORT:

+	esize = 2;

+	break;

+      case GL_UNSIGNED_SHORT_5_6_5:

+      case GL_UNSIGNED_SHORT_5_6_5_REV:

+      case GL_UNSIGNED_SHORT_4_4_4_4:

+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+      case GL_UNSIGNED_SHORT_5_5_5_1:

+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	esize = 2;

+	elements = 1;

+	break;

+      case GL_INT:

+      case GL_UNSIGNED_INT:

+      case GL_FLOAT:

+	esize = 4;

+	break;

+      case GL_UNSIGNED_INT_8_8_8_8:

+      case GL_UNSIGNED_INT_8_8_8_8_REV:

+      case GL_UNSIGNED_INT_10_10_10_2:

+      case GL_UNSIGNED_INT_2_10_10_10_REV:

+	esize = 4;

+	elements = 1;

+	break;

+      default:

+	return 0;

+    }

+    return elements * esize * w * h;

+}

+

+GLint __glTexImage3D_size(GLenum format, GLenum type, GLsizei w, GLsizei h,

+			  GLsizei d)

+{

+    GLint elements, esize;

+

+    if (w < 0) return 0;

+    if (h < 0) return 0;

+    if (d < 0) return 0;

+    switch (format) {

+      case GL_COLOR_INDEX:

+	elements = 1;

+	break;

+      case GL_RED:

+      case GL_GREEN:

+      case GL_BLUE:

+      case GL_ALPHA:

+      case GL_LUMINANCE:

+	elements = 1;

+	break;

+      case GL_LUMINANCE_ALPHA:

+	elements = 2;

+	break;

+      case GL_RGB:

+	elements = 3;

+	break;

+      case GL_RGBA:

+      case GL_ABGR_EXT:

+	elements = 4;

+	break;

+      default:

+	return 0;

+    }

+    switch (type) {

+      case GL_BITMAP:

+	if (format == GL_COLOR_INDEX) {

+	    return (d * (h * ((w+7)/8)));

+	} else {

+	    return 0;

+	}

+      case GL_BYTE:

+      case GL_UNSIGNED_BYTE:

+	esize = 1;

+	break;

+      case GL_UNSIGNED_BYTE_3_3_2:

+      case GL_UNSIGNED_BYTE_2_3_3_REV:

+	esize = 1;

+	elements = 1;

+	break;

+      case GL_SHORT:

+      case GL_UNSIGNED_SHORT:

+	esize = 2;

+	break;

+      case GL_UNSIGNED_SHORT_5_6_5:

+      case GL_UNSIGNED_SHORT_5_6_5_REV:

+      case GL_UNSIGNED_SHORT_4_4_4_4:

+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+      case GL_UNSIGNED_SHORT_5_5_5_1:

+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	esize = 2;

+	elements = 1;

+	break;

+      case GL_INT:

+      case GL_UNSIGNED_INT:

+      case GL_FLOAT:

+	esize = 4;

+	break;

+      case GL_UNSIGNED_INT_8_8_8_8:

+      case GL_UNSIGNED_INT_8_8_8_8_REV:

+      case GL_UNSIGNED_INT_10_10_10_2:

+      case GL_UNSIGNED_INT_2_10_10_10_REV:

+	esize = 4;

+	elements = 1;

+	break;

+      default:

+	return 0;

+    }

+    return elements * esize * w * h * d;

+}

+

+GLint __glLightfv_size(GLenum pname)

+{

+    switch (pname) {

+      case GL_SPOT_EXPONENT:		return 1;

+      case GL_SPOT_CUTOFF:		return 1;

+      case GL_AMBIENT:			return 4;

+      case GL_DIFFUSE:			return 4;

+      case GL_SPECULAR:			return 4;

+      case GL_POSITION:			return 4;

+      case GL_SPOT_DIRECTION:		return 3;

+      case GL_CONSTANT_ATTENUATION:	return 1;

+      case GL_LINEAR_ATTENUATION:	return 1;

+      case GL_QUADRATIC_ATTENUATION:	return 1;

+      default:

+	return 0;

+    }

+}

+

+GLint __glLightiv_size(GLenum pname)

+{

+    return __glLightfv_size(pname);

+}

+

+GLint __glLightModelfv_size(GLenum pname)

+{

+    switch (pname) {

+      case GL_LIGHT_MODEL_AMBIENT:		return 4;

+      case GL_LIGHT_MODEL_LOCAL_VIEWER:		return 1;

+      case GL_LIGHT_MODEL_TWO_SIDE:		return 1;

+      case GL_LIGHT_MODEL_COLOR_CONTROL:	return 1;

+      default:

+	return 0;

+    }

+}

+

+GLint __glLightModeliv_size(GLenum pname)

+{

+    return __glLightModelfv_size(pname);

+}

+

+GLint __glMaterialfv_size(GLenum pname)

+{

+    switch (pname) {

+      case GL_SHININESS:		return 1;

+      case GL_EMISSION:			return 4;

+      case GL_AMBIENT:			return 4;

+      case GL_DIFFUSE:			return 4;

+      case GL_SPECULAR:			return 4;

+      case GL_AMBIENT_AND_DIFFUSE:	return 4;

+      case GL_COLOR_INDEXES:		return 3;

+      default:

+	return 0;

+    }

+}

+

+GLint __glMaterialiv_size(GLenum pname)

+{

+    return __glMaterialfv_size(pname);

+}

+

+GLint __glColorTableParameterfv_size(GLenum pname)

+{

+    switch (pname) {

+      case GL_COLOR_TABLE_FORMAT:

+      case GL_COLOR_TABLE_WIDTH:

+      case GL_COLOR_TABLE_RED_SIZE:

+      case GL_COLOR_TABLE_GREEN_SIZE:

+      case GL_COLOR_TABLE_BLUE_SIZE:

+      case GL_COLOR_TABLE_ALPHA_SIZE:

+      case GL_COLOR_TABLE_LUMINANCE_SIZE:

+      case GL_COLOR_TABLE_INTENSITY_SIZE:

+	return 1;

+      case GL_COLOR_TABLE_SCALE:

+      case GL_COLOR_TABLE_BIAS:

+	return 4;

+      default:

+	return -1;

+    }

+}

+

+GLint __glColorTableParameteriv_size(GLenum pname)

+{

+    return __glColorTableParameterfv_size(pname);

+}

+

+GLint __glConvolutionParameterfv_size(GLenum pname)

+{

+    switch(pname) {

+      case GL_CONVOLUTION_BORDER_MODE:

+	return 1;

+      case GL_CONVOLUTION_BORDER_COLOR:

+      case GL_CONVOLUTION_FILTER_SCALE:

+      case GL_CONVOLUTION_FILTER_BIAS:

+	return 4;

+      default: /* error: bad enum value */

+	return -1;

+    }

+}

+

+GLint __glConvolutionParameteriv_size(GLenum pname)

+{

+    return __glConvolutionParameterfv_size(pname);

+}

diff --git a/xorg-server/hw/dmx/glxProxy/g_renderswap.c b/xorg-server/hw/dmx/glxProxy/g_renderswap.c
index 8aab433e8..39316a99b 100644
--- a/xorg-server/hw/dmx/glxProxy/g_renderswap.c
+++ b/xorg-server/hw/dmx/glxProxy/g_renderswap.c
@@ -64,6 +64,7 @@ void __glXDispSwap_Color3bv(GLbyte *pc)
 void __glXDispSwap_Color3dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -79,6 +80,7 @@ void __glXDispSwap_Color3dv(GLbyte *pc)
 void __glXDispSwap_Color3fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

 }

@@ -86,6 +88,7 @@ void __glXDispSwap_Color3fv(GLbyte *pc)
 void __glXDispSwap_Color3iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

 

@@ -94,6 +97,7 @@ void __glXDispSwap_Color3iv(GLbyte *pc)
 void __glXDispSwap_Color3sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

 

@@ -106,6 +110,7 @@ void __glXDispSwap_Color3ubv(GLbyte *pc)
 void __glXDispSwap_Color3uiv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

 }

@@ -113,6 +118,7 @@ void __glXDispSwap_Color3uiv(GLbyte *pc)
 void __glXDispSwap_Color3usv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

 }

@@ -124,6 +130,7 @@ void __glXDispSwap_Color4bv(GLbyte *pc)
 void __glXDispSwap_Color4dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -138,6 +145,7 @@ void __glXDispSwap_Color4dv(GLbyte *pc)
 void __glXDispSwap_Color4fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);

 

@@ -146,6 +154,7 @@ void __glXDispSwap_Color4fv(GLbyte *pc)
 void __glXDispSwap_Color4iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

 

@@ -154,6 +163,7 @@ void __glXDispSwap_Color4iv(GLbyte *pc)
 void __glXDispSwap_Color4sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

 

@@ -167,6 +177,7 @@ void __glXDispSwap_Color4ubv(GLbyte *pc)
 void __glXDispSwap_Color4uiv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

 

@@ -175,6 +186,7 @@ void __glXDispSwap_Color4uiv(GLbyte *pc)
 void __glXDispSwap_Color4usv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

 

@@ -191,6 +203,7 @@ void __glXDispSwap_End(GLbyte *pc)
 void __glXDispSwap_Indexdv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -206,6 +219,7 @@ void __glXDispSwap_Indexdv(GLbyte *pc)
 void __glXDispSwap_Indexfv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);

 

@@ -214,6 +228,7 @@ void __glXDispSwap_Indexfv(GLbyte *pc)
 void __glXDispSwap_Indexiv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 1);

 

@@ -222,6 +237,7 @@ void __glXDispSwap_Indexiv(GLbyte *pc)
 void __glXDispSwap_Indexsv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);

 

@@ -234,6 +250,7 @@ void __glXDispSwap_Normal3bv(GLbyte *pc)
 void __glXDispSwap_Normal3dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -249,6 +266,7 @@ void __glXDispSwap_Normal3dv(GLbyte *pc)
 void __glXDispSwap_Normal3fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

 

@@ -257,6 +275,7 @@ void __glXDispSwap_Normal3fv(GLbyte *pc)
 void __glXDispSwap_Normal3iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

 

@@ -265,6 +284,7 @@ void __glXDispSwap_Normal3iv(GLbyte *pc)
 void __glXDispSwap_Normal3sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

 

@@ -273,6 +293,7 @@ void __glXDispSwap_Normal3sv(GLbyte *pc)
 void __glXDispSwap_RasterPos2dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -288,6 +309,7 @@ void __glXDispSwap_RasterPos2dv(GLbyte *pc)
 void __glXDispSwap_RasterPos2fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

 

@@ -296,6 +318,7 @@ void __glXDispSwap_RasterPos2fv(GLbyte *pc)
 void __glXDispSwap_RasterPos2iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 2);

 

@@ -304,6 +327,7 @@ void __glXDispSwap_RasterPos2iv(GLbyte *pc)
 void __glXDispSwap_RasterPos2sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);

 

@@ -312,6 +336,7 @@ void __glXDispSwap_RasterPos2sv(GLbyte *pc)
 void __glXDispSwap_RasterPos3dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -327,6 +352,7 @@ void __glXDispSwap_RasterPos3dv(GLbyte *pc)
 void __glXDispSwap_RasterPos3fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

 

@@ -335,6 +361,7 @@ void __glXDispSwap_RasterPos3fv(GLbyte *pc)
 void __glXDispSwap_RasterPos3iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

 

@@ -343,6 +370,7 @@ void __glXDispSwap_RasterPos3iv(GLbyte *pc)
 void __glXDispSwap_RasterPos3sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

 

@@ -351,6 +379,7 @@ void __glXDispSwap_RasterPos3sv(GLbyte *pc)
 void __glXDispSwap_RasterPos4dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -366,6 +395,7 @@ void __glXDispSwap_RasterPos4dv(GLbyte *pc)
 void __glXDispSwap_RasterPos4fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);

 

@@ -374,6 +404,7 @@ void __glXDispSwap_RasterPos4fv(GLbyte *pc)
 void __glXDispSwap_RasterPos4iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

 

@@ -382,6 +413,7 @@ void __glXDispSwap_RasterPos4iv(GLbyte *pc)
 void __glXDispSwap_RasterPos4sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

 

@@ -390,6 +422,7 @@ void __glXDispSwap_RasterPos4sv(GLbyte *pc)
 void __glXDispSwap_Rectdv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -406,6 +439,7 @@ void __glXDispSwap_Rectdv(GLbyte *pc)
 void __glXDispSwap_Rectfv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

 	__GLX_SWAP_FLOAT_ARRAY(pc + 8, 2);

@@ -415,6 +449,7 @@ void __glXDispSwap_Rectfv(GLbyte *pc)
 void __glXDispSwap_Rectiv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 2);

 	__GLX_SWAP_INT_ARRAY(pc + 8, 2);

@@ -424,6 +459,7 @@ void __glXDispSwap_Rectiv(GLbyte *pc)
 void __glXDispSwap_Rectsv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);

 	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);

@@ -433,6 +469,7 @@ void __glXDispSwap_Rectsv(GLbyte *pc)
 void __glXDispSwap_TexCoord1dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -448,6 +485,7 @@ void __glXDispSwap_TexCoord1dv(GLbyte *pc)
 void __glXDispSwap_TexCoord1fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);

 

@@ -456,6 +494,7 @@ void __glXDispSwap_TexCoord1fv(GLbyte *pc)
 void __glXDispSwap_TexCoord1iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 1);

 

@@ -464,6 +503,7 @@ void __glXDispSwap_TexCoord1iv(GLbyte *pc)
 void __glXDispSwap_TexCoord1sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);

 

@@ -472,6 +512,7 @@ void __glXDispSwap_TexCoord1sv(GLbyte *pc)
 void __glXDispSwap_TexCoord2dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -487,6 +528,7 @@ void __glXDispSwap_TexCoord2dv(GLbyte *pc)
 void __glXDispSwap_TexCoord2fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

 

@@ -495,6 +537,7 @@ void __glXDispSwap_TexCoord2fv(GLbyte *pc)
 void __glXDispSwap_TexCoord2iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 2);

 

@@ -503,6 +546,7 @@ void __glXDispSwap_TexCoord2iv(GLbyte *pc)
 void __glXDispSwap_TexCoord2sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);

 

@@ -511,6 +555,7 @@ void __glXDispSwap_TexCoord2sv(GLbyte *pc)
 void __glXDispSwap_TexCoord3dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -526,6 +571,7 @@ void __glXDispSwap_TexCoord3dv(GLbyte *pc)
 void __glXDispSwap_TexCoord3fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

 

@@ -534,6 +580,7 @@ void __glXDispSwap_TexCoord3fv(GLbyte *pc)
 void __glXDispSwap_TexCoord3iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

 

@@ -542,6 +589,7 @@ void __glXDispSwap_TexCoord3iv(GLbyte *pc)
 void __glXDispSwap_TexCoord3sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

 

@@ -550,6 +598,7 @@ void __glXDispSwap_TexCoord3sv(GLbyte *pc)
 void __glXDispSwap_TexCoord4dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -565,6 +614,7 @@ void __glXDispSwap_TexCoord4dv(GLbyte *pc)
 void __glXDispSwap_TexCoord4fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);

 

@@ -573,6 +623,7 @@ void __glXDispSwap_TexCoord4fv(GLbyte *pc)
 void __glXDispSwap_TexCoord4iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

 

@@ -581,6 +632,7 @@ void __glXDispSwap_TexCoord4iv(GLbyte *pc)
 void __glXDispSwap_TexCoord4sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

 

@@ -589,6 +641,7 @@ void __glXDispSwap_TexCoord4sv(GLbyte *pc)
 void __glXDispSwap_Vertex2dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -604,6 +657,7 @@ void __glXDispSwap_Vertex2dv(GLbyte *pc)
 void __glXDispSwap_Vertex2fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

 

@@ -612,6 +666,7 @@ void __glXDispSwap_Vertex2fv(GLbyte *pc)
 void __glXDispSwap_Vertex2iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 2);

 

@@ -620,6 +675,7 @@ void __glXDispSwap_Vertex2iv(GLbyte *pc)
 void __glXDispSwap_Vertex2sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);

 

@@ -628,6 +684,7 @@ void __glXDispSwap_Vertex2sv(GLbyte *pc)
 void __glXDispSwap_Vertex3dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -643,6 +700,7 @@ void __glXDispSwap_Vertex3dv(GLbyte *pc)
 void __glXDispSwap_Vertex3fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

 

@@ -651,6 +709,7 @@ void __glXDispSwap_Vertex3fv(GLbyte *pc)
 void __glXDispSwap_Vertex3iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

 

@@ -659,6 +718,7 @@ void __glXDispSwap_Vertex3iv(GLbyte *pc)
 void __glXDispSwap_Vertex3sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

 

@@ -667,6 +727,7 @@ void __glXDispSwap_Vertex3sv(GLbyte *pc)
 void __glXDispSwap_Vertex4dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -682,6 +743,7 @@ void __glXDispSwap_Vertex4dv(GLbyte *pc)
 void __glXDispSwap_Vertex4fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);

 

@@ -690,6 +752,7 @@ void __glXDispSwap_Vertex4fv(GLbyte *pc)
 void __glXDispSwap_Vertex4iv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

 

@@ -698,6 +761,7 @@ void __glXDispSwap_Vertex4iv(GLbyte *pc)
 void __glXDispSwap_Vertex4sv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

 

@@ -706,6 +770,7 @@ void __glXDispSwap_Vertex4sv(GLbyte *pc)
 void __glXDispSwap_ClipPlane(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -750,6 +815,7 @@ void __glXDispSwap_Fogfv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	pname = *(GLenum *)(pc + 0);

@@ -773,6 +839,7 @@ void __glXDispSwap_Fogiv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	pname = *(GLenum *)(pc + 0);

@@ -814,6 +881,7 @@ void __glXDispSwap_Lightfv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -839,6 +907,7 @@ void __glXDispSwap_Lightiv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -863,6 +932,7 @@ void __glXDispSwap_LightModelfv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	pname = *(GLenum *)(pc + 0);

@@ -886,6 +956,7 @@ void __glXDispSwap_LightModeliv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	pname = *(GLenum *)(pc + 0);

@@ -927,6 +998,7 @@ void __glXDispSwap_Materialfv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -952,6 +1024,7 @@ void __glXDispSwap_Materialiv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -1013,6 +1086,7 @@ void __glXDispSwap_TexParameterfv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -1038,6 +1112,7 @@ void __glXDispSwap_TexParameteriv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -1063,6 +1138,7 @@ void __glXDispSwap_TexEnvfv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -1088,6 +1164,7 @@ void __glXDispSwap_TexEnviv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -1121,6 +1198,7 @@ void __glXDispSwap_TexGendv(GLbyte *pc)
 	GLint cmdlen;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -1154,6 +1232,7 @@ void __glXDispSwap_TexGenfv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -1179,6 +1258,7 @@ void __glXDispSwap_TexGeniv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -1414,6 +1494,7 @@ void __glXDispSwap_MapGrid2f(GLbyte *pc)
 void __glXDispSwap_EvalCoord1dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -1429,6 +1510,7 @@ void __glXDispSwap_EvalCoord1dv(GLbyte *pc)
 void __glXDispSwap_EvalCoord1fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);

 

@@ -1437,6 +1519,7 @@ void __glXDispSwap_EvalCoord1fv(GLbyte *pc)
 void __glXDispSwap_EvalCoord2dv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -1452,6 +1535,7 @@ void __glXDispSwap_EvalCoord2dv(GLbyte *pc)
 void __glXDispSwap_EvalCoord2fv(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

 

@@ -1581,6 +1665,7 @@ void __glXDispSwap_PixelMapfv(GLbyte *pc)
 {

 	GLint mapsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	mapsize = *(GLint *)(pc + 4);

@@ -1593,6 +1678,7 @@ void __glXDispSwap_PixelMapuiv(GLbyte *pc)
 {

 	GLint mapsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	mapsize = *(GLint *)(pc + 4);

@@ -1605,6 +1691,7 @@ void __glXDispSwap_PixelMapusv(GLbyte *pc)
 {

 	GLint mapsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	mapsize = *(GLint *)(pc + 4);

@@ -1676,6 +1763,7 @@ void __glXDispSwap_LoadIdentity(GLbyte *pc)
 void __glXDispSwap_LoadMatrixf(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);

 

@@ -1684,6 +1772,7 @@ void __glXDispSwap_LoadMatrixf(GLbyte *pc)
 void __glXDispSwap_LoadMatrixd(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -1707,6 +1796,7 @@ void __glXDispSwap_MatrixMode(GLbyte *pc)
 void __glXDispSwap_MultMatrixf(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);

 

@@ -1715,6 +1805,7 @@ void __glXDispSwap_MultMatrixf(GLbyte *pc)
 void __glXDispSwap_MultMatrixd(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -1928,6 +2019,7 @@ void __glXDispSwap_PrioritizeTextures(GLbyte *pc)
 {

 	GLsizei n;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	n = *(GLsizei *)(pc + 0);

@@ -1964,6 +2056,7 @@ void __glXDispSwap_ColorTableParameterfv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -1979,6 +2072,7 @@ void __glXDispSwap_ColorTableParameteriv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -2028,6 +2122,7 @@ void __glXDispSwap_ConvolutionParameterfv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -2053,6 +2148,7 @@ void __glXDispSwap_ConvolutionParameteriv(GLbyte *pc)
 	GLenum pname;

 	GLint compsize;

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 4);

 	pname = *(GLenum *)(pc + 4);

@@ -2150,6 +2246,7 @@ void __glXDispSwap_ActiveTextureARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord1dvARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -2166,6 +2263,7 @@ void __glXDispSwap_MultiTexCoord1dvARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord1fvARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 1);

@@ -2175,6 +2273,7 @@ void __glXDispSwap_MultiTexCoord1fvARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord1ivARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_INT_ARRAY(pc + 4, 1);

@@ -2184,6 +2283,7 @@ void __glXDispSwap_MultiTexCoord1ivARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord1svARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_SHORT_ARRAY(pc + 4, 1);

@@ -2193,6 +2293,7 @@ void __glXDispSwap_MultiTexCoord1svARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord2dvARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -2209,6 +2310,7 @@ void __glXDispSwap_MultiTexCoord2dvARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord2fvARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 2);

@@ -2218,6 +2320,7 @@ void __glXDispSwap_MultiTexCoord2fvARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord2ivARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_INT_ARRAY(pc + 4, 2);

@@ -2227,6 +2330,7 @@ void __glXDispSwap_MultiTexCoord2ivARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord2svARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);

@@ -2236,6 +2340,7 @@ void __glXDispSwap_MultiTexCoord2svARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord3dvARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -2252,6 +2357,7 @@ void __glXDispSwap_MultiTexCoord3dvARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord3fvARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 3);

@@ -2261,6 +2367,7 @@ void __glXDispSwap_MultiTexCoord3fvARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord3ivARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_INT_ARRAY(pc + 4, 3);

@@ -2270,6 +2377,7 @@ void __glXDispSwap_MultiTexCoord3ivARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord3svARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_SHORT_ARRAY(pc + 4, 3);

@@ -2279,6 +2387,7 @@ void __glXDispSwap_MultiTexCoord3svARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord4dvARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 

 #ifdef __GLX_ALIGN64

@@ -2295,6 +2404,7 @@ void __glXDispSwap_MultiTexCoord4dvARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord4fvARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 4);

@@ -2304,6 +2414,7 @@ void __glXDispSwap_MultiTexCoord4fvARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord4ivARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_INT_ARRAY(pc + 4, 4);

@@ -2313,6 +2424,7 @@ void __glXDispSwap_MultiTexCoord4ivARB(GLbyte *pc)
 void __glXDispSwap_MultiTexCoord4svARB(GLbyte *pc)

 {

 	__GLX_DECLARE_SWAP_VARIABLES;

+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

 	__GLX_SWAP_INT(pc + 0);

 	__GLX_SWAP_SHORT_ARRAY(pc + 4, 4);

diff --git a/xorg-server/hw/dmx/glxProxy/glxcmds.c b/xorg-server/hw/dmx/glxProxy/glxcmds.c
index bac4478da..d0e3a9b77 100644
--- a/xorg-server/hw/dmx/glxProxy/glxcmds.c
+++ b/xorg-server/hw/dmx/glxProxy/glxcmds.c
@@ -80,7 +80,7 @@ Display *GetBackEndDisplay( __GLXclientState *cl, int s )
    if (! cl->be_displays[s] ) {

       cl->be_displays[s] = XOpenDisplay( DisplayString(dmxScreens[s].beDisplay) );

    }

-   return( cl->be_displays[s] );

+   return cl->be_displays[s];

 }

 

 /*

@@ -628,7 +628,7 @@ int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s)
       return( cl->be_currentCTag[ (tag-1)*screenInfo.numScreens + s ] );

    }

    else {

-      return( 0 );

+      return 0;

    }

 }

 

@@ -2841,6 +2841,7 @@ int __glXGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
 

 	if (client->swapped) {

 	    __GLX_DECLARE_SWAP_VARIABLES;

+	    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 	    __GLX_SWAP_INT_ARRAY((int *)buf, 2*numAttribs);

 	}

 	WriteToClient(client, 2*numAttribs * __GLX_SIZE_CARD32, (char *)buf);

diff --git a/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c b/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c
index b3720f6f6..8a2efaa73 100644
--- a/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c
+++ b/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c
@@ -1,1050 +1,1059 @@
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#include "glxserver.h"
-#include "glxutil.h"
-#include <GL/glxtokens.h>
-#include <g_disptab.h>
-#include <pixmapstr.h>
-#include <windowstr.h>
-#include "unpack.h"
-#include "glxext.h"
-#include "glxvendor.h"
-
-extern int glxIsExtensionSupported( char *ext );
-
-/************************************************************************/
-
-/*
-** Byteswapping versions of GLX commands.  In most cases they just swap
-** the incoming arguments and then call the unswapped routine.  For commands
-** that have replies, a separate swapping routine for the reply is provided;
-** it is called at the end of the unswapped routine.
-*/
-
-int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->context);
-    __GLX_SWAP_INT(&req->visual);
-    __GLX_SWAP_INT(&req->screen);
-    __GLX_SWAP_INT(&req->shareList);
-
-    return __glXCreateContext(cl, pc);
-}
-
-int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->context);
-    __GLX_SWAP_INT(&req->fbconfig);
-    __GLX_SWAP_INT(&req->screen);
-    __GLX_SWAP_INT(&req->shareList);
-
-    return __glXCreateNewContext(cl, pc);
-}
-
-int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreateContextWithConfigSGIXReq *req = (xGLXCreateContextWithConfigSGIXReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->context);
-    __GLX_SWAP_INT(&req->fbconfig);
-    __GLX_SWAP_INT(&req->screen);
-    __GLX_SWAP_INT(&req->shareList);
-
-    return __glXCreateContextWithConfigSGIX(cl, pc);
-}
-
-int __glXSwapQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXQueryMaxSwapBarriersSGIXReq *req =
-	(xGLXQueryMaxSwapBarriersSGIXReq *)pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->screen);
-
-    return __glXQueryMaxSwapBarriersSGIX(cl, pc);
-}
-
-int __glXSwapBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *)pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->drawable);
-    __GLX_SWAP_INT(&req->barrier);
-
-    return __glXBindSwapBarrierSGIX(cl, pc);
-}
-
-int __glXSwapJoinSwapGroupSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXJoinSwapGroupSGIXReq *req = (xGLXJoinSwapGroupSGIXReq *)pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->drawable);
-    __GLX_SWAP_INT(&req->member);
-
-    return __glXJoinSwapGroupSGIX(cl, pc);
-}
-
-int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->context);
-
-    return __glXDestroyContext(cl, pc);
-}
-
-int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->drawable);
-    __GLX_SWAP_INT(&req->context);
-    __GLX_SWAP_INT(&req->oldContextTag);
-
-    return __glXMakeCurrent(cl, pc);
-}
-
-int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->drawable);
-    __GLX_SWAP_INT(&req->readdrawable);
-    __GLX_SWAP_INT(&req->context);
-    __GLX_SWAP_INT(&req->oldContextTag);
-
-    return __glXMakeContextCurrent(cl, pc);
-}
-
-int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->drawable);
-    __GLX_SWAP_INT(&req->readable);
-    __GLX_SWAP_INT(&req->context);
-    __GLX_SWAP_INT(&req->oldContextTag);
-
-    return __glXMakeCurrentReadSGI(cl, pc);
-}
-
-int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->context);
-
-    return __glXIsDirect(cl, pc);
-}
-
-int __glXSwapQueryVersion(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->majorVersion);
-    __GLX_SWAP_INT(&req->minorVersion);
-
-    return __glXQueryVersion(cl, pc);
-}
-
-int __glXSwapWaitGL(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->contextTag);
-
-    return __glXWaitGL(cl, pc);
-}
-
-int __glXSwapWaitX(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXWaitXReq *req = (xGLXWaitXReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->contextTag);
-
-    return __glXWaitX(cl, pc);
-}
-
-int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->source);
-    __GLX_SWAP_INT(&req->dest);
-    __GLX_SWAP_INT(&req->mask);
-
-    return __glXCopyContext(cl, pc);
-}
-
-int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
-{
-   ClientPtr client = cl->client;
-    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
-    xGLXGetVisualConfigsReply reply;
-    __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
-    CARD32 buf[__GLX_TOTAL_CONFIG];
-    unsigned int screen;
-    int i, p;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_INT(&req->screen);
-    screen = req->screen;
-    if (screen > screenInfo.numScreens) {
-	/* The client library must send a valid screen number. */
-	client->errorValue = screen;
-	return BadValue;
-    }
-    pGlxScreen = &__glXActiveScreens[screen];
-
-    reply.numVisuals = pGlxScreen->numGLXVisuals;
-    reply.numProps = __GLX_TOTAL_CONFIG;
-    reply.length = (pGlxScreen->numGLXVisuals * __GLX_SIZE_CARD32 *
-		    __GLX_TOTAL_CONFIG) >> 2;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    
-    __GLX_SWAP_SHORT(&reply.sequenceNumber);
-    __GLX_SWAP_INT(&reply.length);
-    __GLX_SWAP_INT(&reply.numVisuals);
-    __GLX_SWAP_INT(&reply.numProps);
-    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
-
-    for (i=0; i < pGlxScreen->numVisuals; i++) {
-	pGlxVisual = &pGlxScreen->pGlxVisual[i];
-	if (!pGlxScreen->isGLXvis[i] || pGlxVisual->vid == 0) {
-	    /* not a usable visual */
-	    continue;
-	}
-	p = 0;
-	buf[p++] = pGlxVisual->vid;
-	buf[p++] = pGlxVisual->class;
-	buf[p++] = pGlxVisual->rgba;
-
-	buf[p++] = pGlxVisual->redSize;
-	buf[p++] = pGlxVisual->greenSize;
-	buf[p++] = pGlxVisual->blueSize;
-	buf[p++] = pGlxVisual->alphaSize;
-	buf[p++] = pGlxVisual->accumRedSize;
-	buf[p++] = pGlxVisual->accumGreenSize;
-	buf[p++] = pGlxVisual->accumBlueSize;
-	buf[p++] = pGlxVisual->accumAlphaSize;
-
-	buf[p++] = pGlxVisual->doubleBuffer;
-	buf[p++] = pGlxVisual->stereo;
-
-	buf[p++] = pGlxVisual->bufferSize;
-	buf[p++] = pGlxVisual->depthSize;
-	buf[p++] = pGlxVisual->stencilSize;
-	buf[p++] = pGlxVisual->auxBuffers;
-	buf[p++] = pGlxVisual->level;
-        /*
-        ** Add token/value pairs for extensions.
-        */
-        buf[p++] = GLX_VISUAL_CAVEAT_EXT;
-        buf[p++] = pGlxVisual->visualRating;
-        buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
-        buf[p++] = pGlxVisual->transparentPixel;
-        buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentRed;
-        buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentGreen;
-        buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentBlue;
-        buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentAlpha;
-        buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentIndex;
-
-	__GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
-	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 
-			(char *)buf);
-    }
-    return Success;
-}
-
-int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->screen);
-    __GLX_SWAP_INT(&req->visual);
-    __GLX_SWAP_INT(&req->pixmap);
-    __GLX_SWAP_INT(&req->glxpixmap);
-
-    return __glXCreateGLXPixmap(cl, pc);
-}
-
-int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->screen);
-    __GLX_SWAP_INT(&req->fbconfig);
-    __GLX_SWAP_INT(&req->pixmap);
-    __GLX_SWAP_INT(&req->glxpixmap);
-    __GLX_SWAP_INT(&req->numAttribs);
-
-    return __glXCreatePixmap(cl, pc);
-}
-
-int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->glxpixmap);
-
-    return __glXDestroyGLXPixmap(cl, pc);
-}
-
-int __glXSwapSwapBuffers(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->contextTag);
-    __GLX_SWAP_INT(&req->drawable);
-
-    return __glXSwapBuffers(cl, pc);
-}
-
-int __glXSwapUseXFont(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->contextTag);
-    __GLX_SWAP_INT(&req->font);
-    __GLX_SWAP_INT(&req->first);
-    __GLX_SWAP_INT(&req->count);
-    __GLX_SWAP_INT(&req->listBase);
-
-    return __glXUseXFont(cl, pc);
-}
-
-
-int __glXSwapQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXQueryExtensionsStringReq *req = NULL;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->screen);
-
-    return __glXQueryExtensionsString(cl, pc);
-}
-
-int __glXSwapQueryServerString(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *)pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->screen);
-    __GLX_SWAP_INT(&req->name);
-
-    return __glXQueryServerString(cl, pc);
-}
-
-int __glXSwapClientInfo(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXClientInfoReq *req = (xGLXClientInfoReq *)pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->major);
-    __GLX_SWAP_INT(&req->minor);
-    __GLX_SWAP_INT(&req->numbytes);
-
-    return __glXClientInfo(cl, pc);
-}
-
-int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, char *pc)
-{
-    xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->context);
-
-    return __glXQueryContextInfoEXT(cl, (GLbyte *)pc);
-}
-
-/************************************************************************/
-
-/*
-** Swap replies.
-*/
-
-void __glXSwapMakeCurrentReply(ClientPtr client,  xGLXMakeCurrentReadSGIReply *reply)
-{
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_SWAP_SHORT(&reply->sequenceNumber);
-    __GLX_SWAP_INT(&reply->length);
-    __GLX_SWAP_INT(&reply->contextTag);
-    __GLX_SWAP_INT(&reply->writeVid);
-    __GLX_SWAP_INT(&reply->writeType);
-    __GLX_SWAP_INT(&reply->readVid);
-    __GLX_SWAP_INT(&reply->readType);
-    WriteToClient(client, sz_xGLXMakeCurrentReadSGIReply, (char *)reply);
-}
-
-void __glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply *reply)
-{
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_SWAP_SHORT(&reply->sequenceNumber);
-    __GLX_SWAP_INT(&reply->length);
-    WriteToClient(client, sz_xGLXIsDirectReply, (char *)reply);
-}
-
-void __glXSwapQueryVersionReply(ClientPtr client, xGLXQueryVersionReply *reply)
-{
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_SWAP_SHORT(&reply->sequenceNumber);
-    __GLX_SWAP_INT(&reply->length);
-    __GLX_SWAP_INT(&reply->majorVersion);
-    __GLX_SWAP_INT(&reply->minorVersion);
-    WriteToClient(client, sz_xGLXQueryVersionReply, (char *)reply);
-}
-
-void glxSwapQueryExtensionsStringReply(ClientPtr client,
-				       xGLXQueryExtensionsStringReply *reply, char *buf)
-{
-    int length = reply->length;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_SWAP_SHORT(&reply->sequenceNumber);
-    __GLX_SWAP_INT(&reply->length);
-    __GLX_SWAP_INT(&reply->n);
-    WriteToClient(client, sz_xGLXQueryExtensionsStringReply, (char *)reply);
-    __GLX_SWAP_INT_ARRAY((int *)buf, length);
-    WriteToClient(client, length << 2, buf);
-}
-
-void glxSwapQueryServerStringReply(ClientPtr client,
-				   xGLXQueryServerStringReply *reply, char *buf)
-{
-    int length = reply->length;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_SWAP_SHORT(&reply->sequenceNumber);
-    __GLX_SWAP_INT(&reply->length);
-    __GLX_SWAP_INT(&reply->n);
-    WriteToClient(client, sz_xGLXQueryServerStringReply, (char *)reply);
-    /** no swap is needed for an array of chars **/
-    /* __GLX_SWAP_INT_ARRAY((int *)buf, length); */
-    WriteToClient(client, length << 2, buf);
-}
-
-void __glXSwapQueryContextInfoEXTReply(ClientPtr client, xGLXQueryContextInfoEXTReply *reply, int *buf)
-{
-    int length = reply->length;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_SWAP_SHORT(&reply->sequenceNumber);
-    __GLX_SWAP_INT(&reply->length);
-    __GLX_SWAP_INT(&reply->n);
-    WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)reply);
-    __GLX_SWAP_INT_ARRAY((int *)buf, length);
-    WriteToClient(client, length << 2, (char *)buf);
-}
-
-
-void __glXSwapQueryContextReply(ClientPtr client,
-                                xGLXQueryContextReply *reply, int *buf)
-{
-    int length = reply->length;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_SWAP_SHORT(&reply->sequenceNumber);
-    __GLX_SWAP_INT(&reply->length);
-    __GLX_SWAP_INT(&reply->n);
-    WriteToClient(client, sz_xGLXQueryContextReply, (char *)reply);
-    __GLX_SWAP_INT_ARRAY((int *)buf, length);
-    WriteToClient(client, length << 2, (char *)buf);
-}
-
-void __glXSwapGetDrawableAttributesReply(ClientPtr client,
-                                 xGLXGetDrawableAttributesReply *reply, int *buf) 
-{
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_SWAP_SHORT(&reply->sequenceNumber);
-    __GLX_SWAP_INT(&reply->length);
-    __GLX_SWAP_INT(&reply->numAttribs);
-    __GLX_SWAP_INT_ARRAY( buf, reply->length );
-    WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *)reply);
-    WriteToClient(client, reply->length << 2, (char *)buf);
-}
-
-void __glXSwapQueryMaxSwapBarriersSGIXReply(ClientPtr client, xGLXQueryMaxSwapBarriersSGIXReply *reply)
-{
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_SWAP_SHORT(&reply->sequenceNumber);
-    __GLX_SWAP_INT(&reply->length);
-    __GLX_SWAP_INT(&reply->max);
-    WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply, (char *)reply);
-}
-
-/************************************************************************/
-
-/*
-** Render and Renderlarge are not in the GLX API.  They are used by the GLX
-** client library to send batches of GL rendering commands.
-*/
-
-int __glXSwapRender(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXRenderReq *req;
-    int left;
-    __GLXrenderHeader *hdr;
-    ClientPtr client = cl->client;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    /*
-    ** NOTE: much of this code also appears in the nonswapping version of this
-    ** routine, __glXRender().  Any changes made here should also be
-    ** duplicated there.
-    */
-    
-    req = (xGLXRenderReq *) pc;
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->contextTag);
-
-    pc += sz_xGLXRenderReq;
-    left = (req->length << 2) - sz_xGLXRenderReq;
-    while (left > 0) {
-	void (* proc)(GLbyte *);
-	CARD16 opcode;
-
-	/*
-	** Verify that the header length and the overall length agree.
-	** Also, each command must be word aligned.
-	*/
-	hdr = (__GLXrenderHeader *) pc;
-	__GLX_SWAP_SHORT(&hdr->length);
-	__GLX_SWAP_SHORT(&hdr->opcode);
-
-	/*
-         * call the command procedure to swap any arguments
-	 */
-	opcode = hdr->opcode;
-	if ( (opcode >= __GLX_MIN_RENDER_OPCODE) && 
-	     (opcode <= __GLX_MAX_RENDER_OPCODE) ) {
-	    proc = __glXSwapRenderTable[opcode];
-#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
-	} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) && 
-	     (opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
-	    int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
-	    __GLXRenderSwapInfo *info = &__glXSwapRenderTable_EXT[index];
-	    if (info->swapfunc) {
-	       proc = info->swapfunc;
-	    }
-	    else {
-	       proc = NULL;
-	       if (info->elem_size == 4 && info->nelems > 0) {
-		  __GLX_SWAP_INT_ARRAY( (int *)(pc + __GLX_RENDER_HDR_SIZE), 
-			                info->nelems );
-	       }
-	       else if (info->elem_size == 2 && info->nelems > 0) {
-		  __GLX_SWAP_SHORT_ARRAY( (short *)(pc + __GLX_RENDER_HDR_SIZE), 
-			                info->nelems );
-	       }
-	       else if (info->elem_size == 8 && info->nelems > 0) {
-		  __GLX_SWAP_DOUBLE_ARRAY( (double *)(pc + __GLX_RENDER_HDR_SIZE), 
-			                info->nelems );
-	       }
-	    }
-#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
-	} else {
-	    client->errorValue = 0;
-	    return __glXBadRenderRequest;
-	}
-
-	if (proc != NULL) 
-	   (*proc)(pc + __GLX_RENDER_HDR_SIZE);
-
-	/*
-	 * proceed to the next command
-	 */ 
-	pc += hdr->length;
-	left -= hdr->length;
-    }
-
-    return __glXRender( cl, (GLbyte *)req );
-}
-
-/*
-** Execute a large rendering request (one that spans multiple X requests).
-*/
-int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
-{
-   ClientPtr client = cl->client;
-    xGLXRenderLargeReq *req;
-    __GLXrenderLargeHeader *hdr;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    req = (xGLXRenderLargeReq *) pc;
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->contextTag);
-    __GLX_SWAP_INT(&req->dataBytes);
-    __GLX_SWAP_SHORT(&req->requestNumber);
-    __GLX_SWAP_SHORT(&req->requestTotal);
-
-    pc += sz_xGLXRenderLargeReq;
-   
-    if (req->requestNumber == 1) {
-	void (* proc)(GLbyte *) = NULL;
-	__GLXRenderSwapInfo *info = NULL;
-	CARD16 opcode;
-
-	hdr = (__GLXrenderLargeHeader *) pc;
-	__GLX_SWAP_INT(&hdr->length);
-	__GLX_SWAP_INT(&hdr->opcode);
-
-	/*
-         * call the command procedure to swap any arguments
-	 * Note that we are assuming that all arguments that needs to be
-	 * swaped are on the first req only !
-	 */
-	opcode = hdr->opcode;
-	if ( (opcode >= __GLX_MIN_RENDER_OPCODE) && 
-	     (opcode <= __GLX_MAX_RENDER_OPCODE) ) {
-	    proc = __glXSwapRenderTable[opcode];
-#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
-	} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) && 
-	     (opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
-	    int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
-	    info = &__glXSwapRenderTable_EXT[index];
-	    if (info->swapfunc) {
-	       proc = info->swapfunc;
-	    }
-#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
-	} else {
-	    client->errorValue = 0;
-	    cl->largeCmdRequestsTotal = 0;
-	    return __glXBadLargeRequest;
-	}
-
-	/*
-	** Make enough space in the buffer, then copy the entire request.
-	*/
-	if (cl->largeCmdBufSize < hdr->length) {
-	    if (!cl->largeCmdBuf) {
-		cl->largeCmdBuf = (GLbyte *) __glXMalloc(hdr->length);
-	    } else {
-		cl->largeCmdBuf = (GLbyte *) __glXRealloc(cl->largeCmdBuf, hdr->length);
-	    }
-	    if (!cl->largeCmdBuf) {
-	       cl->largeCmdRequestsTotal = 0;
-		return BadAlloc;
-	    }
-	    cl->largeCmdBufSize = hdr->length;
-	}
-	memcpy(cl->largeCmdBuf, pc, req->dataBytes);
-
-	cl->largeCmdBytesSoFar = req->dataBytes;
-	cl->largeCmdBytesTotal = hdr->length;
-	cl->largeCmdRequestsSoFar = 1;
-	cl->largeCmdRequestsTotal = req->requestTotal;
-	cl->largeCmdRequestsSwapProc = proc;
-	cl->largeCmdMaxReqDataSize = req->dataBytes;
-	cl->largeCmdRequestsSwap_info = info;
-
-	return Success;
-	
-
-    }
-    else if (req->requestNumber < cl->largeCmdRequestsTotal) {
-       /*
-        * This is not the first nor last request - just copy the data
-	*/
-       if (  cl->largeCmdBytesSoFar + req->dataBytes > cl->largeCmdBytesTotal) {
-	    cl->largeCmdRequestsTotal = 0;
-	    return __glXBadLargeRequest;
-       }
-
-       memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, 
-	           pc, req->dataBytes);
-
-       cl->largeCmdBytesSoFar += req->dataBytes;
-
-       if (req->dataBytes > cl->largeCmdMaxReqDataSize)
-	  cl->largeCmdMaxReqDataSize = req->dataBytes;
-
-	return Success;
-    }
-    else if (req->requestNumber == cl->largeCmdRequestsTotal) {
-       /*
-        * this is the last request
-        * copy the remainder bytes, call the procedure to swap any
-	* needed data, and then call to transfer the command to all
-	* back-end servers
-	*/
-       if (  cl->largeCmdBytesSoFar + req->dataBytes > cl->largeCmdBytesTotal) {
-	    cl->largeCmdRequestsTotal = 0;
-	    return __glXBadLargeRequest;
-       }
-
-       memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, 
-	           pc, req->dataBytes);
-
-       cl->largeCmdBytesSoFar += req->dataBytes;
-
-       if (req->dataBytes > cl->largeCmdMaxReqDataSize)
-	  cl->largeCmdMaxReqDataSize = req->dataBytes;
-
-	if (cl->largeCmdRequestsSwapProc != NULL) {
-	   (*cl->largeCmdRequestsSwapProc)(cl->largeCmdBuf + __GLX_RENDER_LARGE_HDR_SIZE);
-	}
-	else if (cl->largeCmdRequestsSwap_info &&
-	         cl->largeCmdRequestsSwap_info->nelems > 0) {
-    	   if (cl->largeCmdRequestsSwap_info->elem_size == 4) {
-	      __GLX_SWAP_INT_ARRAY( (int *)(pc + __GLX_RENDER_LARGE_HDR_SIZE), 
-		       cl->largeCmdRequestsSwap_info->nelems );
-	   }
-	   else if (cl->largeCmdRequestsSwap_info->elem_size == 2) {
-	      __GLX_SWAP_SHORT_ARRAY( (short *)(pc + __GLX_RENDER_LARGE_HDR_SIZE), 
-		       cl->largeCmdRequestsSwap_info->nelems );
-	   }
-	   else if (cl->largeCmdRequestsSwap_info->elem_size == 8) {
-	      __GLX_SWAP_DOUBLE_ARRAY( (double *)(pc + __GLX_RENDER_LARGE_HDR_SIZE), 
-		       cl->largeCmdRequestsSwap_info->nelems );
-	   }
-	}
-
-	cl->largeCmdRequestsTotal = 0;
-        return( __glXSendLargeCommand(cl, req->contextTag) );
-
-    }
-    else {
-       cl->largeCmdRequestsTotal = 0;
-       return __glXBadLargeRequest;
-    }
-
-}
-
-/************************************************************************/
-
-/*
-** No support is provided for the vendor-private requests other than
-** allocating these entry points in the dispatch table.
-*/
-
-int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq *req;
-    CARD32 vendorCode;
-
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    req = (xGLXVendorPrivateReq *) pc;
-    vendorCode = req->vendorCode;
-    __GLX_SWAP_INT(&vendorCode);
-
-
-    switch( vendorCode ) {
-
-       case X_GLvop_DeleteTexturesEXT:
-	  return __glXVForwardSingleReqSwap( cl, pc );
-	  break;
-
-       case X_GLXvop_SwapIntervalSGI:
-	  if (glxIsExtensionSupported("SGI_swap_control")) {
-	     return __glXVForwardSingleReqSwap( cl, pc );
-	  }
-	  else {
-	     return Success;
-	  }
-	  break;
-
-#if 0 /* glx 1.3 */
-       case X_GLXvop_CreateGLXVideoSourceSGIX:
-	  break;
-       case X_GLXvop_DestroyGLXVideoSourceSGIX:
-	  break;
-       case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
-	  break;
-       case X_GLXvop_DestroyGLXPbufferSGIX:
-	  break;
-       case X_GLXvop_ChangeDrawableAttributesSGIX:
-	  break;
-#endif
-
-       case X_GLXvop_JoinSwapGroupSGIX:
-	  return __glXSwapJoinSwapGroupSGIX( cl, pc );
-	  break;
-
-       case X_GLXvop_BindSwapBarrierSGIX:
-	  return __glXSwapBindSwapBarrierSGIX( cl, pc );
-	  break;
-
-       case X_GLXvop_CreateContextWithConfigSGIX:
-	  return __glXSwapCreateContextWithConfigSGIX( cl, pc );
-	  break;
-
-       default:
-	  /*
-	   ** unsupported private request
-	   */
-	  cl->client->errorValue = req->vendorCode;
-	  return __glXUnsupportedPrivateRequest;
-    }
-
-}
-
-int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateWithReplyReq *req;
-    CARD32 vendorCode;
-
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    req = (xGLXVendorPrivateWithReplyReq *) pc;
-    vendorCode = req->vendorCode;
-    __GLX_SWAP_INT(&vendorCode);
-
-    switch( vendorCode ) {
-
-       case X_GLvop_GetConvolutionFilterEXT:
-       case X_GLvop_GetSeparableFilterEXT:
-       case X_GLvop_GetHistogramEXT:
-       case X_GLvop_GetMinmaxEXT:
-	  return( __glXNoSuchSingleOpcode(cl, pc) );
-	  break;
-
-       case X_GLvop_GetConvolutionParameterfvEXT:
-       case X_GLvop_GetConvolutionParameterivEXT:
-       case X_GLvop_GetHistogramParameterivEXT:
-       case X_GLvop_GetMinmaxParameterfvEXT:
-       case X_GLvop_GetMinmaxParameterivEXT:
-       case X_GLvop_GenTexturesEXT:
-	  return( __glXVForwardAllWithReplySwapiv(cl, pc) );
-	  break;
-
-       case X_GLvop_AreTexturesResidentEXT:
-       case X_GLvop_IsTextureEXT:
-	  return( __glXVForwardPipe0WithReplySwap(cl, pc) );
-	  break;
-
-#if 0 /* glx1.3 */
-       case X_GLvop_GetDetailTexFuncSGIS:
-       case X_GLvop_GetSharpenTexFuncSGIS:
-       case X_GLvop_GetColorTableSGI:
-       case X_GLvop_GetColorTableParameterfvSGI:
-       case X_GLvop_GetColorTableParameterivSGI:
-       case X_GLvop_GetTexFilterFuncSGIS:
-       case X_GLvop_GetInstrumentsSGIX:
-       case X_GLvop_InstrumentsBufferSGIX:
-       case X_GLvop_PollInstrumentsSGIX:
-       case X_GLvop_FlushRasterSGIX:
-       case X_GLXvop_CreateGLXPbufferSGIX:
-       case X_GLXvop_GetDrawableAttributesSGIX:
-       case X_GLXvop_QueryHyperpipeNetworkSGIX:
-       case X_GLXvop_QueryHyperpipeConfigSGIX:
-       case X_GLXvop_HyperpipeConfigSGIX:
-       case X_GLXvop_DestroyHyperpipeConfigSGIX:
-#endif
-       case X_GLXvop_QueryMaxSwapBarriersSGIX:
-	  return( __glXSwapQueryMaxSwapBarriersSGIX(cl, pc) );
-	  break;
-
-       case X_GLXvop_GetFBConfigsSGIX:
-	  return( __glXSwapGetFBConfigsSGIX(cl, pc) );
-	  break;
-
-       case X_GLXvop_MakeCurrentReadSGI:
-	  return( __glXSwapMakeCurrentReadSGI(cl, pc) );
-	  break;
-
-       case X_GLXvop_QueryContextInfoEXT:
-	  return( __glXSwapQueryContextInfoEXT(cl,(char *)pc) );
-	  break;
-
-       default:
-	  /*
-	   ** unsupported private request
-	   */
-	  cl->client->errorValue = req->vendorCode;
-	  return __glXUnsupportedPrivateRequest;
-    }
-
-}
-
-int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->screen);
-
-    return __glXGetFBConfigs(cl, pc);
-}
-
-int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-   xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)pc;
-   xGLXGetFBConfigsReq new_req;
-
-   new_req.reqType = req->reqType;
-   new_req.glxCode = req->glxCode;
-   new_req.length = req->length;
-   new_req.screen = req->screen;
-
-   return( __glXSwapGetFBConfigs( cl, (GLbyte *)&new_req ) );
-}
-
-int __glXSwapCreateWindow(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->screen);
-    __GLX_SWAP_INT(&req->fbconfig);
-    __GLX_SWAP_INT(&req->window);
-    __GLX_SWAP_INT(&req->glxwindow);
-    __GLX_SWAP_INT(&req->numAttribs);
-
-    return( __glXCreateWindow( cl, (GLbyte *)pc ) );
-}
-
-int __glXSwapDestroyWindow(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->glxwindow);
-
-    return( __glXDestroyWindow( cl, (GLbyte *)pc ) );
-}
-
-int __glXSwapQueryContext(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXQueryContextReq *req = (xGLXQueryContextReq *)pc;
-
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->context);
-
-    return( __glXQueryContext(cl, (GLbyte *)pc) );
- 
-}
-
-int __glXSwapCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *)pc;
-    int nattr = req->numAttribs;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->screen);
-    __GLX_SWAP_INT(&req->fbconfig);
-    __GLX_SWAP_INT(&req->pbuffer);
-    __GLX_SWAP_INT(&req->numAttribs);
-    __GLX_SWAP_INT_ARRAY( (int *)(req+1), nattr*2 );
-
-    return( __glXCreatePbuffer( cl, pc ) );
-}
-
-int __glXSwapDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->pbuffer);
-
-    return( __glXDestroyPbuffer( cl, (GLbyte *)pc ) );
-}
-
-int __glXSwapGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
-{
-   xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->drawable);
-
-    return( __glXGetDrawableAttributes(cl, pc) );
-}
-
-int __glXSwapChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
-{
-   xGLXChangeDrawableAttributesReq *req = (xGLXChangeDrawableAttributesReq *)pc;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_SHORT(&req->length);
-    __GLX_SWAP_INT(&req->drawable);
-    __GLX_SWAP_INT(&req->numAttribs);
-    __GLX_SWAP_INT_ARRAY( (int *)(req+1), req->numAttribs * 2 );
-
-    return( __glXChangeDrawableAttributes(cl, pc) );
-}
+/*

+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)

+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice including the dates of first publication and

+ * either this permission notice or a reference to

+ * http://oss.sgi.com/projects/FreeB/

+ * shall be included in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * Except as contained in this notice, the name of Silicon Graphics, Inc.

+ * shall not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization from

+ * Silicon Graphics, Inc.

+ */

+

+#include "glxserver.h"

+#include "glxutil.h"

+#include <GL/glxtokens.h>

+#include <g_disptab.h>

+#include <pixmapstr.h>

+#include <windowstr.h>

+#include "unpack.h"

+#include "glxext.h"

+#include "glxvendor.h"

+

+extern int glxIsExtensionSupported( char *ext );

+

+/************************************************************************/

+

+/*

+** Byteswapping versions of GLX commands.  In most cases they just swap

+** the incoming arguments and then call the unswapped routine.  For commands

+** that have replies, a separate swapping routine for the reply is provided;

+** it is called at the end of the unswapped routine.

+*/

+

+int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->context);

+    __GLX_SWAP_INT(&req->visual);

+    __GLX_SWAP_INT(&req->screen);

+    __GLX_SWAP_INT(&req->shareList);

+

+    return __glXCreateContext(cl, pc);

+}

+

+int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->context);

+    __GLX_SWAP_INT(&req->fbconfig);

+    __GLX_SWAP_INT(&req->screen);

+    __GLX_SWAP_INT(&req->shareList);

+

+    return __glXCreateNewContext(cl, pc);

+}

+

+int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXCreateContextWithConfigSGIXReq *req = (xGLXCreateContextWithConfigSGIXReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->context);

+    __GLX_SWAP_INT(&req->fbconfig);

+    __GLX_SWAP_INT(&req->screen);

+    __GLX_SWAP_INT(&req->shareList);

+

+    return __glXCreateContextWithConfigSGIX(cl, pc);

+}

+

+int __glXSwapQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXQueryMaxSwapBarriersSGIXReq *req =

+	(xGLXQueryMaxSwapBarriersSGIXReq *)pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->screen);

+

+    return __glXQueryMaxSwapBarriersSGIX(cl, pc);

+}

+

+int __glXSwapBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *)pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->drawable);

+    __GLX_SWAP_INT(&req->barrier);

+

+    return __glXBindSwapBarrierSGIX(cl, pc);

+}

+

+int __glXSwapJoinSwapGroupSGIX(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXJoinSwapGroupSGIXReq *req = (xGLXJoinSwapGroupSGIXReq *)pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->drawable);

+    __GLX_SWAP_INT(&req->member);

+

+    return __glXJoinSwapGroupSGIX(cl, pc);

+}

+

+int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->context);

+

+    return __glXDestroyContext(cl, pc);

+}

+

+int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->drawable);

+    __GLX_SWAP_INT(&req->context);

+    __GLX_SWAP_INT(&req->oldContextTag);

+

+    return __glXMakeCurrent(cl, pc);

+}

+

+int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->drawable);

+    __GLX_SWAP_INT(&req->readdrawable);

+    __GLX_SWAP_INT(&req->context);

+    __GLX_SWAP_INT(&req->oldContextTag);

+

+    return __glXMakeContextCurrent(cl, pc);

+}

+

+int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->drawable);

+    __GLX_SWAP_INT(&req->readable);

+    __GLX_SWAP_INT(&req->context);

+    __GLX_SWAP_INT(&req->oldContextTag);

+

+    return __glXMakeCurrentReadSGI(cl, pc);

+}

+

+int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->context);

+

+    return __glXIsDirect(cl, pc);

+}

+

+int __glXSwapQueryVersion(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->majorVersion);

+    __GLX_SWAP_INT(&req->minorVersion);

+

+    return __glXQueryVersion(cl, pc);

+}

+

+int __glXSwapWaitGL(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->contextTag);

+

+    return __glXWaitGL(cl, pc);

+}

+

+int __glXSwapWaitX(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXWaitXReq *req = (xGLXWaitXReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->contextTag);

+

+    return __glXWaitX(cl, pc);

+}

+

+int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->source);

+    __GLX_SWAP_INT(&req->dest);

+    __GLX_SWAP_INT(&req->mask);

+

+    return __glXCopyContext(cl, pc);

+}

+

+int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)

+{

+   ClientPtr client = cl->client;

+    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;

+    xGLXGetVisualConfigsReply reply;

+    __GLXscreenInfo *pGlxScreen;

+    __GLXvisualConfig *pGlxVisual;

+    CARD32 buf[__GLX_TOTAL_CONFIG];

+    unsigned int screen;

+    int i, p;

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

+

+    __GLX_SWAP_INT(&req->screen);

+    screen = req->screen;

+    if (screen > screenInfo.numScreens) {

+	/* The client library must send a valid screen number. */

+	client->errorValue = screen;

+	return BadValue;

+    }

+    pGlxScreen = &__glXActiveScreens[screen];

+

+    reply.numVisuals = pGlxScreen->numGLXVisuals;

+    reply.numProps = __GLX_TOTAL_CONFIG;

+    reply.length = (pGlxScreen->numGLXVisuals * __GLX_SIZE_CARD32 *

+		    __GLX_TOTAL_CONFIG) >> 2;

+    reply.type = X_Reply;

+    reply.sequenceNumber = client->sequence;

+    

+    __GLX_SWAP_SHORT(&reply.sequenceNumber);

+    __GLX_SWAP_INT(&reply.length);

+    __GLX_SWAP_INT(&reply.numVisuals);

+    __GLX_SWAP_INT(&reply.numProps);

+    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);

+

+    for (i=0; i < pGlxScreen->numVisuals; i++) {

+	pGlxVisual = &pGlxScreen->pGlxVisual[i];

+	if (!pGlxScreen->isGLXvis[i] || pGlxVisual->vid == 0) {

+	    /* not a usable visual */

+	    continue;

+	}

+	p = 0;

+	buf[p++] = pGlxVisual->vid;

+	buf[p++] = pGlxVisual->class;

+	buf[p++] = pGlxVisual->rgba;

+

+	buf[p++] = pGlxVisual->redSize;

+	buf[p++] = pGlxVisual->greenSize;

+	buf[p++] = pGlxVisual->blueSize;

+	buf[p++] = pGlxVisual->alphaSize;

+	buf[p++] = pGlxVisual->accumRedSize;

+	buf[p++] = pGlxVisual->accumGreenSize;

+	buf[p++] = pGlxVisual->accumBlueSize;

+	buf[p++] = pGlxVisual->accumAlphaSize;

+

+	buf[p++] = pGlxVisual->doubleBuffer;

+	buf[p++] = pGlxVisual->stereo;

+

+	buf[p++] = pGlxVisual->bufferSize;

+	buf[p++] = pGlxVisual->depthSize;

+	buf[p++] = pGlxVisual->stencilSize;

+	buf[p++] = pGlxVisual->auxBuffers;

+	buf[p++] = pGlxVisual->level;

+        /*

+        ** Add token/value pairs for extensions.

+        */

+        buf[p++] = GLX_VISUAL_CAVEAT_EXT;

+        buf[p++] = pGlxVisual->visualRating;

+        buf[p++] = GLX_TRANSPARENT_TYPE_EXT;

+        buf[p++] = pGlxVisual->transparentPixel;

+        buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;

+        buf[p++] = pGlxVisual->transparentRed;

+        buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;

+        buf[p++] = pGlxVisual->transparentGreen;

+        buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;

+        buf[p++] = pGlxVisual->transparentBlue;

+        buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;

+        buf[p++] = pGlxVisual->transparentAlpha;

+        buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;

+        buf[p++] = pGlxVisual->transparentIndex;

+

+	__GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);

+	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 

+			(char *)buf);

+    }

+    return Success;

+}

+

+int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->screen);

+    __GLX_SWAP_INT(&req->visual);

+    __GLX_SWAP_INT(&req->pixmap);

+    __GLX_SWAP_INT(&req->glxpixmap);

+

+    return __glXCreateGLXPixmap(cl, pc);

+}

+

+int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->screen);

+    __GLX_SWAP_INT(&req->fbconfig);

+    __GLX_SWAP_INT(&req->pixmap);

+    __GLX_SWAP_INT(&req->glxpixmap);

+    __GLX_SWAP_INT(&req->numAttribs);

+

+    return __glXCreatePixmap(cl, pc);

+}

+

+int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->glxpixmap);

+

+    return __glXDestroyGLXPixmap(cl, pc);

+}

+

+int __glXSwapSwapBuffers(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->contextTag);

+    __GLX_SWAP_INT(&req->drawable);

+

+    return __glXSwapBuffers(cl, pc);

+}

+

+int __glXSwapUseXFont(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->contextTag);

+    __GLX_SWAP_INT(&req->font);

+    __GLX_SWAP_INT(&req->first);

+    __GLX_SWAP_INT(&req->count);

+    __GLX_SWAP_INT(&req->listBase);

+

+    return __glXUseXFont(cl, pc);

+}

+

+

+int __glXSwapQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXQueryExtensionsStringReq *req = NULL;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->screen);

+

+    return __glXQueryExtensionsString(cl, pc);

+}

+

+int __glXSwapQueryServerString(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *)pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->screen);

+    __GLX_SWAP_INT(&req->name);

+

+    return __glXQueryServerString(cl, pc);

+}

+

+int __glXSwapClientInfo(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXClientInfoReq *req = (xGLXClientInfoReq *)pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->major);

+    __GLX_SWAP_INT(&req->minor);

+    __GLX_SWAP_INT(&req->numbytes);

+

+    return __glXClientInfo(cl, pc);

+}

+

+int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, char *pc)

+{

+    xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->context);

+

+    return __glXQueryContextInfoEXT(cl, (GLbyte *)pc);

+}

+

+/************************************************************************/

+

+/*

+** Swap replies.

+*/

+

+void __glXSwapMakeCurrentReply(ClientPtr client,  xGLXMakeCurrentReadSGIReply *reply)

+{

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_SWAP_SHORT(&reply->sequenceNumber);

+    __GLX_SWAP_INT(&reply->length);

+    __GLX_SWAP_INT(&reply->contextTag);

+    __GLX_SWAP_INT(&reply->writeVid);

+    __GLX_SWAP_INT(&reply->writeType);

+    __GLX_SWAP_INT(&reply->readVid);

+    __GLX_SWAP_INT(&reply->readType);

+    WriteToClient(client, sz_xGLXMakeCurrentReadSGIReply, (char *)reply);

+}

+

+void __glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply *reply)

+{

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_SWAP_SHORT(&reply->sequenceNumber);

+    __GLX_SWAP_INT(&reply->length);

+    WriteToClient(client, sz_xGLXIsDirectReply, (char *)reply);

+}

+

+void __glXSwapQueryVersionReply(ClientPtr client, xGLXQueryVersionReply *reply)

+{

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_SWAP_SHORT(&reply->sequenceNumber);

+    __GLX_SWAP_INT(&reply->length);

+    __GLX_SWAP_INT(&reply->majorVersion);

+    __GLX_SWAP_INT(&reply->minorVersion);

+    WriteToClient(client, sz_xGLXQueryVersionReply, (char *)reply);

+}

+

+void glxSwapQueryExtensionsStringReply(ClientPtr client,

+				       xGLXQueryExtensionsStringReply *reply, char *buf)

+{

+    int length = reply->length;

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

+    __GLX_SWAP_SHORT(&reply->sequenceNumber);

+    __GLX_SWAP_INT(&reply->length);

+    __GLX_SWAP_INT(&reply->n);

+    WriteToClient(client, sz_xGLXQueryExtensionsStringReply, (char *)reply);

+    __GLX_SWAP_INT_ARRAY((int *)buf, length);

+    WriteToClient(client, length << 2, buf);

+}

+

+void glxSwapQueryServerStringReply(ClientPtr client,

+				   xGLXQueryServerStringReply *reply, char *buf)

+{

+    int length = reply->length;

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_SWAP_SHORT(&reply->sequenceNumber);

+    __GLX_SWAP_INT(&reply->length);

+    __GLX_SWAP_INT(&reply->n);

+    WriteToClient(client, sz_xGLXQueryServerStringReply, (char *)reply);

+    /** no swap is needed for an array of chars **/

+    /* __GLX_SWAP_INT_ARRAY((int *)buf, length); */

+    WriteToClient(client, length << 2, buf);

+}

+

+void __glXSwapQueryContextInfoEXTReply(ClientPtr client, xGLXQueryContextInfoEXTReply *reply, int *buf)

+{

+    int length = reply->length;

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

+    __GLX_SWAP_SHORT(&reply->sequenceNumber);

+    __GLX_SWAP_INT(&reply->length);

+    __GLX_SWAP_INT(&reply->n);

+    WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)reply);

+    __GLX_SWAP_INT_ARRAY((int *)buf, length);

+    WriteToClient(client, length << 2, (char *)buf);

+}

+

+

+void __glXSwapQueryContextReply(ClientPtr client,

+                                xGLXQueryContextReply *reply, int *buf)

+{

+    int length = reply->length;

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

+    __GLX_SWAP_SHORT(&reply->sequenceNumber);

+    __GLX_SWAP_INT(&reply->length);

+    __GLX_SWAP_INT(&reply->n);

+    WriteToClient(client, sz_xGLXQueryContextReply, (char *)reply);

+    __GLX_SWAP_INT_ARRAY((int *)buf, length);

+    WriteToClient(client, length << 2, (char *)buf);

+}

+

+void __glXSwapGetDrawableAttributesReply(ClientPtr client,

+                                 xGLXGetDrawableAttributesReply *reply, int *buf) 

+{

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

+    __GLX_SWAP_SHORT(&reply->sequenceNumber);

+    __GLX_SWAP_INT(&reply->length);

+    __GLX_SWAP_INT(&reply->numAttribs);

+    __GLX_SWAP_INT_ARRAY( buf, reply->length );

+    WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *)reply);

+    WriteToClient(client, reply->length << 2, (char *)buf);

+}

+

+void __glXSwapQueryMaxSwapBarriersSGIXReply(ClientPtr client, xGLXQueryMaxSwapBarriersSGIXReply *reply)

+{

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_SWAP_SHORT(&reply->sequenceNumber);

+    __GLX_SWAP_INT(&reply->length);

+    __GLX_SWAP_INT(&reply->max);

+    WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply, (char *)reply);

+}

+

+/************************************************************************/

+

+/*

+** Render and Renderlarge are not in the GLX API.  They are used by the GLX

+** client library to send batches of GL rendering commands.

+*/

+

+int __glXSwapRender(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXRenderReq *req;

+    int left;

+    __GLXrenderHeader *hdr;

+    ClientPtr client = cl->client;

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

+

+    /*

+    ** NOTE: much of this code also appears in the nonswapping version of this

+    ** routine, __glXRender().  Any changes made here should also be

+    ** duplicated there.

+    */

+    

+    req = (xGLXRenderReq *) pc;

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->contextTag);

+

+    pc += sz_xGLXRenderReq;

+    left = (req->length << 2) - sz_xGLXRenderReq;

+    while (left > 0) {

+	void (* proc)(GLbyte *);

+	CARD16 opcode;

+

+	/*

+	** Verify that the header length and the overall length agree.

+	** Also, each command must be word aligned.

+	*/

+	hdr = (__GLXrenderHeader *) pc;

+	__GLX_SWAP_SHORT(&hdr->length);

+	__GLX_SWAP_SHORT(&hdr->opcode);

+

+	/*

+         * call the command procedure to swap any arguments

+	 */

+	opcode = hdr->opcode;

+	if ( (opcode >= __GLX_MIN_RENDER_OPCODE) && 

+	     (opcode <= __GLX_MAX_RENDER_OPCODE) ) {

+	    proc = __glXSwapRenderTable[opcode];

+#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT

+	} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) && 

+	     (opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {

+	    int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;

+	    __GLXRenderSwapInfo *info = &__glXSwapRenderTable_EXT[index];

+	    if (info->swapfunc) {

+	       proc = info->swapfunc;

+	    }

+	    else {

+	       proc = NULL;

+	       if (info->elem_size == 4 && info->nelems > 0) {

+		  __GLX_SWAP_INT_ARRAY( (int *)(pc + __GLX_RENDER_HDR_SIZE), 

+			                info->nelems );

+	       }

+	       else if (info->elem_size == 2 && info->nelems > 0) {

+		  __GLX_SWAP_SHORT_ARRAY( (short *)(pc + __GLX_RENDER_HDR_SIZE), 

+			                info->nelems );

+	       }

+	       else if (info->elem_size == 8 && info->nelems > 0) {

+		  __GLX_SWAP_DOUBLE_ARRAY( (double *)(pc + __GLX_RENDER_HDR_SIZE), 

+			                info->nelems );

+	       }

+	    }

+#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */

+	} else {

+	    client->errorValue = 0;

+	    return __glXBadRenderRequest;

+	}

+

+	if (proc != NULL) 

+	   (*proc)(pc + __GLX_RENDER_HDR_SIZE);

+

+	/*

+	 * proceed to the next command

+	 */ 

+	pc += hdr->length;

+	left -= hdr->length;

+    }

+

+    return __glXRender( cl, (GLbyte *)req );

+}

+

+/*

+** Execute a large rendering request (one that spans multiple X requests).

+*/

+int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)

+{

+   ClientPtr client = cl->client;

+    xGLXRenderLargeReq *req;

+    __GLXrenderLargeHeader *hdr;

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

+

+    req = (xGLXRenderLargeReq *) pc;

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->contextTag);

+    __GLX_SWAP_INT(&req->dataBytes);

+    __GLX_SWAP_SHORT(&req->requestNumber);

+    __GLX_SWAP_SHORT(&req->requestTotal);

+

+    pc += sz_xGLXRenderLargeReq;

+   

+    if (req->requestNumber == 1) {

+	void (* proc)(GLbyte *) = NULL;

+	__GLXRenderSwapInfo *info = NULL;

+	CARD16 opcode;

+

+	hdr = (__GLXrenderLargeHeader *) pc;

+	__GLX_SWAP_INT(&hdr->length);

+	__GLX_SWAP_INT(&hdr->opcode);

+

+	/*

+         * call the command procedure to swap any arguments

+	 * Note that we are assuming that all arguments that needs to be

+	 * swaped are on the first req only !

+	 */

+	opcode = hdr->opcode;

+	if ( (opcode >= __GLX_MIN_RENDER_OPCODE) && 

+	     (opcode <= __GLX_MAX_RENDER_OPCODE) ) {

+	    proc = __glXSwapRenderTable[opcode];

+#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT

+	} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) && 

+	     (opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {

+	    int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;

+	    info = &__glXSwapRenderTable_EXT[index];

+	    if (info->swapfunc) {

+	       proc = info->swapfunc;

+	    }

+#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */

+	} else {

+	    client->errorValue = 0;

+	    cl->largeCmdRequestsTotal = 0;

+	    return __glXBadLargeRequest;

+	}

+

+	/*

+	** Make enough space in the buffer, then copy the entire request.

+	*/

+	if (cl->largeCmdBufSize < hdr->length) {

+	    if (!cl->largeCmdBuf) {

+		cl->largeCmdBuf = (GLbyte *) __glXMalloc(hdr->length);

+	    } else {

+		cl->largeCmdBuf = (GLbyte *) __glXRealloc(cl->largeCmdBuf, hdr->length);

+	    }

+	    if (!cl->largeCmdBuf) {

+	       cl->largeCmdRequestsTotal = 0;

+		return BadAlloc;

+	    }

+	    cl->largeCmdBufSize = hdr->length;

+	}

+	memcpy(cl->largeCmdBuf, pc, req->dataBytes);

+

+	cl->largeCmdBytesSoFar = req->dataBytes;

+	cl->largeCmdBytesTotal = hdr->length;

+	cl->largeCmdRequestsSoFar = 1;

+	cl->largeCmdRequestsTotal = req->requestTotal;

+	cl->largeCmdRequestsSwapProc = proc;

+	cl->largeCmdMaxReqDataSize = req->dataBytes;

+	cl->largeCmdRequestsSwap_info = info;

+

+	return Success;

+	

+

+    }

+    else if (req->requestNumber < cl->largeCmdRequestsTotal) {

+       /*

+        * This is not the first nor last request - just copy the data

+	*/

+       if (  cl->largeCmdBytesSoFar + req->dataBytes > cl->largeCmdBytesTotal) {

+	    cl->largeCmdRequestsTotal = 0;

+	    return __glXBadLargeRequest;

+       }

+

+       memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, 

+	           pc, req->dataBytes);

+

+       cl->largeCmdBytesSoFar += req->dataBytes;

+

+       if (req->dataBytes > cl->largeCmdMaxReqDataSize)

+	  cl->largeCmdMaxReqDataSize = req->dataBytes;

+

+	return Success;

+    }

+    else if (req->requestNumber == cl->largeCmdRequestsTotal) {

+       /*

+        * this is the last request

+        * copy the remainder bytes, call the procedure to swap any

+	* needed data, and then call to transfer the command to all

+	* back-end servers

+	*/

+       if (  cl->largeCmdBytesSoFar + req->dataBytes > cl->largeCmdBytesTotal) {

+	    cl->largeCmdRequestsTotal = 0;

+	    return __glXBadLargeRequest;

+       }

+

+       memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, 

+	           pc, req->dataBytes);

+

+       cl->largeCmdBytesSoFar += req->dataBytes;

+

+       if (req->dataBytes > cl->largeCmdMaxReqDataSize)

+	  cl->largeCmdMaxReqDataSize = req->dataBytes;

+

+	if (cl->largeCmdRequestsSwapProc != NULL) {

+	   (*cl->largeCmdRequestsSwapProc)(cl->largeCmdBuf + __GLX_RENDER_LARGE_HDR_SIZE);

+	}

+	else if (cl->largeCmdRequestsSwap_info &&

+	         cl->largeCmdRequestsSwap_info->nelems > 0) {

+    	   if (cl->largeCmdRequestsSwap_info->elem_size == 4) {

+	      __GLX_SWAP_INT_ARRAY( (int *)(pc + __GLX_RENDER_LARGE_HDR_SIZE), 

+		       cl->largeCmdRequestsSwap_info->nelems );

+	   }

+	   else if (cl->largeCmdRequestsSwap_info->elem_size == 2) {

+	      __GLX_SWAP_SHORT_ARRAY( (short *)(pc + __GLX_RENDER_LARGE_HDR_SIZE), 

+		       cl->largeCmdRequestsSwap_info->nelems );

+	   }

+	   else if (cl->largeCmdRequestsSwap_info->elem_size == 8) {

+	      __GLX_SWAP_DOUBLE_ARRAY( (double *)(pc + __GLX_RENDER_LARGE_HDR_SIZE), 

+		       cl->largeCmdRequestsSwap_info->nelems );

+	   }

+	}

+

+	cl->largeCmdRequestsTotal = 0;

+        return( __glXSendLargeCommand(cl, req->contextTag) );

+

+    }

+    else {

+       cl->largeCmdRequestsTotal = 0;

+       return __glXBadLargeRequest;

+    }

+

+}

+

+/************************************************************************/

+

+/*

+** No support is provided for the vendor-private requests other than

+** allocating these entry points in the dispatch table.

+*/

+

+int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXVendorPrivateReq *req;

+    CARD32 vendorCode;

+

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    req = (xGLXVendorPrivateReq *) pc;

+    vendorCode = req->vendorCode;

+    __GLX_SWAP_INT(&vendorCode);

+

+

+    switch( vendorCode ) {

+

+       case X_GLvop_DeleteTexturesEXT:

+	  return __glXVForwardSingleReqSwap( cl, pc );

+	  break;

+

+       case X_GLXvop_SwapIntervalSGI:

+	  if (glxIsExtensionSupported("SGI_swap_control")) {

+	     return __glXVForwardSingleReqSwap( cl, pc );

+	  }

+	  else {

+	     return Success;

+	  }

+	  break;

+

+#if 0 /* glx 1.3 */

+       case X_GLXvop_CreateGLXVideoSourceSGIX:

+	  break;

+       case X_GLXvop_DestroyGLXVideoSourceSGIX:

+	  break;

+       case X_GLXvop_CreateGLXPixmapWithConfigSGIX:

+	  break;

+       case X_GLXvop_DestroyGLXPbufferSGIX:

+	  break;

+       case X_GLXvop_ChangeDrawableAttributesSGIX:

+	  break;

+#endif

+

+       case X_GLXvop_JoinSwapGroupSGIX:

+	  return __glXSwapJoinSwapGroupSGIX( cl, pc );

+	  break;

+

+       case X_GLXvop_BindSwapBarrierSGIX:

+	  return __glXSwapBindSwapBarrierSGIX( cl, pc );

+	  break;

+

+       case X_GLXvop_CreateContextWithConfigSGIX:

+	  return __glXSwapCreateContextWithConfigSGIX( cl, pc );

+	  break;

+

+       default:

+	  /*

+	   ** unsupported private request

+	   */

+	  cl->client->errorValue = req->vendorCode;

+	  return __glXUnsupportedPrivateRequest;

+    }

+

+}

+

+int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXVendorPrivateWithReplyReq *req;

+    CARD32 vendorCode;

+

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    req = (xGLXVendorPrivateWithReplyReq *) pc;

+    vendorCode = req->vendorCode;

+    __GLX_SWAP_INT(&vendorCode);

+

+    switch( vendorCode ) {

+

+       case X_GLvop_GetConvolutionFilterEXT:

+       case X_GLvop_GetSeparableFilterEXT:

+       case X_GLvop_GetHistogramEXT:

+       case X_GLvop_GetMinmaxEXT:

+	  return( __glXNoSuchSingleOpcode(cl, pc) );

+	  break;

+

+       case X_GLvop_GetConvolutionParameterfvEXT:

+       case X_GLvop_GetConvolutionParameterivEXT:

+       case X_GLvop_GetHistogramParameterivEXT:

+       case X_GLvop_GetMinmaxParameterfvEXT:

+       case X_GLvop_GetMinmaxParameterivEXT:

+       case X_GLvop_GenTexturesEXT:

+	  return( __glXVForwardAllWithReplySwapiv(cl, pc) );

+	  break;

+

+       case X_GLvop_AreTexturesResidentEXT:

+       case X_GLvop_IsTextureEXT:

+	  return( __glXVForwardPipe0WithReplySwap(cl, pc) );

+	  break;

+

+#if 0 /* glx1.3 */

+       case X_GLvop_GetDetailTexFuncSGIS:

+       case X_GLvop_GetSharpenTexFuncSGIS:

+       case X_GLvop_GetColorTableSGI:

+       case X_GLvop_GetColorTableParameterfvSGI:

+       case X_GLvop_GetColorTableParameterivSGI:

+       case X_GLvop_GetTexFilterFuncSGIS:

+       case X_GLvop_GetInstrumentsSGIX:

+       case X_GLvop_InstrumentsBufferSGIX:

+       case X_GLvop_PollInstrumentsSGIX:

+       case X_GLvop_FlushRasterSGIX:

+       case X_GLXvop_CreateGLXPbufferSGIX:

+       case X_GLXvop_GetDrawableAttributesSGIX:

+       case X_GLXvop_QueryHyperpipeNetworkSGIX:

+       case X_GLXvop_QueryHyperpipeConfigSGIX:

+       case X_GLXvop_HyperpipeConfigSGIX:

+       case X_GLXvop_DestroyHyperpipeConfigSGIX:

+#endif

+       case X_GLXvop_QueryMaxSwapBarriersSGIX:

+	  return( __glXSwapQueryMaxSwapBarriersSGIX(cl, pc) );

+	  break;

+

+       case X_GLXvop_GetFBConfigsSGIX:

+	  return( __glXSwapGetFBConfigsSGIX(cl, pc) );

+	  break;

+

+       case X_GLXvop_MakeCurrentReadSGI:

+	  return( __glXSwapMakeCurrentReadSGI(cl, pc) );

+	  break;

+

+       case X_GLXvop_QueryContextInfoEXT:

+	  return( __glXSwapQueryContextInfoEXT(cl,(char *)pc) );

+	  break;

+

+       default:

+	  /*

+	   ** unsupported private request

+	   */

+	  cl->client->errorValue = req->vendorCode;

+	  return __glXUnsupportedPrivateRequest;

+    }

+

+}

+

+int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->screen);

+

+    return __glXGetFBConfigs(cl, pc);

+}

+

+int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)

+{

+   xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)pc;

+   xGLXGetFBConfigsReq new_req;

+

+   new_req.reqType = req->reqType;

+   new_req.glxCode = req->glxCode;

+   new_req.length = req->length;

+   new_req.screen = req->screen;

+

+   return( __glXSwapGetFBConfigs( cl, (GLbyte *)&new_req ) );

+}

+

+int __glXSwapCreateWindow(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->screen);

+    __GLX_SWAP_INT(&req->fbconfig);

+    __GLX_SWAP_INT(&req->window);

+    __GLX_SWAP_INT(&req->glxwindow);

+    __GLX_SWAP_INT(&req->numAttribs);

+

+    return( __glXCreateWindow( cl, (GLbyte *)pc ) );

+}

+

+int __glXSwapDestroyWindow(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->glxwindow);

+

+    return( __glXDestroyWindow( cl, (GLbyte *)pc ) );

+}

+

+int __glXSwapQueryContext(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXQueryContextReq *req = (xGLXQueryContextReq *)pc;

+

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->context);

+

+    return( __glXQueryContext(cl, (GLbyte *)pc) );

+ 

+}

+

+int __glXSwapCreatePbuffer(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *)pc;

+    int nattr = req->numAttribs;

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->screen);

+    __GLX_SWAP_INT(&req->fbconfig);

+    __GLX_SWAP_INT(&req->pbuffer);

+    __GLX_SWAP_INT(&req->numAttribs);

+    __GLX_SWAP_INT_ARRAY( (int *)(req+1), nattr*2 );

+

+    return( __glXCreatePbuffer( cl, pc ) );

+}

+

+int __glXSwapDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)

+{

+    xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->pbuffer);

+

+    return( __glXDestroyPbuffer( cl, (GLbyte *)pc ) );

+}

+

+int __glXSwapGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)

+{

+   xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->drawable);

+

+    return( __glXGetDrawableAttributes(cl, pc) );

+}

+

+int __glXSwapChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)

+{

+   xGLXChangeDrawableAttributesReq *req = (xGLXChangeDrawableAttributesReq *)pc;

+    __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

+

+    __GLX_SWAP_SHORT(&req->length);

+    __GLX_SWAP_INT(&req->drawable);

+    __GLX_SWAP_INT(&req->numAttribs);

+    __GLX_SWAP_INT_ARRAY( (int *)(req+1), req->numAttribs * 2 );

+

+    return( __glXChangeDrawableAttributes(cl, pc) );

+}

diff --git a/xorg-server/hw/dmx/glxProxy/glxfbconfig.c b/xorg-server/hw/dmx/glxProxy/glxfbconfig.c
index c721fdd24..3611cf61e 100644
--- a/xorg-server/hw/dmx/glxProxy/glxfbconfig.c
+++ b/xorg-server/hw/dmx/glxProxy/glxfbconfig.c
@@ -1,106 +1,106 @@
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#include "glxfbconfig.h"
-
-int AreFBConfigsMatch( __GLXFBConfig *c1, __GLXFBConfig *c2 )
-{
-   int match;
-
-   match = (
-	     (c1->visualType == c2->visualType) &&
-	     (c1->transparentType == c2->transparentType) &&
-	     (c1->transparentRed == c2->transparentRed) &&
-	     (c1->transparentGreen == c2->transparentGreen) &&
-	     (c1->transparentBlue == c2->transparentBlue) &&
-	     (c1->transparentAlpha == c2->transparentAlpha) &&
-	     (c1->transparentIndex == c2->transparentIndex) &&
-	     (c1->visualCaveat == c2->visualCaveat) &&
-	     (c1->drawableType == c2->drawableType) &&
-	     (c1->renderType == c2->renderType) &&
-#if 0	     
-	     (c1->maxPbufferWidth == c2->maxPbufferWidth) &&
-	     (c1->maxPbufferHeight == c2->maxPbufferHeight) &&
-	     (c1->maxPbufferPixels == c2->maxPbufferPixels) &&
-	     (c1->optimalPbufferWidth == c2->optimalPbufferWidth) &&
-	     (c1->optimalPbufferHeight == c2->optimalPbufferHeight) &&
-#endif
-	     (c1->visualSelectGroup == c2->visualSelectGroup) &&
-	     (c1->rgbMode == c2->rgbMode) &&
-	     (c1->colorIndexMode == c2->colorIndexMode) &&
-	     (c1->doubleBufferMode == c2->doubleBufferMode) &&
-	     (c1->stereoMode == c2->stereoMode) &&
-	     (c1->haveAccumBuffer == c2->haveAccumBuffer) &&
-	     (c1->haveDepthBuffer == c2->haveDepthBuffer) &&
-	     (c1->haveStencilBuffer == c2->haveStencilBuffer) &&
-	     (c1->accumRedBits == c2->accumRedBits) &&
-	     (c1->accumGreenBits == c2->accumGreenBits) &&
-	     (c1->accumBlueBits == c2->accumBlueBits) &&
-	     (c1->accumAlphaBits == c2->accumAlphaBits) &&
-	     (c1->depthBits == c2->depthBits) &&
-	     (c1->stencilBits == c2->stencilBits) &&
-	     (c1->indexBits == c2->indexBits) &&
-	     (c1->redBits == c2->redBits) &&
-	     (c1->greenBits == c2->greenBits) &&
-	     (c1->blueBits == c2->blueBits) &&
-	     (c1->alphaBits == c2->alphaBits) &&
-	     (c1->redMask == c2->redMask) &&
-	     (c1->greenMask == c2->greenMask) &&
-	     (c1->blueMask == c2->blueMask) &&
-	     (c1->alphaMask == c2->alphaMask) &&
-	     (c1->multiSampleSize == c2->multiSampleSize) &&
-	     (c1->nMultiSampleBuffers == c2->nMultiSampleBuffers) &&
-	     (c1->maxAuxBuffers == c2->maxAuxBuffers) &&
-	     (c1->level == c2->level) &&
-	     (c1->extendedRange == c2->extendedRange) &&
-	     (c1->minRed == c2->minRed) &&
-	     (c1->maxRed == c2->maxRed) &&
-	     (c1->minGreen == c2->minGreen) &&
-	     (c1->maxGreen == c2->maxGreen) &&
-	     (c1->minBlue == c2->minBlue) &&
-	     (c1->maxBlue == c2->maxBlue) &&
-	     (c1->minAlpha == c2->minAlpha) &&
-	     (c1->maxAlpha == c2->maxAlpha) 
-	   );
-
-   return( match );
-}
-
-__GLXFBConfig *FindMatchingFBConfig( __GLXFBConfig *c, __GLXFBConfig *configs, int nconfigs )
-{
-   int i;
-
-   for (i=0; i<nconfigs; i++) {
-      if ( AreFBConfigsMatch( c, configs + i ) ) 
-	 return( configs + i );
-   }
-
-   return(0);
-}
+/*

+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)

+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice including the dates of first publication and

+ * either this permission notice or a reference to

+ * http://oss.sgi.com/projects/FreeB/

+ * shall be included in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * Except as contained in this notice, the name of Silicon Graphics, Inc.

+ * shall not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization from

+ * Silicon Graphics, Inc.

+ */

+

+#include "glxfbconfig.h"

+

+int AreFBConfigsMatch( __GLXFBConfig *c1, __GLXFBConfig *c2 )

+{

+   int match;

+

+   match = (

+	     (c1->visualType == c2->visualType) &&

+	     (c1->transparentType == c2->transparentType) &&

+	     (c1->transparentRed == c2->transparentRed) &&

+	     (c1->transparentGreen == c2->transparentGreen) &&

+	     (c1->transparentBlue == c2->transparentBlue) &&

+	     (c1->transparentAlpha == c2->transparentAlpha) &&

+	     (c1->transparentIndex == c2->transparentIndex) &&

+	     (c1->visualCaveat == c2->visualCaveat) &&

+	     (c1->drawableType == c2->drawableType) &&

+	     (c1->renderType == c2->renderType) &&

+#if 0	     

+	     (c1->maxPbufferWidth == c2->maxPbufferWidth) &&

+	     (c1->maxPbufferHeight == c2->maxPbufferHeight) &&

+	     (c1->maxPbufferPixels == c2->maxPbufferPixels) &&

+	     (c1->optimalPbufferWidth == c2->optimalPbufferWidth) &&

+	     (c1->optimalPbufferHeight == c2->optimalPbufferHeight) &&

+#endif

+	     (c1->visualSelectGroup == c2->visualSelectGroup) &&

+	     (c1->rgbMode == c2->rgbMode) &&

+	     (c1->colorIndexMode == c2->colorIndexMode) &&

+	     (c1->doubleBufferMode == c2->doubleBufferMode) &&

+	     (c1->stereoMode == c2->stereoMode) &&

+	     (c1->haveAccumBuffer == c2->haveAccumBuffer) &&

+	     (c1->haveDepthBuffer == c2->haveDepthBuffer) &&

+	     (c1->haveStencilBuffer == c2->haveStencilBuffer) &&

+	     (c1->accumRedBits == c2->accumRedBits) &&

+	     (c1->accumGreenBits == c2->accumGreenBits) &&

+	     (c1->accumBlueBits == c2->accumBlueBits) &&

+	     (c1->accumAlphaBits == c2->accumAlphaBits) &&

+	     (c1->depthBits == c2->depthBits) &&

+	     (c1->stencilBits == c2->stencilBits) &&

+	     (c1->indexBits == c2->indexBits) &&

+	     (c1->redBits == c2->redBits) &&

+	     (c1->greenBits == c2->greenBits) &&

+	     (c1->blueBits == c2->blueBits) &&

+	     (c1->alphaBits == c2->alphaBits) &&

+	     (c1->redMask == c2->redMask) &&

+	     (c1->greenMask == c2->greenMask) &&

+	     (c1->blueMask == c2->blueMask) &&

+	     (c1->alphaMask == c2->alphaMask) &&

+	     (c1->multiSampleSize == c2->multiSampleSize) &&

+	     (c1->nMultiSampleBuffers == c2->nMultiSampleBuffers) &&

+	     (c1->maxAuxBuffers == c2->maxAuxBuffers) &&

+	     (c1->level == c2->level) &&

+	     (c1->extendedRange == c2->extendedRange) &&

+	     (c1->minRed == c2->minRed) &&

+	     (c1->maxRed == c2->maxRed) &&

+	     (c1->minGreen == c2->minGreen) &&

+	     (c1->maxGreen == c2->maxGreen) &&

+	     (c1->minBlue == c2->minBlue) &&

+	     (c1->maxBlue == c2->maxBlue) &&

+	     (c1->minAlpha == c2->minAlpha) &&

+	     (c1->maxAlpha == c2->maxAlpha) 

+	   );

+

+   return match;

+}

+

+__GLXFBConfig *FindMatchingFBConfig( __GLXFBConfig *c, __GLXFBConfig *configs, int nconfigs )

+{

+   int i;

+

+   for (i=0; i<nconfigs; i++) {

+      if ( AreFBConfigsMatch( c, configs + i ) ) 

+	 return configs + i;

+   }

+

+   return 0;

+}

diff --git a/xorg-server/hw/dmx/glxProxy/glxscreens.c b/xorg-server/hw/dmx/glxProxy/glxscreens.c
index 8cf7b281c..6425a2bfe 100644
--- a/xorg-server/hw/dmx/glxProxy/glxscreens.c
+++ b/xorg-server/hw/dmx/glxProxy/glxscreens.c
@@ -327,7 +327,7 @@ char *__glXGetServerString( unsigned int name )
 	 break;

    }

 

-   return( ret );

+   return ret;

 

 }

 

@@ -338,10 +338,10 @@ __GLXFBConfig *glxLookupFBConfig( GLXFBConfigID id )
 

    for (i=0, j=0; i<__glXNumFBConfigs; i++,j+=(__glXNumActiveScreens+1) ) {

       if ( __glXFBConfigs[j]->id == id) 

-	 return( __glXFBConfigs[j] );

+	 return __glXFBConfigs[j];

    }

 

-   return(NULL);

+   return NULL;

 }

 

 __GLXFBConfig *glxLookupFBConfigByVID( VisualID vid )

@@ -350,10 +350,10 @@ __GLXFBConfig *glxLookupFBConfigByVID( VisualID vid )
 

    for (i=0, j=0; i<__glXNumFBConfigs; i++,j+=(__glXNumActiveScreens+1) ) {

       if ( __glXFBConfigs[j]->associatedVisualId == vid) 

-	 return( __glXFBConfigs[j] );

+	 return __glXFBConfigs[j];

    }

 

-   return(NULL);

+   return NULL;

 }

 

 __GLXFBConfig *glxLookupBackEndFBConfig( GLXFBConfigID id, int screen )

@@ -363,10 +363,10 @@ __GLXFBConfig *glxLookupBackEndFBConfig( GLXFBConfigID id, int screen )
 

    for (i=0, j=0; i<__glXNumFBConfigs; i++,j+=(__glXNumActiveScreens+1) ) {

       if ( __glXFBConfigs[j]->id == id) 

-	 return( __glXFBConfigs[j+screen+1] );

+	 return __glXFBConfigs[j+screen+1];

    }

 

-   return(NULL);

+   return NULL;

 

 }

 

diff --git a/xorg-server/hw/dmx/glxProxy/glxsingle.c b/xorg-server/hw/dmx/glxProxy/glxsingle.c
index 8325b4afc..056c74066 100644
--- a/xorg-server/hw/dmx/glxProxy/glxsingle.c
+++ b/xorg-server/hw/dmx/glxProxy/glxsingle.c
@@ -397,6 +397,7 @@ int __glXForwardSingleReqSwap( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXSingleReq *req = (xGLXSingleReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->contextTag);

@@ -420,6 +421,7 @@ int __glXForwardPipe0WithReplySwap( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXSingleReq *req = (xGLXSingleReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->contextTag);

@@ -443,6 +445,7 @@ int __glXForwardPipe0WithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXSingleReq *req = (xGLXSingleReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->contextTag);

@@ -467,6 +470,7 @@ int __glXForwardPipe0WithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXSingleReq *req = (xGLXSingleReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->contextTag);

@@ -491,6 +495,7 @@ int __glXForwardPipe0WithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXSingleReq *req = (xGLXSingleReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->contextTag);

@@ -515,6 +520,7 @@ int __glXForwardAllWithReplySwap( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXSingleReq *req = (xGLXSingleReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->contextTag);

@@ -539,6 +545,7 @@ int __glXForwardAllWithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXSingleReq *req = (xGLXSingleReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->contextTag);

@@ -563,6 +570,7 @@ int __glXForwardAllWithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXSingleReq *req = (xGLXSingleReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->contextTag);

@@ -587,6 +595,7 @@ int __glXForwardAllWithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXSingleReq *req = (xGLXSingleReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->contextTag);

@@ -659,7 +668,7 @@ static GLint __glReadPixels_size(GLenum format, GLenum type, GLint w, GLint h,
 	   }

 	   if (elementbits_return) *elementbits_return = elements;

 	   if (rowbytes_return) *rowbytes_return = rowsize;

-	   return (rowsize * h);

+	   return rowsize * h;

 	} else {

 	   return -1;

 	}

@@ -709,7 +718,7 @@ static GLint __glReadPixels_size(GLenum format, GLenum type, GLint w, GLint h,
     if (elementbits_return) *elementbits_return = esize*elements*8;

     if (rowbytes_return) *rowbytes_return = rowsize;

 

-    return (rowsize * h);

+    return rowsize * h;

 }

 

 static int intersectRect( int x1, int x2, int y1, int y2,

@@ -725,14 +734,14 @@ static int intersectRect( int x1, int x2, int y1, int y2,
 

    if ( (width <= 0) || (height <= 0) ) {

       *ix1 = *ix2 = *iy1 = *iy2 = 0;

-      return(0);

+      return 0;

    }

    else {

       *ix1 = left;

       *ix2 = right;

       *iy1 = top;

       *iy2 = bottom;

-      return( width * height );

+      return width * height;

    }

 

 }

@@ -802,7 +811,7 @@ int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
     if (buf_size > 0) {

        buf = (char *) malloc( buf_size );

        if ( !buf ) {

-	  return( BadAlloc );

+	  return BadAlloc;

        }

     }

     else {

diff --git a/xorg-server/hw/dmx/glxProxy/glxutil.c b/xorg-server/hw/dmx/glxProxy/glxutil.c
index 2460ed0dc..ad34eef05 100644
--- a/xorg-server/hw/dmx/glxProxy/glxutil.c
+++ b/xorg-server/hw/dmx/glxProxy/glxutil.c
@@ -105,7 +105,5 @@ __glXRealloc(void *addr, size_t newSize)
 void

 __glXFree(void *addr)

 {

-    if (addr) {

-	free(addr);

-    }

+    free(addr);

 }

diff --git a/xorg-server/hw/dmx/glxProxy/glxvendor.c b/xorg-server/hw/dmx/glxProxy/glxvendor.c
index f2cea706f..02c8ad73d 100644
--- a/xorg-server/hw/dmx/glxProxy/glxvendor.c
+++ b/xorg-server/hw/dmx/glxProxy/glxvendor.c
@@ -392,6 +392,7 @@ int __glXVForwardPipe0WithReplySwap( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->vendorCode);

@@ -416,6 +417,7 @@ int __glXVForwardPipe0WithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->vendorCode);

@@ -440,6 +442,7 @@ int __glXVForwardPipe0WithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->vendorCode);

@@ -464,6 +467,7 @@ int __glXVForwardPipe0WithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->vendorCode);

@@ -488,6 +492,7 @@ int __glXVForwardAllWithReplySwap( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->vendorCode);

@@ -512,6 +517,7 @@ int __glXVForwardAllWithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->vendorCode);

@@ -536,6 +542,7 @@ int __glXVForwardAllWithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->vendorCode);

@@ -560,6 +567,7 @@ int __glXVForwardAllWithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
 {

    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;

    __GLX_DECLARE_SWAP_VARIABLES;

+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

    __GLX_SWAP_SHORT(&req->length);

    __GLX_SWAP_INT(&req->vendorCode);

diff --git a/xorg-server/hw/dmx/glxProxy/glxvisuals.c b/xorg-server/hw/dmx/glxProxy/glxvisuals.c
index 6e30b4edc..aaace39b6 100644
--- a/xorg-server/hw/dmx/glxProxy/glxvisuals.c
+++ b/xorg-server/hw/dmx/glxProxy/glxvisuals.c
@@ -77,11 +77,11 @@ int glxVisualsMatch( __GLXvisualConfig *v1, __GLXvisualConfig *v2 )
 	   (v1->nMultiSampleBuffers == v2->nMultiSampleBuffers) &&

 	   (v1->visualSelectGroup == v2->visualSelectGroup)         ) {

 

-	      return(1);

+	      return 1;

 

       }

 

-      return(0);

+      return 0;

 

 }

 

@@ -93,12 +93,12 @@ VisualID glxMatchGLXVisualInConfigList( __GLXvisualConfig *pGlxVisual, __GLXvisu
 

        if (glxVisualsMatch( pGlxVisual, &configs[i] )) {

 

-	  return( configs[i].vid );

+	  return configs[i].vid;

 

        }

     }

 

-    return(0);

+    return 0;

 }

 

 VisualID glxMatchVisualInConfigList( ScreenPtr pScreen, VisualPtr pVisual, __GLXvisualConfig *configs, int nconfigs )

@@ -109,7 +109,7 @@ VisualID glxMatchVisualInConfigList( ScreenPtr pScreen, VisualPtr pVisual, __GLX
 

     /* check that the glx extension has been initialized */

     if ( !__glXActiveScreens ) 

-       return(0);

+       return 0;

 

     pGlxScreen = &__glXActiveScreens[pScreen->myNum];

     pGlxVisual = pGlxScreen->pGlxVisual;

@@ -124,7 +124,7 @@ VisualID glxMatchVisualInConfigList( ScreenPtr pScreen, VisualPtr pVisual, __GLX
 	/*

 	 * the visual is not supported by glx

 	 */

-        return(0);

+        return 0;

     }

 

     return( glxMatchGLXVisualInConfigList(pGlxVisual, configs, nconfigs) );

@@ -151,12 +151,12 @@ VisualPtr glxMatchVisual( ScreenPtr pScreen, VisualPtr pVisual, ScreenPtr pMatch
 	*/

        for (j=0; j<pMatchScreen->numVisuals; j++) {

 	  if (vid == pMatchScreen->visuals[j].vid) {

-	     return( &pMatchScreen->visuals[j] );

+	     return &pMatchScreen->visuals[j];

 	  }

        }

     }

 

-    return(0);

+    return 0;

 }

 

 void glxSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,

@@ -198,7 +198,7 @@ static VisualID FindClosestVisual( VisualPtr pVisual, int rootDepth,
 	    while( pdepth[d].vids[v] != vis->vid ) vis++;

 

 	    if (vis->class == pVisual->class) {

-	       return( pdepth[d].vids[v] );

+	       return pdepth[d].vids[v];

 	    }

 	 }

       }

@@ -216,7 +216,7 @@ static VisualID FindClosestVisual( VisualPtr pVisual, int rootDepth,
 	 while( pdepth[d].vids[v] != vis->vid ) vis++;

 

       	 if (vis->class == pVisual->class) {

-	    return( pdepth[d].vids[v] );

+	    return pdepth[d].vids[v];

 	 }

       }

    }

@@ -224,7 +224,7 @@ static VisualID FindClosestVisual( VisualPtr pVisual, int rootDepth,
    /*

     * if not found - just take the first visual

     */

-   return( pdepth[0].vids[0] );

+   return pdepth[0].vids[0];

 }

 

 Bool glxInitVisuals(int *nvisualp, VisualPtr *visualp,

@@ -531,8 +531,7 @@ Bool glxInitVisuals(int *nvisualp, VisualPtr *visualp,
     __glXFree(pNewVisualConfigs);

 

     /* Free the private list created by DDX HW driver */

-    if (visualPrivates)

-        free(visualPrivates);

+    free(visualPrivates);

     visualPrivates = NULL;

 

     return TRUE;

diff --git a/xorg-server/hw/dmx/glxProxy/render2swap.c b/xorg-server/hw/dmx/glxProxy/render2swap.c
index 34122fb36..34fd19624 100644
--- a/xorg-server/hw/dmx/glxProxy/render2swap.c
+++ b/xorg-server/hw/dmx/glxProxy/render2swap.c
@@ -69,6 +69,7 @@ void __glXDispSwap_Map1f(GLbyte *pc)
     GLenum target;

     GLint compsize;

     __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

     __GLX_SWAP_INT(pc + 0);

     __GLX_SWAP_INT(pc + 12);

@@ -99,6 +100,7 @@ void __glXDispSwap_Map2f(GLbyte *pc)
     GLenum target;

     GLint compsize;

     __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

     __GLX_SWAP_INT(pc + 0);

     __GLX_SWAP_INT(pc + 12);

@@ -137,6 +139,7 @@ void __glXDispSwap_Map1d(GLbyte *pc)
     GLenum target;

     GLdouble u1, u2, *points;

     __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

     __GLX_SWAP_DOUBLE(pc + 0);

     __GLX_SWAP_DOUBLE(pc + 8);

@@ -179,6 +182,7 @@ void __glXDispSwap_Map2d(GLbyte *pc)
     GLint uorder, vorder, ustride, vstride, k, compsize;

     GLenum target;

     __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

     __GLX_SWAP_DOUBLE(pc + 0);

     __GLX_SWAP_DOUBLE(pc + 8);

@@ -228,6 +232,7 @@ void __glXDispSwap_CallLists(GLbyte *pc)
     GLenum type;

     GLsizei n;

     __GLX_DECLARE_SWAP_VARIABLES;

+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

 

     __GLX_SWAP_INT(pc + 4);

     __GLX_SWAP_INT(pc + 0);

diff --git a/xorg-server/hw/dmx/glxProxy/unpack.h b/xorg-server/hw/dmx/glxProxy/unpack.h
index 73d0485e3..b89a53411 100644
--- a/xorg-server/hw/dmx/glxProxy/unpack.h
+++ b/xorg-server/hw/dmx/glxProxy/unpack.h
@@ -138,7 +138,9 @@ extern xGLXSingleReply __glXReply;
 ** conceivably be replaced with routines that do the job faster.

 */

 #define __GLX_DECLARE_SWAP_VARIABLES \

-	GLbyte sw; \

+	GLbyte sw

+

+#define __GLX_DECLARE_SWAP_ARRAY_VARIABLES \

   	GLbyte *swapPC;		\

   	GLbyte *swapEnd

 

diff --git a/xorg-server/hw/dmx/input/dmxbackend.c b/xorg-server/hw/dmx/input/dmxbackend.c
index 55615cf39..35e9e9616 100644
--- a/xorg-server/hw/dmx/input/dmxbackend.c
+++ b/xorg-server/hw/dmx/input/dmxbackend.c
@@ -1,616 +1,616 @@
-/*
- * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   David H. Dawes <dawes@xfree86.org>
- *   Kevin E. Martin <kem@redhat.com>
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- */
-
-/** \file
- * These routines support taking input from devices on the backend
- * (output) displays.  \see dmxcommon.c. */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#define DMX_BACKEND_DEBUG 0
-
-#include "dmxinputinit.h"
-#include "dmxbackend.h"
-#include "dmxcommon.h"
-#include "dmxconsole.h"
-#include "dmxcursor.h"
-#include "dmxprop.h"
-#include "dmxsync.h"
-#include "dmxcb.h"              /* For dmxGlobalWidth and dmxGlobalHeight */
-#include "dmxevents.h"          /* For dmxGetGlobalPosition */
-#include "ChkNotMaskEv.h"
-
-#include "inputstr.h"
-#include "input.h"
-#include <X11/keysym.h>
-#include "mipointer.h"
-#include "scrnintstr.h"
-#include "windowstr.h"
-
-/* Private area for backend devices. */
-typedef struct _myPrivate {
-    DMX_COMMON_PRIVATE;
-    int                     myScreen;
-    DMXScreenInfo           *grabbedScreen;
-    
-    int                     lastX, lastY;
-    int                     centerX, centerY;
-    int                     relative;
-    int                     newscreen;
-    int                     initialized;
-    DevicePtr               mou, kbd;
-    int                     entered;
-    int                     offX, offY;
-} myPrivate;
-
-#if DMX_BACKEND_DEBUG
-#define DMXDBG0(f)                   dmxLog(dmxDebug,f)
-#define DMXDBG1(f,a)                 dmxLog(dmxDebug,f,a)
-#define DMXDBG2(f,a,b)               dmxLog(dmxDebug,f,a,b)
-#define DMXDBG3(f,a,b,c)             dmxLog(dmxDebug,f,a,b,c)
-#define DMXDBG4(f,a,b,c,d)           dmxLog(dmxDebug,f,a,b,c,d)
-#define DMXDBG5(f,a,b,c,d,e)         dmxLog(dmxDebug,f,a,b,c,d,e)
-#define DMXDBG6(f,a,b,c,d,e,g)       dmxLog(dmxDebug,f,a,b,c,d,e,g)
-#define DMXDBG7(f,a,b,c,d,e,g,h)     dmxLog(dmxDebug,f,a,b,c,d,e,g,h)
-#define DMXDBG8(f,a,b,c,d,e,g,h,i)   dmxLog(dmxDebug,f,a,b,c,d,e,g,h,i)
-#define DMXDBG9(f,a,b,c,d,e,g,h,i,j) dmxLog(dmxDebug,f,a,b,c,d,e,g,h,i,j)
-#else
-#define DMXDBG0(f)
-#define DMXDBG1(f,a)
-#define DMXDBG2(f,a,b)
-#define DMXDBG3(f,a,b,c)
-#define DMXDBG4(f,a,b,c,d)
-#define DMXDBG5(f,a,b,c,d,e)
-#define DMXDBG6(f,a,b,c,d,e,g)
-#define DMXDBG7(f,a,b,c,d,e,g,h)
-#define DMXDBG8(f,a,b,c,d,e,g,h,i)
-#define DMXDBG9(f,a,b,c,d,e,g,h,i,j)
-#endif
-
-/** Create and return a private data structure. */
-pointer dmxBackendCreatePrivate(DeviceIntPtr pDevice)
-{
-    GETDMXLOCALFROMPDEVICE;
-    myPrivate *priv = calloc(1, sizeof(*priv));
-    priv->dmxLocal  = dmxLocal;
-    return priv;
-}
-
-/** Destroy the private data structure.  No checking is performed to
- * verify that the structure was actually created by
- * #dmxBackendCreatePrivate. */
-void dmxBackendDestroyPrivate(pointer private)
-{
-    if (private) free(private);
-}
-
-static void *dmxBackendTestScreen(DMXScreenInfo *dmxScreen, void *closure)
-{
-    long target = (long)closure;
-
-    if (dmxScreen->index == target) return dmxScreen;
-    return NULL;
-}
-
-/* Return non-zero if screen and priv->myScreen are on the same physical
- * backend display (1 if they are the same screen, 2 if they are
- * different screens).  Since this is a common operation, the results
- * are cached.  The cache is invalidated if \a priv is NULL (this should
- * be done with each server generation and reconfiguration). */
-static int dmxBackendSameDisplay(myPrivate *priv, long screen)
-{
-    static myPrivate *oldpriv  = NULL;
-    static int       oldscreen = -1;
-    static int       retcode   = 0;
-
-    if (priv == oldpriv && screen == oldscreen) return retcode;
-    if (!priv) {                /* Invalidate cache */
-        oldpriv   = NULL;
-        oldscreen = -1;
-        retcode   = 0;
-        return 0;
-    }
-
-    if (screen == priv->myScreen)                     retcode = 1;
-    else if (screen < 0 || screen >= dmxNumScreens)   retcode = 0;
-    else if (dmxPropertyIterate(priv->be,
-                                dmxBackendTestScreen,
-                                (void *)screen))      retcode = 2;
-    else                                              retcode = 0;
-
-    oldpriv   = priv;
-    oldscreen = screen;
-    return retcode;
-}
-
-static void *dmxBackendTestEvents(DMXScreenInfo *dmxScreen, void *closure)
-{
-    XEvent *X = (XEvent *)closure;
-    
-    if (XCheckNotMaskEvent(dmxScreen->beDisplay, ExposureMask, X))
-        return dmxScreen;
-    return NULL;
-}
-
-static void *dmxBackendTestMotionEvent(DMXScreenInfo *dmxScreen, void *closure)
-{
-    XEvent *X = (XEvent *)closure;
-
-    if (XCheckTypedEvent(dmxScreen->beDisplay, MotionNotify, X))
-        return dmxScreen;
-    return NULL;
-}
-
-static DMXScreenInfo *dmxBackendGetEvent(myPrivate *priv, XEvent *X)
-{
-    DMXScreenInfo *dmxScreen;
-
-    if ((dmxScreen = dmxPropertyIterate(priv->be, dmxBackendTestEvents, X)))
-        return dmxScreen;
-    return NULL;
-}
-
-static DMXScreenInfo *dmxBackendPendingMotionEvent(myPrivate *priv, int save)
-{
-    DMXScreenInfo *dmxScreen;
-    XEvent        N;
-
-    if ((dmxScreen = dmxPropertyIterate(priv->be,
-                                        dmxBackendTestMotionEvent, &N))) {
-        if (save) XPutBackEvent(dmxScreen->beDisplay, &N);
-        return dmxScreen;
-    }
-    return NULL;
-}
-
-static void *dmxBackendTestWindow(DMXScreenInfo *dmxScreen, void *closure)
-{
-    Window win = (Window)(long)closure;
-    if (dmxScreen->scrnWin == win) return dmxScreen;
-    return NULL;
-}
-
-static DMXScreenInfo *dmxBackendFindWindow(myPrivate *priv, Window win)
-{
-    return dmxPropertyIterate(priv->be, dmxBackendTestWindow,
-                              (void *)(long)win);
-}
-
-/* If the cursor is over a set of overlapping screens and one of those
- * screens takes backend input, then we want that particular screen to
- * be current, not one of the other ones. */
-static int dmxBackendFindOverlapping(myPrivate *priv, int screen, int x, int y)
-{
-    DMXScreenInfo *start = &dmxScreens[screen];
-    DMXScreenInfo *pt;
-
-    if (!start->over) return screen;
-    
-    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {
-        if (pt->index == priv->myScreen
-            && dmxOnScreen(x, y, &dmxScreens[pt->index])) return pt->index;
-        if (pt == start) break;
-    }
-    return screen;
-}
-
-/* Return non-zero if \a x and \a y are off \a screen. */
-static int dmxBackendOffscreen(int screen, int x, int y)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[screen];
-
-    return (!dmxOnScreen(x, y, dmxScreen));
-}
-
-/** This routine is called from #dmxCoreMotion for each motion
- * event. \a x and \a y are global coordinants. */
-void dmxBackendUpdatePosition(pointer private, int x, int y)
-{
-    GETPRIVFROMPRIVATE;
-    int           screen      = miPointerGetScreen(inputInfo.pointer)->myNum;
-    DMXScreenInfo *dmxScreen  = &dmxScreens[priv->myScreen];
-    int           oldRelative = priv->relative;
-    int           topscreen   = dmxBackendFindOverlapping(priv, screen, x, y);
-    int           same        = dmxBackendSameDisplay(priv, topscreen);
-    int           offscreen   = dmxBackendOffscreen(priv->myScreen, x, y);
-    int           offthis     = dmxBackendOffscreen(screen, x, y);
-
-    DMXDBG9("dmxBackendUpdatePosition(%d,%d) my=%d mi=%d rel=%d"
-            " topscreen=%d same=%d offscreen=%d offthis=%d\n",
-            x, y, priv->myScreen, screen, priv->relative,
-            topscreen, same, offscreen, offthis);
-
-    if (offscreen) {
-        /* If the cursor is off the input screen, it should be moving
-         * relative unless it is visible on a screen of the same display
-         * (i.e., one that shares the mouse). */
-        if (same == 2 && !offthis) {
-            if (priv->relative) {
-                DMXDBG0("   Off screen, but not absolute\n");
-                priv->relative = 0;
-            }
-        } else {
-            if (!priv->relative) {
-                DMXDBG0("   Off screen, but not relative\n");
-                priv->relative = 1;
-            }
-        }
-    } else {
-        if (topscreen != screen) {
-            DMXDBG2("   Using screen %d instead of %d (from mi)\n",
-                    topscreen, screen);
-        }
-        if (same) {
-            if (priv->relative) {
-                DMXDBG0("   On screen, but not absolute\n");
-                priv->relative = 0;
-            }
-        } else {
-            if (!priv->relative) {
-                DMXDBG0("   Not on screen, but not relative\n");
-                priv->relative = 1;
-            }
-        }
-    }
-
-    if (oldRelative != priv->relative) {
-        DMXDBG2("   Do switch, relative=%d same=%d\n",
-                priv->relative, same);
-        /* Discard all pre-switch events */
-        dmxSync(dmxScreen, TRUE);
-        while (dmxBackendPendingMotionEvent(priv, FALSE));
-        
-        if (dmxInput->console && offscreen) {
-            /* Our special case is a console window and a backend window
-             * share a display.  In this case, the cursor is either on
-             * the backend window (taking absolute input), or not (in
-             * which case the cursor needs to be in the console
-             * window). */
-            if (priv->grabbedScreen) {
-                DMXDBG2("   *** force ungrab on %s, display=%p\n",
-                        priv->grabbedScreen->name,
-                        priv->grabbedScreen->beDisplay);
-                XUngrabPointer(priv->grabbedScreen->beDisplay, CurrentTime);
-                dmxSync(priv->grabbedScreen, TRUE);
-                priv->grabbedScreen = NULL;
-            }
-            DMXDBG0("   Capturing console\n");
-            dmxConsoleCapture(dmxInput);
-        } else {
-            priv->newscreen = 1;
-            if (priv->relative && !dmxInput->console) {
-                DMXDBG5("   Hide cursor; warp from %d,%d to %d,%d on %d\n",
-                        priv->lastX, priv->lastY, priv->centerX, priv->centerY,
-                        priv->myScreen);
-                dmxConsoleUncapture(dmxInput);
-                dmxHideCursor(dmxScreen);
-                priv->lastX   = priv->centerX;
-                priv->lastY   = priv->centerY;
-                XWarpPointer(priv->display, None, priv->window,
-                             0, 0, 0, 0, priv->lastX, priv->lastY);
-                dmxSync(dmxScreen, TRUE);
-            } else {
-                DMXDBG0("   Check cursor\n");
-                dmxCheckCursor();
-            }
-        }
-    }
-}
-
-/** Get events from the X queue on the backend servers and put the
- * events into the DMX event queue. */
-void dmxBackendCollectEvents(DevicePtr pDev,
-                             dmxMotionProcPtr motion,
-                             dmxEnqueueProcPtr enqueue,
-                             dmxCheckSpecialProcPtr checkspecial,
-                             DMXBlockType block)
-{
-    GETPRIVFROMPDEV;
-    GETDMXINPUTFROMPRIV;
-    XEvent               X;
-    DMXScreenInfo        *dmxScreen;
-    int                  left        = 0;
-    int                  entered     = priv->entered;
-    int                  ignoreLeave = 0;
-    int                  v[2];
-    int                  retcode;
-
-    while ((dmxScreen = dmxBackendGetEvent(priv, &X))) {
-	switch (X.type) {
-        case EnterNotify:
-            dmxCommonSaveState(priv);
-            if (entered++)
-                continue;
-            priv->entered = 1;
-            ignoreLeave   = 1;
-            DMXDBG5("dmxBackendCollectEvents: Enter %lu %d,%d; GRAB %s %p\n",
-                    X.xcrossing.root, X.xcrossing.x, X.xcrossing.y,
-                    dmxScreen->name, dmxScreen->beDisplay);
-            XRaiseWindow(dmxScreen->beDisplay, dmxScreen->scrnWin);
-            priv->grabbedScreen = dmxScreen;
-            if ((retcode = XGrabPointer(dmxScreen->beDisplay,
-					dmxScreen->scrnWin,
-                                        True, 0, GrabModeAsync,
-                                        GrabModeAsync, None, None,
-                                        CurrentTime))) {
-                dmxLog(dmxError,
-                       "XGrabPointer failed during backend enter (%d)\n",
-                       retcode);
-            }
-            break;
-        case LeaveNotify:
-            if (ignoreLeave) {
-                ignoreLeave = 0;
-                continue;
-            }
-            dmxCommonRestoreState(priv);
-            if (left++)
-                continue;
-            DMXDBG7("dmxBackendCollectEvents: Leave %lu %d,%d %d %d %s %s\n",
-                    X.xcrossing.root, X.xcrossing.x, X.xcrossing.y,
-                    X.xcrossing.detail, X.xcrossing.focus,
-                    priv->grabbedScreen ? "UNGRAB" : "",
-                    dmxScreen->name);
-            if (priv->grabbedScreen) {
-                XUngrabPointer(priv->grabbedScreen->beDisplay, CurrentTime);
-                dmxSync(priv->grabbedScreen, TRUE);
-                priv->grabbedScreen = NULL;
-            }
-            break;
-	case MotionNotify:
-            DMXDBG9("dmxBackendCollectEvents: MotionNotify %d/%d (mi %d)"
-                    " newscreen=%d: %d %d (e=%d; last=%d,%d)\n",
-                    dmxScreen->index, priv->myScreen,
-                    miPointerCurrentScreen()->myNum,
-                    priv->newscreen,
-                    X.xmotion.x, X.xmotion.y,
-                    entered, priv->lastX, priv->lastY);
-            if (dmxBackendPendingMotionEvent(priv, TRUE))
-                continue;
-            if (!(dmxScreen = dmxBackendFindWindow(priv, X.xmotion.window)))
-                dmxLog(dmxFatal,
-                       "   Event on non-existant window %lu\n",
-                       X.xmotion.window);
-            if (!priv->relative || dmxInput->console) {
-                int newX = X.xmotion.x - dmxScreen->rootX;
-                int newY = X.xmotion.y - dmxScreen->rootY;
-
-                if (!priv->newscreen) {
-                    int width  = dmxScreen->rootWidth;
-                    int height = dmxScreen->rootHeight;
-                    if (!newX)              newX = -1;
-                    if (newX == width - 1)  newX = width;
-                    if (!newY)              newY = -1;
-                    if (newY == height - 1) newY = height;
-                }
-                priv->newscreen = 0;
-                v[0] = dmxScreen->rootXOrigin + newX;
-                v[1] = dmxScreen->rootYOrigin + newY;
-                DMXDBG8("   Absolute move: %d,%d (r=%dx%d+%d+%d s=%dx%d)\n",
-                        v[0], v[1],
-                        priv->be->rootWidth, priv->be->rootHeight,
-                        priv->be->rootX, priv->be->rootY,
-                        priv->be->scrnWidth, priv->be->scrnHeight);
-                motion(priv->mou, v, 0, 2, DMX_ABSOLUTE, block);
-                priv->entered = 0;
-            } else {
-                int newX = priv->lastX - X.xmotion.x;
-                int newY = priv->lastY - X.xmotion.y;
-                priv->lastX = X.xmotion.x;
-                priv->lastY = X.xmotion.y;
-                v[0]        = newX;
-                v[1]        = newY;
-                DMXDBG2("   Relative move: %d, %d\n", v[0], v[1]);
-                motion(priv->mou, v, 0, 2, DMX_RELATIVE, block);
-            }
-            if (entered && priv->relative) {
-                DMXDBG4("   **** Relative %d %d instead of absolute %d %d\n",
-                        v[0], v[1],
-                        (dmxScreen->rootXOrigin + X.xmotion.x
-                         - dmxScreen->rootX),
-                        (dmxScreen->rootYOrigin + X.xmotion.y
-                         - dmxScreen->rootY));
-            }
-	    break;
-
-        case KeyPress:
-        case KeyRelease:
-            enqueue(priv->kbd, X.type, X.xkey.keycode, 0, NULL, block);
-            break;
-        case ButtonPress:
-        case ButtonRelease:
-            /* fall-through */
-	default:
-                                /* Pass the whole event here, because
-                                 * this may be an extension event. */
-            enqueue(priv->mou, X.type, X.xbutton.button, 0, &X, block);
-	    break;
-	}
-    }
-}
-
-/** Called after input events are processed from the DMX queue.  No
- * event processing actually takes place here, but this is a convenient
- * place to update the pointer. */
-void dmxBackendProcessInput(pointer private)
-{
-    GETPRIVFROMPRIVATE;
-
-    DMXDBG6("dmxBackendProcessInput: myScreen=%d relative=%d"
-            " last=%d,%d center=%d,%d\n",
-            priv->myScreen, priv->relative,
-            priv->lastX, priv->lastY,
-            priv->centerX, priv->centerY);
-
-    if (priv->relative
-        && !dmxInput->console
-        && (priv->lastX != priv->centerX || priv->lastY != priv->centerY)) {
-        DMXDBG4("   warping pointer from last=%d,%d to center=%d,%d\n",
-                priv->lastX, priv->lastY, priv->centerX, priv->centerY);
-	priv->lastX   = priv->centerX;
-	priv->lastY   = priv->centerY;
-        XWarpPointer(priv->display, None, priv->window,
-                     0, 0, 0, 0, priv->lastX, priv->lastY);
-        dmxSync(&dmxScreens[priv->myScreen], TRUE);
-    }
-}
-
-static void dmxBackendComputeCenter(myPrivate *priv)
-{
-    int centerX;
-    int centerY;
-    
-    centerX       = priv->be->rootWidth / 2 + priv->be->rootX;
-    centerY       = priv->be->rootHeight / 2 + priv->be->rootY;
-
-    if (centerX > priv->be->rootWidth)  centerX = priv->be->rootWidth  - 1;
-    if (centerY > priv->be->rootHeight) centerY = priv->be->rootHeight - 1;
-    if (centerX < 1)                    centerX = 1;
-    if (centerY < 1)                    centerY = 1;
-
-    priv->centerX = centerX;
-    priv->centerY = centerY;
-}
-
-static DMXScreenInfo *dmxBackendInitPrivate(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    DMXInputInfo      *dmxInput = &dmxInputs[dmxLocal->inputIdx];
-    DMXScreenInfo     *dmxScreen;
-    int               i;
-
-    /* Fill in myPrivate */
-    for (i = 0,dmxScreen = &dmxScreens[0]; i<dmxNumScreens; i++,dmxScreen++) {
-        if (dmxPropertySameDisplay(dmxScreen, dmxInput->name)) {
-            priv->display  = dmxScreen->beDisplay;
-            priv->window   = dmxScreen->scrnWin;
-            priv->be       = dmxScreen;
-            break;
-        }
-    }
-
-    if (i >= dmxNumScreens)
-        dmxLog(dmxFatal,
-               "%s is not an existing backend display - cannot initialize\n",
-               dmxInput->name);
-
-    return dmxScreen;
-}
-
-/** Re-initialized the backend device described by \a pDev (after a
- * reconfig). */
-void dmxBackendLateReInit(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    int               x, y;
-
-    DMXDBG1("dmxBackendLateReInit miPointerCurrentScreen() = %p\n",
-            miPointerCurrentScreen());
-
-    dmxBackendSameDisplay(NULL, 0); /* Invalidate cache */
-    dmxBackendInitPrivate(pDev);
-    dmxBackendComputeCenter(priv);
-    dmxGetGlobalPosition(&x, &y);
-    dmxInvalidateGlobalPosition(); /* To force event processing */
-    dmxBackendUpdatePosition(priv, x, y);
-}
-
-/** Initialized the backend device described by \a pDev. */
-void dmxBackendInit(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    DMXScreenInfo     *dmxScreen;
-
-    dmxBackendSameDisplay(NULL, 0); /* Invalidate cache */
-
-    if (dmxLocal->type == DMX_LOCAL_MOUSE)    priv->mou = pDev;
-    if (dmxLocal->type == DMX_LOCAL_KEYBOARD) priv->kbd = pDev;
-    if (priv->initialized++) return; /* Only do once for mouse/keyboard pair */
-
-    dmxScreen = dmxBackendInitPrivate(pDev);
-
-    /* Finish initialization using computed values or constants. */
-    dmxBackendComputeCenter(priv);
-    priv->eventMask          = (EnterWindowMask|LeaveWindowMask);
-    priv->myScreen           = dmxScreen->index;
-    priv->lastX              = priv->centerX;
-    priv->lastY              = priv->centerY;
-    priv->relative           = 0;
-    priv->newscreen          = 0;
-}
-
-/** Get information about the backend pointer (for initialization). */
-void dmxBackendMouGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)
-{
-    const DMXScreenInfo *dmxScreen = dmxBackendInitPrivate(pDev);
-
-    info->buttonClass      = 1;
-    dmxCommonMouGetMap(pDev, info->map, &info->numButtons);
-    info->valuatorClass    = 1;
-    info->numRelAxes       = 2;
-    info->minval[0]        = 0;
-    info->minval[1]        = 0;
-    info->maxval[0]        = dmxScreen->beWidth;
-    info->maxval[1]        = dmxScreen->beHeight;
-    info->res[0]           = 1;
-    info->minres[0]        = 0;
-    info->maxres[0]        = 1;
-    info->ptrFeedbackClass = 1;
-}
-
-/** Get information about the backend keyboard (for initialization). */
-void dmxBackendKbdGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)
-{
-    dmxCommonKbdGetInfo(pDev, info);
-    info->keyboard         = 1;
-    info->keyClass         = 1;
-    dmxCommonKbdGetMap(pDev, &info->keySyms, info->modMap);
-    info->freemap          = 1;
-    info->focusClass       = 1;
-    info->kbdFeedbackClass = 1;
-}
-
-/** Process #DMXFunctionType functions.  The only function handled here
- * is to acknowledge a pending server shutdown. */
-int dmxBackendFunctions(pointer private, DMXFunctionType function)
-{
-    switch (function) {
-    case DMX_FUNCTION_TERMINATE:
-        return 1;
-    default:
-        return 0;
-    }
-}
+/*

+ * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   David H. Dawes <dawes@xfree86.org>

+ *   Kevin E. Martin <kem@redhat.com>

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ */

+

+/** \file

+ * These routines support taking input from devices on the backend

+ * (output) displays.  \see dmxcommon.c. */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#define DMX_BACKEND_DEBUG 0

+

+#include "dmxinputinit.h"

+#include "dmxbackend.h"

+#include "dmxcommon.h"

+#include "dmxconsole.h"

+#include "dmxcursor.h"

+#include "dmxprop.h"

+#include "dmxsync.h"

+#include "dmxcb.h"              /* For dmxGlobalWidth and dmxGlobalHeight */

+#include "dmxevents.h"          /* For dmxGetGlobalPosition */

+#include "ChkNotMaskEv.h"

+

+#include "inputstr.h"

+#include "input.h"

+#include <X11/keysym.h>

+#include "mipointer.h"

+#include "scrnintstr.h"

+#include "windowstr.h"

+

+/* Private area for backend devices. */

+typedef struct _myPrivate {

+    DMX_COMMON_PRIVATE;

+    int                     myScreen;

+    DMXScreenInfo           *grabbedScreen;

+    

+    int                     lastX, lastY;

+    int                     centerX, centerY;

+    int                     relative;

+    int                     newscreen;

+    int                     initialized;

+    DevicePtr               mou, kbd;

+    int                     entered;

+    int                     offX, offY;

+} myPrivate;

+

+#if DMX_BACKEND_DEBUG

+#define DMXDBG0(f)                   dmxLog(dmxDebug,f)

+#define DMXDBG1(f,a)                 dmxLog(dmxDebug,f,a)

+#define DMXDBG2(f,a,b)               dmxLog(dmxDebug,f,a,b)

+#define DMXDBG3(f,a,b,c)             dmxLog(dmxDebug,f,a,b,c)

+#define DMXDBG4(f,a,b,c,d)           dmxLog(dmxDebug,f,a,b,c,d)

+#define DMXDBG5(f,a,b,c,d,e)         dmxLog(dmxDebug,f,a,b,c,d,e)

+#define DMXDBG6(f,a,b,c,d,e,g)       dmxLog(dmxDebug,f,a,b,c,d,e,g)

+#define DMXDBG7(f,a,b,c,d,e,g,h)     dmxLog(dmxDebug,f,a,b,c,d,e,g,h)

+#define DMXDBG8(f,a,b,c,d,e,g,h,i)   dmxLog(dmxDebug,f,a,b,c,d,e,g,h,i)

+#define DMXDBG9(f,a,b,c,d,e,g,h,i,j) dmxLog(dmxDebug,f,a,b,c,d,e,g,h,i,j)

+#else

+#define DMXDBG0(f)

+#define DMXDBG1(f,a)

+#define DMXDBG2(f,a,b)

+#define DMXDBG3(f,a,b,c)

+#define DMXDBG4(f,a,b,c,d)

+#define DMXDBG5(f,a,b,c,d,e)

+#define DMXDBG6(f,a,b,c,d,e,g)

+#define DMXDBG7(f,a,b,c,d,e,g,h)

+#define DMXDBG8(f,a,b,c,d,e,g,h,i)

+#define DMXDBG9(f,a,b,c,d,e,g,h,i,j)

+#endif

+

+/** Create and return a private data structure. */

+pointer dmxBackendCreatePrivate(DeviceIntPtr pDevice)

+{

+    GETDMXLOCALFROMPDEVICE;

+    myPrivate *priv = calloc(1, sizeof(*priv));

+    priv->dmxLocal  = dmxLocal;

+    return priv;

+}

+

+/** Destroy the private data structure.  No checking is performed to

+ * verify that the structure was actually created by

+ * #dmxBackendCreatePrivate. */

+void dmxBackendDestroyPrivate(pointer private)

+{

+    free(private);

+}

+

+static void *dmxBackendTestScreen(DMXScreenInfo *dmxScreen, void *closure)

+{

+    long target = (long)closure;

+

+    if (dmxScreen->index == target) return dmxScreen;

+    return NULL;

+}

+

+/* Return non-zero if screen and priv->myScreen are on the same physical

+ * backend display (1 if they are the same screen, 2 if they are

+ * different screens).  Since this is a common operation, the results

+ * are cached.  The cache is invalidated if \a priv is NULL (this should

+ * be done with each server generation and reconfiguration). */

+static int dmxBackendSameDisplay(myPrivate *priv, long screen)

+{

+    static myPrivate *oldpriv  = NULL;

+    static int       oldscreen = -1;

+    static int       retcode   = 0;

+

+    if (priv == oldpriv && screen == oldscreen) return retcode;

+    if (!priv) {                /* Invalidate cache */

+        oldpriv   = NULL;

+        oldscreen = -1;

+        retcode   = 0;

+        return 0;

+    }

+

+    if (screen == priv->myScreen)                     retcode = 1;

+    else if (screen < 0 || screen >= dmxNumScreens)   retcode = 0;

+    else if (dmxPropertyIterate(priv->be,

+                                dmxBackendTestScreen,

+                                (void *)screen))      retcode = 2;

+    else                                              retcode = 0;

+

+    oldpriv   = priv;

+    oldscreen = screen;

+    return retcode;

+}

+

+static void *dmxBackendTestEvents(DMXScreenInfo *dmxScreen, void *closure)

+{

+    XEvent *X = (XEvent *)closure;

+    

+    if (XCheckNotMaskEvent(dmxScreen->beDisplay, ExposureMask, X))

+        return dmxScreen;

+    return NULL;

+}

+

+static void *dmxBackendTestMotionEvent(DMXScreenInfo *dmxScreen, void *closure)

+{

+    XEvent *X = (XEvent *)closure;

+

+    if (XCheckTypedEvent(dmxScreen->beDisplay, MotionNotify, X))

+        return dmxScreen;

+    return NULL;

+}

+

+static DMXScreenInfo *dmxBackendGetEvent(myPrivate *priv, XEvent *X)

+{

+    DMXScreenInfo *dmxScreen;

+

+    if ((dmxScreen = dmxPropertyIterate(priv->be, dmxBackendTestEvents, X)))

+        return dmxScreen;

+    return NULL;

+}

+

+static DMXScreenInfo *dmxBackendPendingMotionEvent(myPrivate *priv, int save)

+{

+    DMXScreenInfo *dmxScreen;

+    XEvent        N;

+

+    if ((dmxScreen = dmxPropertyIterate(priv->be,

+                                        dmxBackendTestMotionEvent, &N))) {

+        if (save) XPutBackEvent(dmxScreen->beDisplay, &N);

+        return dmxScreen;

+    }

+    return NULL;

+}

+

+static void *dmxBackendTestWindow(DMXScreenInfo *dmxScreen, void *closure)

+{

+    Window win = (Window)(long)closure;

+    if (dmxScreen->scrnWin == win) return dmxScreen;

+    return NULL;

+}

+

+static DMXScreenInfo *dmxBackendFindWindow(myPrivate *priv, Window win)

+{

+    return dmxPropertyIterate(priv->be, dmxBackendTestWindow,

+                              (void *)(long)win);

+}

+

+/* If the cursor is over a set of overlapping screens and one of those

+ * screens takes backend input, then we want that particular screen to

+ * be current, not one of the other ones. */

+static int dmxBackendFindOverlapping(myPrivate *priv, int screen, int x, int y)

+{

+    DMXScreenInfo *start = &dmxScreens[screen];

+    DMXScreenInfo *pt;

+

+    if (!start->over) return screen;

+    

+    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {

+        if (pt->index == priv->myScreen

+            && dmxOnScreen(x, y, &dmxScreens[pt->index])) return pt->index;

+        if (pt == start) break;

+    }

+    return screen;

+}

+

+/* Return non-zero if \a x and \a y are off \a screen. */

+static int dmxBackendOffscreen(int screen, int x, int y)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[screen];

+

+    return (!dmxOnScreen(x, y, dmxScreen));

+}

+

+/** This routine is called from #dmxCoreMotion for each motion

+ * event. \a x and \a y are global coordinants. */

+void dmxBackendUpdatePosition(pointer private, int x, int y)

+{

+    GETPRIVFROMPRIVATE;

+    int           screen      = miPointerGetScreen(inputInfo.pointer)->myNum;

+    DMXScreenInfo *dmxScreen  = &dmxScreens[priv->myScreen];

+    int           oldRelative = priv->relative;

+    int           topscreen   = dmxBackendFindOverlapping(priv, screen, x, y);

+    int           same        = dmxBackendSameDisplay(priv, topscreen);

+    int           offscreen   = dmxBackendOffscreen(priv->myScreen, x, y);

+    int           offthis     = dmxBackendOffscreen(screen, x, y);

+

+    DMXDBG9("dmxBackendUpdatePosition(%d,%d) my=%d mi=%d rel=%d"

+            " topscreen=%d same=%d offscreen=%d offthis=%d\n",

+            x, y, priv->myScreen, screen, priv->relative,

+            topscreen, same, offscreen, offthis);

+

+    if (offscreen) {

+        /* If the cursor is off the input screen, it should be moving

+         * relative unless it is visible on a screen of the same display

+         * (i.e., one that shares the mouse). */

+        if (same == 2 && !offthis) {

+            if (priv->relative) {

+                DMXDBG0("   Off screen, but not absolute\n");

+                priv->relative = 0;

+            }

+        } else {

+            if (!priv->relative) {

+                DMXDBG0("   Off screen, but not relative\n");

+                priv->relative = 1;

+            }

+        }

+    } else {

+        if (topscreen != screen) {

+            DMXDBG2("   Using screen %d instead of %d (from mi)\n",

+                    topscreen, screen);

+        }

+        if (same) {

+            if (priv->relative) {

+                DMXDBG0("   On screen, but not absolute\n");

+                priv->relative = 0;

+            }

+        } else {

+            if (!priv->relative) {

+                DMXDBG0("   Not on screen, but not relative\n");

+                priv->relative = 1;

+            }

+        }

+    }

+

+    if (oldRelative != priv->relative) {

+        DMXDBG2("   Do switch, relative=%d same=%d\n",

+                priv->relative, same);

+        /* Discard all pre-switch events */

+        dmxSync(dmxScreen, TRUE);

+        while (dmxBackendPendingMotionEvent(priv, FALSE));

+        

+        if (dmxInput->console && offscreen) {

+            /* Our special case is a console window and a backend window

+             * share a display.  In this case, the cursor is either on

+             * the backend window (taking absolute input), or not (in

+             * which case the cursor needs to be in the console

+             * window). */

+            if (priv->grabbedScreen) {

+                DMXDBG2("   *** force ungrab on %s, display=%p\n",

+                        priv->grabbedScreen->name,

+                        priv->grabbedScreen->beDisplay);

+                XUngrabPointer(priv->grabbedScreen->beDisplay, CurrentTime);

+                dmxSync(priv->grabbedScreen, TRUE);

+                priv->grabbedScreen = NULL;

+            }

+            DMXDBG0("   Capturing console\n");

+            dmxConsoleCapture(dmxInput);

+        } else {

+            priv->newscreen = 1;

+            if (priv->relative && !dmxInput->console) {

+                DMXDBG5("   Hide cursor; warp from %d,%d to %d,%d on %d\n",

+                        priv->lastX, priv->lastY, priv->centerX, priv->centerY,

+                        priv->myScreen);

+                dmxConsoleUncapture(dmxInput);

+                dmxHideCursor(dmxScreen);

+                priv->lastX   = priv->centerX;

+                priv->lastY   = priv->centerY;

+                XWarpPointer(priv->display, None, priv->window,

+                             0, 0, 0, 0, priv->lastX, priv->lastY);

+                dmxSync(dmxScreen, TRUE);

+            } else {

+                DMXDBG0("   Check cursor\n");

+                dmxCheckCursor();

+            }

+        }

+    }

+}

+

+/** Get events from the X queue on the backend servers and put the

+ * events into the DMX event queue. */

+void dmxBackendCollectEvents(DevicePtr pDev,

+                             dmxMotionProcPtr motion,

+                             dmxEnqueueProcPtr enqueue,

+                             dmxCheckSpecialProcPtr checkspecial,

+                             DMXBlockType block)

+{

+    GETPRIVFROMPDEV;

+    GETDMXINPUTFROMPRIV;

+    XEvent               X;

+    DMXScreenInfo        *dmxScreen;

+    int                  left        = 0;

+    int                  entered     = priv->entered;

+    int                  ignoreLeave = 0;

+    int                  v[2];

+    int                  retcode;

+

+    while ((dmxScreen = dmxBackendGetEvent(priv, &X))) {

+	switch (X.type) {

+        case EnterNotify:

+            dmxCommonSaveState(priv);

+            if (entered++)

+                continue;

+            priv->entered = 1;

+            ignoreLeave   = 1;

+            DMXDBG5("dmxBackendCollectEvents: Enter %lu %d,%d; GRAB %s %p\n",

+                    X.xcrossing.root, X.xcrossing.x, X.xcrossing.y,

+                    dmxScreen->name, dmxScreen->beDisplay);

+            XRaiseWindow(dmxScreen->beDisplay, dmxScreen->scrnWin);

+            priv->grabbedScreen = dmxScreen;

+            if ((retcode = XGrabPointer(dmxScreen->beDisplay,

+					dmxScreen->scrnWin,

+                                        True, 0, GrabModeAsync,

+                                        GrabModeAsync, None, None,

+                                        CurrentTime))) {

+                dmxLog(dmxError,

+                       "XGrabPointer failed during backend enter (%d)\n",

+                       retcode);

+            }

+            break;

+        case LeaveNotify:

+            if (ignoreLeave) {

+                ignoreLeave = 0;

+                continue;

+            }

+            dmxCommonRestoreState(priv);

+            if (left++)

+                continue;

+            DMXDBG7("dmxBackendCollectEvents: Leave %lu %d,%d %d %d %s %s\n",

+                    X.xcrossing.root, X.xcrossing.x, X.xcrossing.y,

+                    X.xcrossing.detail, X.xcrossing.focus,

+                    priv->grabbedScreen ? "UNGRAB" : "",

+                    dmxScreen->name);

+            if (priv->grabbedScreen) {

+                XUngrabPointer(priv->grabbedScreen->beDisplay, CurrentTime);

+                dmxSync(priv->grabbedScreen, TRUE);

+                priv->grabbedScreen = NULL;

+            }

+            break;

+	case MotionNotify:

+            DMXDBG9("dmxBackendCollectEvents: MotionNotify %d/%d (mi %d)"

+                    " newscreen=%d: %d %d (e=%d; last=%d,%d)\n",

+                    dmxScreen->index, priv->myScreen,

+                    miPointerCurrentScreen()->myNum,

+                    priv->newscreen,

+                    X.xmotion.x, X.xmotion.y,

+                    entered, priv->lastX, priv->lastY);

+            if (dmxBackendPendingMotionEvent(priv, TRUE))

+                continue;

+            if (!(dmxScreen = dmxBackendFindWindow(priv, X.xmotion.window)))

+                dmxLog(dmxFatal,

+                       "   Event on non-existant window %lu\n",

+                       X.xmotion.window);

+            if (!priv->relative || dmxInput->console) {

+                int newX = X.xmotion.x - dmxScreen->rootX;

+                int newY = X.xmotion.y - dmxScreen->rootY;

+

+                if (!priv->newscreen) {

+                    int width  = dmxScreen->rootWidth;

+                    int height = dmxScreen->rootHeight;

+                    if (!newX)              newX = -1;

+                    if (newX == width - 1)  newX = width;

+                    if (!newY)              newY = -1;

+                    if (newY == height - 1) newY = height;

+                }

+                priv->newscreen = 0;

+                v[0] = dmxScreen->rootXOrigin + newX;

+                v[1] = dmxScreen->rootYOrigin + newY;

+                DMXDBG8("   Absolute move: %d,%d (r=%dx%d+%d+%d s=%dx%d)\n",

+                        v[0], v[1],

+                        priv->be->rootWidth, priv->be->rootHeight,

+                        priv->be->rootX, priv->be->rootY,

+                        priv->be->scrnWidth, priv->be->scrnHeight);

+                motion(priv->mou, v, 0, 2, DMX_ABSOLUTE, block);

+                priv->entered = 0;

+            } else {

+                int newX = priv->lastX - X.xmotion.x;

+                int newY = priv->lastY - X.xmotion.y;

+                priv->lastX = X.xmotion.x;

+                priv->lastY = X.xmotion.y;

+                v[0]        = newX;

+                v[1]        = newY;

+                DMXDBG2("   Relative move: %d, %d\n", v[0], v[1]);

+                motion(priv->mou, v, 0, 2, DMX_RELATIVE, block);

+            }

+            if (entered && priv->relative) {

+                DMXDBG4("   **** Relative %d %d instead of absolute %d %d\n",

+                        v[0], v[1],

+                        (dmxScreen->rootXOrigin + X.xmotion.x

+                         - dmxScreen->rootX),

+                        (dmxScreen->rootYOrigin + X.xmotion.y

+                         - dmxScreen->rootY));

+            }

+	    break;

+

+        case KeyPress:

+        case KeyRelease:

+            enqueue(priv->kbd, X.type, X.xkey.keycode, 0, NULL, block);

+            break;

+        case ButtonPress:

+        case ButtonRelease:

+            /* fall-through */

+	default:

+                                /* Pass the whole event here, because

+                                 * this may be an extension event. */

+            enqueue(priv->mou, X.type, X.xbutton.button, 0, &X, block);

+	    break;

+	}

+    }

+}

+

+/** Called after input events are processed from the DMX queue.  No

+ * event processing actually takes place here, but this is a convenient

+ * place to update the pointer. */

+void dmxBackendProcessInput(pointer private)

+{

+    GETPRIVFROMPRIVATE;

+

+    DMXDBG6("dmxBackendProcessInput: myScreen=%d relative=%d"

+            " last=%d,%d center=%d,%d\n",

+            priv->myScreen, priv->relative,

+            priv->lastX, priv->lastY,

+            priv->centerX, priv->centerY);

+

+    if (priv->relative

+        && !dmxInput->console

+        && (priv->lastX != priv->centerX || priv->lastY != priv->centerY)) {

+        DMXDBG4("   warping pointer from last=%d,%d to center=%d,%d\n",

+                priv->lastX, priv->lastY, priv->centerX, priv->centerY);

+	priv->lastX   = priv->centerX;

+	priv->lastY   = priv->centerY;

+        XWarpPointer(priv->display, None, priv->window,

+                     0, 0, 0, 0, priv->lastX, priv->lastY);

+        dmxSync(&dmxScreens[priv->myScreen], TRUE);

+    }

+}

+

+static void dmxBackendComputeCenter(myPrivate *priv)

+{

+    int centerX;

+    int centerY;

+    

+    centerX       = priv->be->rootWidth / 2 + priv->be->rootX;

+    centerY       = priv->be->rootHeight / 2 + priv->be->rootY;

+

+    if (centerX > priv->be->rootWidth)  centerX = priv->be->rootWidth  - 1;

+    if (centerY > priv->be->rootHeight) centerY = priv->be->rootHeight - 1;

+    if (centerX < 1)                    centerX = 1;

+    if (centerY < 1)                    centerY = 1;

+

+    priv->centerX = centerX;

+    priv->centerY = centerY;

+}

+

+static DMXScreenInfo *dmxBackendInitPrivate(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    DMXInputInfo      *dmxInput = &dmxInputs[dmxLocal->inputIdx];

+    DMXScreenInfo     *dmxScreen;

+    int               i;

+

+    /* Fill in myPrivate */

+    for (i = 0,dmxScreen = &dmxScreens[0]; i<dmxNumScreens; i++,dmxScreen++) {

+        if (dmxPropertySameDisplay(dmxScreen, dmxInput->name)) {

+            priv->display  = dmxScreen->beDisplay;

+            priv->window   = dmxScreen->scrnWin;

+            priv->be       = dmxScreen;

+            break;

+        }

+    }

+

+    if (i >= dmxNumScreens)

+        dmxLog(dmxFatal,

+               "%s is not an existing backend display - cannot initialize\n",

+               dmxInput->name);

+

+    return dmxScreen;

+}

+

+/** Re-initialized the backend device described by \a pDev (after a

+ * reconfig). */

+void dmxBackendLateReInit(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    int               x, y;

+

+    DMXDBG1("dmxBackendLateReInit miPointerCurrentScreen() = %p\n",

+            miPointerCurrentScreen());

+

+    dmxBackendSameDisplay(NULL, 0); /* Invalidate cache */

+    dmxBackendInitPrivate(pDev);

+    dmxBackendComputeCenter(priv);

+    dmxGetGlobalPosition(&x, &y);

+    dmxInvalidateGlobalPosition(); /* To force event processing */

+    dmxBackendUpdatePosition(priv, x, y);

+}

+

+/** Initialized the backend device described by \a pDev. */

+void dmxBackendInit(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    DMXScreenInfo     *dmxScreen;

+

+    dmxBackendSameDisplay(NULL, 0); /* Invalidate cache */

+

+    if (dmxLocal->type == DMX_LOCAL_MOUSE)    priv->mou = pDev;

+    if (dmxLocal->type == DMX_LOCAL_KEYBOARD) priv->kbd = pDev;

+    if (priv->initialized++) return; /* Only do once for mouse/keyboard pair */

+

+    dmxScreen = dmxBackendInitPrivate(pDev);

+

+    /* Finish initialization using computed values or constants. */

+    dmxBackendComputeCenter(priv);

+    priv->eventMask          = (EnterWindowMask|LeaveWindowMask);

+    priv->myScreen           = dmxScreen->index;

+    priv->lastX              = priv->centerX;

+    priv->lastY              = priv->centerY;

+    priv->relative           = 0;

+    priv->newscreen          = 0;

+}

+

+/** Get information about the backend pointer (for initialization). */

+void dmxBackendMouGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)

+{

+    const DMXScreenInfo *dmxScreen = dmxBackendInitPrivate(pDev);

+

+    info->buttonClass      = 1;

+    dmxCommonMouGetMap(pDev, info->map, &info->numButtons);

+    info->valuatorClass    = 1;

+    info->numRelAxes       = 2;

+    info->minval[0]        = 0;

+    info->minval[1]        = 0;

+    info->maxval[0]        = dmxScreen->beWidth;

+    info->maxval[1]        = dmxScreen->beHeight;

+    info->res[0]           = 1;

+    info->minres[0]        = 0;

+    info->maxres[0]        = 1;

+    info->ptrFeedbackClass = 1;

+}

+

+/** Get information about the backend keyboard (for initialization). */

+void dmxBackendKbdGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)

+{

+    dmxCommonKbdGetInfo(pDev, info);

+    info->keyboard         = 1;

+    info->keyClass         = 1;

+    dmxCommonKbdGetMap(pDev, &info->keySyms, info->modMap);

+    info->freemap          = 1;

+    info->focusClass       = 1;

+    info->kbdFeedbackClass = 1;

+}

+

+/** Process #DMXFunctionType functions.  The only function handled here

+ * is to acknowledge a pending server shutdown. */

+int dmxBackendFunctions(pointer private, DMXFunctionType function)

+{

+    switch (function) {

+    case DMX_FUNCTION_TERMINATE:

+        return 1;

+    default:

+        return 0;

+    }

+}

diff --git a/xorg-server/hw/dmx/input/dmxcommon.c b/xorg-server/hw/dmx/input/dmxcommon.c
index da5b77893..29c1958ad 100644
--- a/xorg-server/hw/dmx/input/dmxcommon.c
+++ b/xorg-server/hw/dmx/input/dmxcommon.c
@@ -1,670 +1,669 @@
-/*
- * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   David H. Dawes <dawes@xfree86.org>
- *   Kevin E. Martin <kem@redhat.com>
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- */
-
-/** \file
- *
- * This file implements common routines used by the backend and console
- * input devices.
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#define DMX_STATE_DEBUG 0
-
-#include "dmxinputinit.h"
-#include "dmxcommon.h"
-#include "dmxconsole.h"
-#include "dmxprop.h"
-#include "dmxsync.h"
-#include "dmxmap.h"
-
-#include "inputstr.h"
-#include "input.h"
-#include <X11/keysym.h>
-#include "mipointer.h"
-#include "scrnintstr.h"
-
-#include <unistd.h>             /* For usleep() */
-
-#if DMX_STATE_DEBUG
-#define DMXDBG0(f)               dmxLog(dmxDebug,f)
-#else
-#define DMXDBG0(f)
-#endif
-
-/** Each device has a private area that is visible only from inside the
- * driver code. */ 
-typedef struct _myPrivate {
-    DMX_COMMON_PRIVATE;
-} myPrivate;
-
-static void dmxCommonKbdSetAR(Display *display,
-                              unsigned char *old, unsigned char *new)
-{
-    XKeyboardControl kc;
-    XKeyboardState   ks;
-    unsigned long    mask = KBKey | KBAutoRepeatMode;
-    int              i, j;
-    int              minKeycode, maxKeycode;
-
-    if (!old) {
-        XGetKeyboardControl(display, &ks);
-        old = (unsigned char *)ks.auto_repeats;
-    }
-
-    XDisplayKeycodes(display, &minKeycode, &maxKeycode);
-    for (i = 1; i < 32; i++) {
-        if (!old || old[i] != new[i]) {
-            for (j = 0; j < 8; j++) {
-                if ((new[i] & (1 << j)) != (old[i] & (1 << j))) {
-                    kc.key              = i * 8 + j;
-                    kc.auto_repeat_mode = ((new[i] & (1 << j))
-                                           ? AutoRepeatModeOn
-                                           : AutoRepeatModeOff);
-                    if (kc.key >= minKeycode && kc.key <= maxKeycode)
-                        XChangeKeyboardControl(display, mask, &kc);
-                }
-            }
-        }
-    }
-}
-
-static void dmxCommonKbdSetLeds(Display *display, unsigned long new)
-{
-    int              i;
-    XKeyboardControl kc;
-
-    for (i = 0; i < 32; i++) {
-        kc.led      = i + 1;
-        kc.led_mode = (new & (1 << i)) ? LedModeOn : LedModeOff;
-        XChangeKeyboardControl(display, KBLed | KBLedMode, &kc);
-    }
-}
-
-static void dmxCommonKbdSetCtrl(Display *display,
-                                KeybdCtrl *old, KeybdCtrl *new)
-{
-    XKeyboardControl kc;
-    unsigned long    mask = KBKeyClickPercent | KBAutoRepeatMode;
-
-    if (!old
-        || old->click         != new->click
-        || old->autoRepeat    != new->autoRepeat) {
-        
-        kc.key_click_percent = new->click;
-        kc.auto_repeat_mode  = new->autoRepeat;
-
-        XChangeKeyboardControl(display, mask, &kc);
-    }
-
-    dmxCommonKbdSetLeds(display, new->leds);
-    dmxCommonKbdSetAR(display, old ? old->autoRepeats : NULL,
-                      new->autoRepeats);
-}
-
-static void dmxCommonMouSetCtrl(Display *display, PtrCtrl *old, PtrCtrl *new)
-{
-    Bool do_accel, do_threshold;
-    
-    if (!old
-        || old->num != new->num
-        || old->den != new->den
-        || old->threshold != new->threshold) {
-        do_accel     = (new->num > 0 && new->den > 0);
-        do_threshold = (new->threshold > 0);
-        if (do_accel || do_threshold) {
-            XChangePointerControl(display, do_accel, do_threshold,
-                                  new->num, new->den, new->threshold);
-        }
-    }
-}
-
-/** Update the keyboard control. */
-void dmxCommonKbdCtrl(DevicePtr pDev, KeybdCtrl *ctrl)
-{
-    GETPRIVFROMPDEV;
-
-    if (!priv->stateSaved && priv->be) dmxCommonSaveState(priv);
-    if (!priv->display || !priv->stateSaved) return;
-    dmxCommonKbdSetCtrl(priv->display,
-                        priv->kctrlset ? &priv->kctrl : NULL,
-                        ctrl);
-    priv->kctrl    = *ctrl;
-    priv->kctrlset = 1;
-}
-
-/** Update the mouse control. */
-void dmxCommonMouCtrl(DevicePtr pDev, PtrCtrl *ctrl)
-{
-    GETPRIVFROMPDEV;
-
-                                /* Don't set the acceleration for the
-                                 * console, because that should be
-                                 * controlled by the X server that the
-                                 * console is running on.  Otherwise,
-                                 * the acceleration for the console
-                                 * window would be unexpected for the
-                                 * scale of the window. */
-    if (priv->be) {
-        dmxCommonMouSetCtrl(priv->display,
-                            priv->mctrlset ? &priv->mctrl : NULL,
-                            ctrl);
-        priv->mctrl    = *ctrl;
-        priv->mctrlset = 1;
-    }
-}
-
-/** Sound they keyboard bell. */
-void dmxCommonKbdBell(DevicePtr pDev, int percent,
-                      int volume, int pitch, int duration)
-{
-    GETPRIVFROMPDEV;
-    XKeyboardControl kc;
-    XKeyboardState   ks;
-    unsigned long    mask = KBBellPercent | KBBellPitch | KBBellDuration;
-    
-    if (!priv->be) XGetKeyboardControl(priv->display, &ks);
-    kc.bell_percent  = volume;
-    kc.bell_pitch    = pitch;
-    kc.bell_duration = duration;
-    XChangeKeyboardControl(priv->display, mask, &kc);
-    XBell(priv->display, percent);
-    if (!priv->be) {
-        kc.bell_percent  = ks.bell_percent;
-        kc.bell_pitch    = ks.bell_pitch;
-        kc.bell_duration = ks.bell_duration;
-        XChangeKeyboardControl(priv->display, mask, &kc);
-    }
-}
-
-/** Get the keyboard mapping. */
-void dmxCommonKbdGetMap(DevicePtr pDev, KeySymsPtr pKeySyms, CARD8 *pModMap)
-{
-    GETPRIVFROMPDEV;
-    int             min_keycode;
-    int             max_keycode;
-    int             map_width;
-    KeySym          *keyboard_mapping;
-    XModifierKeymap *modifier_mapping;
-    int             i, j;
-
-                                /* Compute pKeySyms.  Cast
-                                 * XGetKeyboardMapping because of
-                                 * compiler warning on 64-bit machines.
-                                 * We assume pointers to 32-bit and
-                                 * 64-bit ints are the same. */
-    XDisplayKeycodes(priv->display, &min_keycode, &max_keycode);
-    keyboard_mapping     = (KeySym *)XGetKeyboardMapping(priv->display,
-                                                         min_keycode,
-                                                         max_keycode
-                                                         - min_keycode + 1,
-                                                         &map_width);
-    pKeySyms->minKeyCode = min_keycode;
-    pKeySyms->maxKeyCode = max_keycode;
-    pKeySyms->mapWidth   = map_width;
-    pKeySyms->map        = keyboard_mapping;
-
-
-                                /* Compute pModMap  */
-    modifier_mapping     = XGetModifierMapping(priv->display);
-    for (i = 0; i < MAP_LENGTH; i++)
-        pModMap[i] = 0;
-    for (j = 0; j < 8; j++) {
-        int max_keypermod = modifier_mapping->max_keypermod;
-        
-        for (i = 0; i < max_keypermod; i++) {
-            CARD8 keycode = modifier_mapping->modifiermap[j*max_keypermod + i];
-            if (keycode)
-                pModMap[keycode] |= 1 << j;
-        }
-    }
-    XFreeModifiermap(modifier_mapping);
-}
-
-/** Fill in the XKEYBOARD parts of the \a info structure for the
- * specified \a pDev. */
-void dmxCommonKbdGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)
-{
-    GETPRIVFROMPDEV;
-    GETDMXINPUTFROMPRIV;
-    char *pt;
-
-    dmxCommonSaveState(priv);
-    if (priv->xkb) {
-#define NAME(x) \
- priv->xkb->names->x ? XGetAtomName(priv->display,priv->xkb->names->x) : NULL
-        info->names.keycodes = NAME(keycodes);
-        info->names.types    = NAME(types);
-        info->names.compat   = NAME(compat);
-        info->names.symbols  = NAME(symbols);
-        info->names.geometry = NAME(geometry);
-        info->freenames      = 1;
-#undef NAME
-        dmxLogInput(dmxInput,
-                    "XKEYBOARD: keycodes = %s\n", info->names.keycodes);
-        dmxLogInput(dmxInput,
-                    "XKEYBOARD: symbols  = %s\n", info->names.symbols);
-        dmxLogInput(dmxInput,
-                    "XKEYBOARD: geometry = %s\n", info->names.geometry);
-        if ((pt = strchr(info->names.keycodes, '+'))) *pt = '\0';
-    }
-    dmxCommonRestoreState(priv);
-}
-
-/** Turn \a pDev on (i.e., take input from \a pDev). */
-int dmxCommonKbdOn(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    if (priv->be) dmxCommonSaveState(priv);
-    priv->eventMask |= DMX_KEYBOARD_EVENT_MASK;
-    XSelectInput(priv->display, priv->window, priv->eventMask);
-    if (priv->be)
-        XSetInputFocus(priv->display, priv->window, RevertToPointerRoot,
-                       CurrentTime);
-    return -1;
-}
-
-/** Turn \a pDev off. */
-void dmxCommonKbdOff(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    priv->eventMask &= ~DMX_KEYBOARD_EVENT_MASK;
-    XSelectInput(priv->display, priv->window, priv->eventMask);
-    dmxCommonRestoreState(priv);
-}
-
-/** Turn \a pDev on (i.e., take input from \a pDev). */
-int dmxCommonOthOn(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    GETDMXINPUTFROMPRIV;
-    XEventClass event_list[DMX_MAX_XINPUT_EVENT_TYPES];
-    int         event_type[DMX_MAX_XINPUT_EVENT_TYPES];
-    int         count = 0;
-
-#define ADD(type)                                                            \
-    if (count < DMX_MAX_XINPUT_EVENT_TYPES) {                                \
-        type(priv->xi, event_type[count], event_list[count]);                \
-        if (event_type[count]) {                                             \
-            dmxMapInsert(dmxLocal, event_type[count], XI_##type);            \
-            ++count;                                                         \
-        }                                                                    \
-    } else {                                                                 \
-        dmxLog(dmxWarning, "More than %d event types for %s\n",              \
-               DMX_MAX_XINPUT_EVENT_TYPES, dmxInput->name);                  \
-    }
-
-    if (!(priv->xi = XOpenDevice(priv->display, dmxLocal->deviceId))) {
-        dmxLog(dmxWarning, "Cannot open %s device (id=%d) on %s\n",
-               dmxLocal->deviceName ? dmxLocal->deviceName : "(unknown)",
-               dmxLocal->deviceId, dmxInput->name);
-        return -1;
-    }
-    ADD(DeviceKeyPress);
-    ADD(DeviceKeyRelease);
-    ADD(DeviceButtonPress);
-    ADD(DeviceButtonRelease);
-    ADD(DeviceMotionNotify);
-    ADD(DeviceFocusIn);
-    ADD(DeviceFocusOut);
-    ADD(ProximityIn);
-    ADD(ProximityOut);
-    ADD(DeviceStateNotify);
-    ADD(DeviceMappingNotify);
-    ADD(ChangeDeviceNotify);
-    XSelectExtensionEvent(priv->display, priv->window, event_list, count);
-    
-    return -1;
-}
-
-/** Turn \a pDev off. */
-void dmxCommonOthOff(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    
-    if (priv->xi) XCloseDevice(priv->display, priv->xi);
-    priv->xi = NULL;
-}
-
-/** Fill the \a info structure with information needed to initialize \a
- * pDev. */ 
-void dmxCommonOthGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)
-{
-    GETPRIVFROMPDEV;
-    GETDMXINPUTFROMPRIV;
-    XExtensionVersion    *ext;
-    XDeviceInfo          *devices;
-    Display              *display = priv->display;
-    int                  num;
-    int                  i, j, k;
-    int                  (*handler)(Display *, char *, char *);
-
-    if (!display && !(display = XOpenDisplay(dmxInput->name)))
-        return;
-    
-    /* Print out information about the XInput Extension. */
-    handler = XSetExtensionErrorHandler(dmxInputExtensionErrorHandler);
-    ext     = XGetExtensionVersion(display, INAME);
-    XSetExtensionErrorHandler(handler);
-
-    if (ext && ext != (XExtensionVersion *)NoSuchExtension) {
-        XFree(ext);
-        devices = XListInputDevices(display, &num);
-        for (i = 0; i < num; i++) {
-            if (devices[i].id == (XID)dmxLocal->deviceId) {
-                XAnyClassPtr     any;
-                XKeyInfoPtr      ki;
-                XButtonInfoPtr   bi;
-                XValuatorInfoPtr vi;
-                for (j = 0, any = devices[i].inputclassinfo;
-                     j < devices[i].num_classes;
-                     any = (XAnyClassPtr)((char *)any + any->length), j++) {
-                    switch (any->class) {
-                    case KeyClass:
-                        ki = (XKeyInfoPtr)any;
-                        info->keyboard           = 1;
-                        info->keyClass           = 1;
-                        info->keySyms.minKeyCode = ki->min_keycode;
-                        info->keySyms.maxKeyCode = ki->max_keycode;
-                        info->kbdFeedbackClass   = 1;
-                        break;
-                    case ButtonClass:
-                        bi = (XButtonInfoPtr)any;
-                        info->buttonClass        = 1;
-                        info->numButtons         = bi->num_buttons;
-                        info->ptrFeedbackClass   = 1;
-                        break;
-                    case ValuatorClass:
-                                /* This assume all axes are either
-                                 * Absolute or Relative. */
-                        vi = (XValuatorInfoPtr)any;
-                        info->valuatorClass      = 1;
-                        if (vi->mode == Absolute)
-                            info->numAbsAxes     = vi->num_axes;
-                        else
-                            info->numRelAxes     = vi->num_axes;
-                        for (k = 0; k < vi->num_axes; k++) {
-                            info->res[k]         = vi->axes[k].resolution;
-                            info->minres[k]      = vi->axes[k].resolution;
-                            info->maxres[k]      = vi->axes[k].resolution;
-                            info->minval[k]      = vi->axes[k].min_value;
-                            info->maxval[k]      = vi->axes[k].max_value;
-                        }
-                        break;
-                    case FeedbackClass:
-                                /* Only keyboard and pointer feedback
-                                 * are handled at this time. */
-                        break;
-                    case ProximityClass:
-                        info->proximityClass     = 1;
-                        break;
-                    case FocusClass:
-                        info->focusClass         = 1;
-                        break;
-                    case OtherClass:
-                        break;
-                    }
-                }
-            }
-        }
-        XFreeDeviceList(devices);
-    }
-    if (display != priv->display) XCloseDisplay(display);
-}
-
-/** Obtain the mouse button mapping. */
-void dmxCommonMouGetMap(DevicePtr pDev, unsigned char *map, int *nButtons)
-{
-    GETPRIVFROMPDEV;
-    int i;
-    
-    *nButtons = XGetPointerMapping(priv->display, map, DMX_MAX_BUTTONS);
-    for (i = 0; i <= *nButtons; i++) map[i] = i;
-}
-
-static void *dmxCommonXSelect(DMXScreenInfo *dmxScreen, void *closure)
-{
-    myPrivate *priv = closure;
-    XSelectInput(dmxScreen->beDisplay, dmxScreen->scrnWin, priv->eventMask);
-    return NULL;
-}
-
-static void *dmxCommonAddEnabledDevice(DMXScreenInfo *dmxScreen, void *closure)
-{
-    AddEnabledDevice(XConnectionNumber(dmxScreen->beDisplay));
-    return NULL;
-}
-
-static void *dmxCommonRemoveEnabledDevice(DMXScreenInfo *dmxScreen,
-                                          void *closure)
-{
-    RemoveEnabledDevice(XConnectionNumber(dmxScreen->beDisplay));
-    return NULL;
-}
-
-/** Turn \a pDev on (i.e., take input from \a pDev). */
-int dmxCommonMouOn(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    GETDMXINPUTFROMPRIV;
-
-    priv->eventMask |= DMX_POINTER_EVENT_MASK;
-    if (dmxShadowFB) {
-        XWarpPointer(priv->display, priv->window, priv->window,
-                     0, 0, 0, 0,
-                     priv->initPointerX,
-                     priv->initPointerY);
-        dmxSync(&dmxScreens[dmxInput->scrnIdx], TRUE);
-    }
-    if (!priv->be) {
-        XSelectInput(priv->display, priv->window, priv->eventMask);
-        AddEnabledDevice(XConnectionNumber(priv->display));
-    } else {
-        dmxPropertyIterate(priv->be, dmxCommonXSelect, priv);
-        dmxPropertyIterate(priv->be, dmxCommonAddEnabledDevice, dmxInput);
-    }
-    
-    return -1;
-}
-
-/** Turn \a pDev off. */
-void dmxCommonMouOff(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    GETDMXINPUTFROMPRIV;
-    
-    priv->eventMask &= ~DMX_POINTER_EVENT_MASK;
-    if (!priv->be) {
-        RemoveEnabledDevice(XConnectionNumber(priv->display));
-        XSelectInput(priv->display, priv->window, priv->eventMask);
-    } else {
-        dmxPropertyIterate(priv->be, dmxCommonRemoveEnabledDevice, dmxInput);
-        dmxPropertyIterate(priv->be, dmxCommonXSelect, priv);
-    }
-}
-
-/** Given the global coordinates \a x and \a y, determine the screen
- * with the lowest number on which those coordinates lie.  If they are
- * not on any screen, return -1.  The number returned is an index into
- * \a dmxScreenInfo and is between -1 and \a dmxNumScreens - 1,
- * inclusive. */
-int dmxFindPointerScreen(int x, int y)
-{
-    int i;
-
-    for (i = 0; i < dmxNumScreens; i++) {
-	if (x >= dixScreenOrigins[i].x
-            && x < dixScreenOrigins[i].x + screenInfo.screens[i]->width
-            && y >= dixScreenOrigins[i].y
-            && y < dixScreenOrigins[i].y + screenInfo.screens[i]->height)
-	    return i;
-    }
-    return -1;
-}
-
-/** Returns a pointer to the private area for the device that comes just
- * prior to \a pDevice in the current \a dmxInput device list.  This is
- * used as the private area for the current device in some situations
- * (e.g., when a keyboard and mouse form a pair that should share the
- * same private area).  If the requested private area cannot be located,
- * then NULL is returned. */
-pointer dmxCommonCopyPrivate(DeviceIntPtr pDevice)
-{
-    GETDMXLOCALFROMPDEVICE;
-    DMXInputInfo *dmxInput = &dmxInputs[dmxLocal->inputIdx];
-    int          i;
-
-    for (i = 0; i < dmxInput->numDevs; i++)
-        if (dmxInput->devs[i] == dmxLocal && i)
-            return dmxInput->devs[i-1]->private;
-    return NULL;
-}
-
-/** This routine saves and resets some important state for the backend
- * and console device drivers:
- * - the modifier map is saved and set to 0 (so DMX controls the LEDs)
- * - the key click, bell, led, and repeat masks are saved and set to the
- * values that DMX claims to be using
- *
- * This routine and #dmxCommonRestoreState are used when the pointer
- * enters and leaves the console window, or when the backend window is
- * active or not active (for a full-screen window, this only happens at
- * server startup and server shutdown).
- */
-void dmxCommonSaveState(pointer private)
-{
-    GETPRIVFROMPRIVATE;
-    XKeyboardState   ks;
-    unsigned long    i;
-    XModifierKeymap  *modmap;
-
-    if (dmxInput->console) priv = dmxInput->devs[0]->private;
-    if (!priv->display || priv->stateSaved) return;
-    DMXDBG0("dmxCommonSaveState\n");
-    if (dmxUseXKB && (priv->xkb = XkbAllocKeyboard())) {
-        if (XkbGetIndicatorMap(priv->display, XkbAllIndicatorsMask, priv->xkb)
-            || XkbGetNames(priv->display, XkbAllNamesMask, priv->xkb)) {
-            dmxLogInput(dmxInput, "Could not get XKB information\n");
-            XkbFreeKeyboard(priv->xkb, 0, True);
-            priv->xkb = NULL;
-        } else {
-            if (priv->xkb->indicators) {
-                priv->savedIndicators = *priv->xkb->indicators;
-                for (i = 0; i < XkbNumIndicators; i++)
-                    if (priv->xkb->indicators->phys_indicators & (1 << i)) {
-                        priv->xkb->indicators->maps[i].flags
-                            = XkbIM_NoAutomatic;
-                    }
-                XkbSetIndicatorMap(priv->display, ~0, priv->xkb);
-            }
-        }
-    }
-
-    XGetKeyboardControl(priv->display, &ks);
-    priv->savedKctrl.click              = ks.key_click_percent;
-    priv->savedKctrl.bell               = ks.bell_percent;
-    priv->savedKctrl.bell_pitch         = ks.bell_pitch;
-    priv->savedKctrl.bell_duration      = ks.bell_duration;
-    priv->savedKctrl.leds               = ks.led_mask;
-    priv->savedKctrl.autoRepeat         = ks.global_auto_repeat;
-    for (i = 0; i < 32; i++)
-        priv->savedKctrl.autoRepeats[i] = ks.auto_repeats[i];
-    
-    dmxCommonKbdSetCtrl(priv->display, &priv->savedKctrl,
-                        &priv->dmxLocal->kctrl);
-
-    priv->savedModMap                   = XGetModifierMapping(priv->display);
-
-    modmap                              = XNewModifiermap(0);
-    XSetModifierMapping(priv->display, modmap);
-    if (dmxInput->scrnIdx != -1)
-        dmxSync(&dmxScreens[dmxInput->scrnIdx], TRUE);
-    XFreeModifiermap(modmap);
-
-    priv->stateSaved = 1;
-}
-
-/** This routine restores all the information saved by #dmxCommonSaveState. */
-void dmxCommonRestoreState(pointer private)
-{
-    GETPRIVFROMPRIVATE;
-    int retcode = -1;
-    CARD32 start;
-
-    if (dmxInput->console)
-        priv = dmxInput->devs[0]->private;
-    if (!priv->stateSaved)
-        return;
-    priv->stateSaved = 0;
-    
-    DMXDBG0("dmxCommonRestoreState\n");
-    if (priv->xkb) {
-        *priv->xkb->indicators = priv->savedIndicators;
-        XkbSetIndicatorMap(priv->display, ~0, priv->xkb);
-        XkbFreeKeyboard(priv->xkb, 0, True);
-        priv->xkb = 0;
-    }
-
-    for (start = GetTimeInMillis(); GetTimeInMillis() - start < 5000;) {
-        CARD32 tmp;
-        
-        retcode = XSetModifierMapping(priv->display, priv->savedModMap);
-        if (retcode == MappingSuccess)
-            break;
-        if (retcode == MappingBusy)
-            dmxLogInput(dmxInput, "Keyboard busy, waiting\n");
-        else
-            dmxLogInput(dmxInput, "Keyboard error, waiting\n");
-
-                                /* Don't generate X11 protocol for a bit */
-        for (tmp = GetTimeInMillis(); GetTimeInMillis() - tmp < 250;) {
-            usleep(250);            /* This ends up sleeping only until
-                                     * the next key press generates an
-                                     * interruption.  We make the delay
-                                     * relatively short in case the user
-                                     * pressed they keys quickly. */
-        }
-
-    }
-    if (retcode != MappingSuccess)
-        dmxLog(dmxWarning, "Unable to restore keyboard modifier state!\n");
-    
-    XFreeModifiermap(priv->savedModMap);
-    priv->savedModMap = NULL;
-
-    dmxCommonKbdSetCtrl(priv->display, NULL, &priv->savedKctrl);
-    priv->kctrlset = 0;         /* Invalidate copy */
-}
+/*

+ * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   David H. Dawes <dawes@xfree86.org>

+ *   Kevin E. Martin <kem@redhat.com>

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ */

+

+/** \file

+ *

+ * This file implements common routines used by the backend and console

+ * input devices.

+ */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#define DMX_STATE_DEBUG 0

+

+#include "dmxinputinit.h"

+#include "dmxcommon.h"

+#include "dmxconsole.h"

+#include "dmxprop.h"

+#include "dmxsync.h"

+#include "dmxmap.h"

+

+#include "inputstr.h"

+#include "input.h"

+#include <X11/keysym.h>

+#include "mipointer.h"

+#include "scrnintstr.h"

+

+#include <unistd.h>             /* For usleep() */

+

+#if DMX_STATE_DEBUG

+#define DMXDBG0(f)               dmxLog(dmxDebug,f)

+#else

+#define DMXDBG0(f)

+#endif

+

+/** Each device has a private area that is visible only from inside the

+ * driver code. */ 

+typedef struct _myPrivate {

+    DMX_COMMON_PRIVATE;

+} myPrivate;

+

+static void dmxCommonKbdSetAR(Display *display,

+                              unsigned char *old, unsigned char *new)

+{

+    XKeyboardControl kc;

+    XKeyboardState   ks;

+    unsigned long    mask = KBKey | KBAutoRepeatMode;

+    int              i, j;

+    int              minKeycode, maxKeycode;

+

+    if (!old) {

+        XGetKeyboardControl(display, &ks);

+        old = (unsigned char *)ks.auto_repeats;

+    }

+

+    XDisplayKeycodes(display, &minKeycode, &maxKeycode);

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

+        if (!old || old[i] != new[i]) {

+            for (j = 0; j < 8; j++) {

+                if ((new[i] & (1 << j)) != (old[i] & (1 << j))) {

+                    kc.key              = i * 8 + j;

+                    kc.auto_repeat_mode = ((new[i] & (1 << j))

+                                           ? AutoRepeatModeOn

+                                           : AutoRepeatModeOff);

+                    if (kc.key >= minKeycode && kc.key <= maxKeycode)

+                        XChangeKeyboardControl(display, mask, &kc);

+                }

+            }

+        }

+    }

+}

+

+static void dmxCommonKbdSetLeds(Display *display, unsigned long new)

+{

+    int              i;

+    XKeyboardControl kc;

+

+    for (i = 0; i < 32; i++) {

+        kc.led      = i + 1;

+        kc.led_mode = (new & (1 << i)) ? LedModeOn : LedModeOff;

+        XChangeKeyboardControl(display, KBLed | KBLedMode, &kc);

+    }

+}

+

+static void dmxCommonKbdSetCtrl(Display *display,

+                                KeybdCtrl *old, KeybdCtrl *new)

+{

+    XKeyboardControl kc;

+    unsigned long    mask = KBKeyClickPercent | KBAutoRepeatMode;

+

+    if (!old

+        || old->click         != new->click

+        || old->autoRepeat    != new->autoRepeat) {

+        

+        kc.key_click_percent = new->click;

+        kc.auto_repeat_mode  = new->autoRepeat;

+

+        XChangeKeyboardControl(display, mask, &kc);

+    }

+

+    dmxCommonKbdSetLeds(display, new->leds);

+    dmxCommonKbdSetAR(display, old ? old->autoRepeats : NULL,

+                      new->autoRepeats);

+}

+

+static void dmxCommonMouSetCtrl(Display *display, PtrCtrl *old, PtrCtrl *new)

+{

+    Bool do_accel, do_threshold;

+    

+    if (!old

+        || old->num != new->num

+        || old->den != new->den

+        || old->threshold != new->threshold) {

+        do_accel     = (new->num > 0 && new->den > 0);

+        do_threshold = (new->threshold > 0);

+        if (do_accel || do_threshold) {

+            XChangePointerControl(display, do_accel, do_threshold,

+                                  new->num, new->den, new->threshold);

+        }

+    }

+}

+

+/** Update the keyboard control. */

+void dmxCommonKbdCtrl(DevicePtr pDev, KeybdCtrl *ctrl)

+{

+    GETPRIVFROMPDEV;

+

+    if (!priv->stateSaved && priv->be) dmxCommonSaveState(priv);

+    if (!priv->display || !priv->stateSaved) return;

+    dmxCommonKbdSetCtrl(priv->display,

+                        priv->kctrlset ? &priv->kctrl : NULL,

+                        ctrl);

+    priv->kctrl    = *ctrl;

+    priv->kctrlset = 1;

+}

+

+/** Update the mouse control. */

+void dmxCommonMouCtrl(DevicePtr pDev, PtrCtrl *ctrl)

+{

+    GETPRIVFROMPDEV;

+

+                                /* Don't set the acceleration for the

+                                 * console, because that should be

+                                 * controlled by the X server that the

+                                 * console is running on.  Otherwise,

+                                 * the acceleration for the console

+                                 * window would be unexpected for the

+                                 * scale of the window. */

+    if (priv->be) {

+        dmxCommonMouSetCtrl(priv->display,

+                            priv->mctrlset ? &priv->mctrl : NULL,

+                            ctrl);

+        priv->mctrl    = *ctrl;

+        priv->mctrlset = 1;

+    }

+}

+

+/** Sound they keyboard bell. */

+void dmxCommonKbdBell(DevicePtr pDev, int percent,

+                      int volume, int pitch, int duration)

+{

+    GETPRIVFROMPDEV;

+    XKeyboardControl kc;

+    XKeyboardState   ks;

+    unsigned long    mask = KBBellPercent | KBBellPitch | KBBellDuration;

+    

+    if (!priv->be) XGetKeyboardControl(priv->display, &ks);

+    kc.bell_percent  = volume;

+    kc.bell_pitch    = pitch;

+    kc.bell_duration = duration;

+    XChangeKeyboardControl(priv->display, mask, &kc);

+    XBell(priv->display, percent);

+    if (!priv->be) {

+        kc.bell_percent  = ks.bell_percent;

+        kc.bell_pitch    = ks.bell_pitch;

+        kc.bell_duration = ks.bell_duration;

+        XChangeKeyboardControl(priv->display, mask, &kc);

+    }

+}

+

+/** Get the keyboard mapping. */

+void dmxCommonKbdGetMap(DevicePtr pDev, KeySymsPtr pKeySyms, CARD8 *pModMap)

+{

+    GETPRIVFROMPDEV;

+    int             min_keycode;

+    int             max_keycode;

+    int             map_width;

+    KeySym          *keyboard_mapping;

+    XModifierKeymap *modifier_mapping;

+    int             i, j;

+

+                                /* Compute pKeySyms.  Cast

+                                 * XGetKeyboardMapping because of

+                                 * compiler warning on 64-bit machines.

+                                 * We assume pointers to 32-bit and

+                                 * 64-bit ints are the same. */

+    XDisplayKeycodes(priv->display, &min_keycode, &max_keycode);

+    keyboard_mapping     = (KeySym *)XGetKeyboardMapping(priv->display,

+                                                         min_keycode,

+                                                         max_keycode

+                                                         - min_keycode + 1,

+                                                         &map_width);

+    pKeySyms->minKeyCode = min_keycode;

+    pKeySyms->maxKeyCode = max_keycode;

+    pKeySyms->mapWidth   = map_width;

+    pKeySyms->map        = keyboard_mapping;

+

+

+                                /* Compute pModMap  */

+    modifier_mapping     = XGetModifierMapping(priv->display);

+    for (i = 0; i < MAP_LENGTH; i++)

+        pModMap[i] = 0;

+    for (j = 0; j < 8; j++) {

+        int max_keypermod = modifier_mapping->max_keypermod;

+        

+        for (i = 0; i < max_keypermod; i++) {

+            CARD8 keycode = modifier_mapping->modifiermap[j*max_keypermod + i];

+            if (keycode)

+                pModMap[keycode] |= 1 << j;

+        }

+    }

+    XFreeModifiermap(modifier_mapping);

+}

+

+/** Fill in the XKEYBOARD parts of the \a info structure for the

+ * specified \a pDev. */

+void dmxCommonKbdGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)

+{

+    GETPRIVFROMPDEV;

+    GETDMXINPUTFROMPRIV;

+    char *pt;

+

+    dmxCommonSaveState(priv);

+    if (priv->xkb) {

+#define NAME(x) \

+ priv->xkb->names->x ? XGetAtomName(priv->display,priv->xkb->names->x) : NULL

+        info->names.keycodes = NAME(keycodes);

+        info->names.types    = NAME(types);

+        info->names.compat   = NAME(compat);

+        info->names.symbols  = NAME(symbols);

+        info->names.geometry = NAME(geometry);

+        info->freenames      = 1;

+#undef NAME

+        dmxLogInput(dmxInput,

+                    "XKEYBOARD: keycodes = %s\n", info->names.keycodes);

+        dmxLogInput(dmxInput,

+                    "XKEYBOARD: symbols  = %s\n", info->names.symbols);

+        dmxLogInput(dmxInput,

+                    "XKEYBOARD: geometry = %s\n", info->names.geometry);

+        if ((pt = strchr(info->names.keycodes, '+'))) *pt = '\0';

+    }

+    dmxCommonRestoreState(priv);

+}

+

+/** Turn \a pDev on (i.e., take input from \a pDev). */

+int dmxCommonKbdOn(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    if (priv->be) dmxCommonSaveState(priv);

+    priv->eventMask |= DMX_KEYBOARD_EVENT_MASK;

+    XSelectInput(priv->display, priv->window, priv->eventMask);

+    if (priv->be)

+        XSetInputFocus(priv->display, priv->window, RevertToPointerRoot,

+                       CurrentTime);

+    return -1;

+}

+

+/** Turn \a pDev off. */

+void dmxCommonKbdOff(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    priv->eventMask &= ~DMX_KEYBOARD_EVENT_MASK;

+    XSelectInput(priv->display, priv->window, priv->eventMask);

+    dmxCommonRestoreState(priv);

+}

+

+/** Turn \a pDev on (i.e., take input from \a pDev). */

+int dmxCommonOthOn(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    GETDMXINPUTFROMPRIV;

+    XEventClass event_list[DMX_MAX_XINPUT_EVENT_TYPES];

+    int         event_type[DMX_MAX_XINPUT_EVENT_TYPES];

+    int         count = 0;

+

+#define ADD(type)                                                            \

+    if (count < DMX_MAX_XINPUT_EVENT_TYPES) {                                \

+        type(priv->xi, event_type[count], event_list[count]);                \

+        if (event_type[count]) {                                             \

+            dmxMapInsert(dmxLocal, event_type[count], XI_##type);            \

+            ++count;                                                         \

+        }                                                                    \

+    } else {                                                                 \

+        dmxLog(dmxWarning, "More than %d event types for %s\n",              \

+               DMX_MAX_XINPUT_EVENT_TYPES, dmxInput->name);                  \

+    }

+

+    if (!(priv->xi = XOpenDevice(priv->display, dmxLocal->deviceId))) {

+        dmxLog(dmxWarning, "Cannot open %s device (id=%d) on %s\n",

+               dmxLocal->deviceName ? dmxLocal->deviceName : "(unknown)",

+               dmxLocal->deviceId, dmxInput->name);

+        return -1;

+    }

+    ADD(DeviceKeyPress);

+    ADD(DeviceKeyRelease);

+    ADD(DeviceButtonPress);

+    ADD(DeviceButtonRelease);

+    ADD(DeviceMotionNotify);

+    ADD(DeviceFocusIn);

+    ADD(DeviceFocusOut);

+    ADD(ProximityIn);

+    ADD(ProximityOut);

+    ADD(DeviceStateNotify);

+    ADD(DeviceMappingNotify);

+    ADD(ChangeDeviceNotify);

+    XSelectExtensionEvent(priv->display, priv->window, event_list, count);

+    

+    return -1;

+}

+

+/** Turn \a pDev off. */

+void dmxCommonOthOff(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    

+    if (priv->xi) XCloseDevice(priv->display, priv->xi);

+    priv->xi = NULL;

+}

+

+/** Fill the \a info structure with information needed to initialize \a

+ * pDev. */ 

+void dmxCommonOthGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)

+{

+    GETPRIVFROMPDEV;

+    GETDMXINPUTFROMPRIV;

+    XExtensionVersion    *ext;

+    XDeviceInfo          *devices;

+    Display              *display = priv->display;

+    int                  num;

+    int                  i, j, k;

+    XextErrorHandler     handler;

+

+    if (!display && !(display = XOpenDisplay(dmxInput->name)))

+        return;

+    

+    /* Print out information about the XInput Extension. */

+    handler = XSetExtensionErrorHandler(dmxInputExtensionErrorHandler);

+    ext     = XGetExtensionVersion(display, INAME);

+    XSetExtensionErrorHandler(handler);

+

+    if (ext && ext != (XExtensionVersion *)NoSuchExtension) {

+        XFree(ext);

+        devices = XListInputDevices(display, &num);

+        for (i = 0; i < num; i++) {

+            if (devices[i].id == (XID)dmxLocal->deviceId) {

+                XAnyClassPtr     any;

+                XKeyInfoPtr      ki;

+                XButtonInfoPtr   bi;

+                XValuatorInfoPtr vi;

+                for (j = 0, any = devices[i].inputclassinfo;

+                     j < devices[i].num_classes;

+                     any = (XAnyClassPtr)((char *)any + any->length), j++) {

+                    switch (any->class) {

+                    case KeyClass:

+                        ki = (XKeyInfoPtr)any;

+                        info->keyboard           = 1;

+                        info->keyClass           = 1;

+                        info->keySyms.minKeyCode = ki->min_keycode;

+                        info->keySyms.maxKeyCode = ki->max_keycode;

+                        info->kbdFeedbackClass   = 1;

+                        break;

+                    case ButtonClass:

+                        bi = (XButtonInfoPtr)any;

+                        info->buttonClass        = 1;

+                        info->numButtons         = bi->num_buttons;

+                        info->ptrFeedbackClass   = 1;

+                        break;

+                    case ValuatorClass:

+                                /* This assume all axes are either

+                                 * Absolute or Relative. */

+                        vi = (XValuatorInfoPtr)any;

+                        info->valuatorClass      = 1;

+                        if (vi->mode == Absolute)

+                            info->numAbsAxes     = vi->num_axes;

+                        else

+                            info->numRelAxes     = vi->num_axes;

+                        for (k = 0; k < vi->num_axes; k++) {

+                            info->res[k]         = vi->axes[k].resolution;

+                            info->minres[k]      = vi->axes[k].resolution;

+                            info->maxres[k]      = vi->axes[k].resolution;

+                            info->minval[k]      = vi->axes[k].min_value;

+                            info->maxval[k]      = vi->axes[k].max_value;

+                        }

+                        break;

+                    case FeedbackClass:

+                                /* Only keyboard and pointer feedback

+                                 * are handled at this time. */

+                        break;

+                    case ProximityClass:

+                        info->proximityClass     = 1;

+                        break;

+                    case FocusClass:

+                        info->focusClass         = 1;

+                        break;

+                    case OtherClass:

+                        break;

+                    }

+                }

+            }

+        }

+        XFreeDeviceList(devices);

+    }

+    if (display != priv->display) XCloseDisplay(display);

+}

+

+/** Obtain the mouse button mapping. */

+void dmxCommonMouGetMap(DevicePtr pDev, unsigned char *map, int *nButtons)

+{

+    GETPRIVFROMPDEV;

+    int i;

+    

+    *nButtons = XGetPointerMapping(priv->display, map, DMX_MAX_BUTTONS);

+    for (i = 0; i <= *nButtons; i++) map[i] = i;

+}

+

+static void *dmxCommonXSelect(DMXScreenInfo *dmxScreen, void *closure)

+{

+    myPrivate *priv = closure;

+    XSelectInput(dmxScreen->beDisplay, dmxScreen->scrnWin, priv->eventMask);

+    return NULL;

+}

+

+static void *dmxCommonAddEnabledDevice(DMXScreenInfo *dmxScreen, void *closure)

+{

+    AddEnabledDevice(XConnectionNumber(dmxScreen->beDisplay));

+    return NULL;

+}

+

+static void *dmxCommonRemoveEnabledDevice(DMXScreenInfo *dmxScreen,

+                                          void *closure)

+{

+    RemoveEnabledDevice(XConnectionNumber(dmxScreen->beDisplay));

+    return NULL;

+}

+

+/** Turn \a pDev on (i.e., take input from \a pDev). */

+int dmxCommonMouOn(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    GETDMXINPUTFROMPRIV;

+

+    priv->eventMask |= DMX_POINTER_EVENT_MASK;

+    if (dmxShadowFB) {

+        XWarpPointer(priv->display, priv->window, priv->window,

+                     0, 0, 0, 0,

+                     priv->initPointerX,

+                     priv->initPointerY);

+        dmxSync(&dmxScreens[dmxInput->scrnIdx], TRUE);

+    }

+    if (!priv->be) {

+        XSelectInput(priv->display, priv->window, priv->eventMask);

+        AddEnabledDevice(XConnectionNumber(priv->display));

+    } else {

+        dmxPropertyIterate(priv->be, dmxCommonXSelect, priv);

+        dmxPropertyIterate(priv->be, dmxCommonAddEnabledDevice, dmxInput);

+    }

+    

+    return -1;

+}

+

+/** Turn \a pDev off. */

+void dmxCommonMouOff(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    GETDMXINPUTFROMPRIV;

+    

+    priv->eventMask &= ~DMX_POINTER_EVENT_MASK;

+    if (!priv->be) {

+        RemoveEnabledDevice(XConnectionNumber(priv->display));

+        XSelectInput(priv->display, priv->window, priv->eventMask);

+    } else {

+        dmxPropertyIterate(priv->be, dmxCommonRemoveEnabledDevice, dmxInput);

+        dmxPropertyIterate(priv->be, dmxCommonXSelect, priv);

+    }

+}

+

+/** Given the global coordinates \a x and \a y, determine the screen

+ * with the lowest number on which those coordinates lie.  If they are

+ * not on any screen, return -1.  The number returned is an index into

+ * \a dmxScreenInfo and is between -1 and \a dmxNumScreens - 1,

+ * inclusive. */

+int dmxFindPointerScreen(int x, int y)

+{

+    int i;

+

+    for (i = 0; i < dmxNumScreens; i++) {

+	ScreenPtr pScreen = screenInfo.screens[i];

+	if (x >= pScreen->x && x < pScreen->x + pScreen->width &&

+	    y >= pScreen->y && y < pScreen->y + pScreen->height)

+	    return i;

+    }

+    return -1;

+}

+

+/** Returns a pointer to the private area for the device that comes just

+ * prior to \a pDevice in the current \a dmxInput device list.  This is

+ * used as the private area for the current device in some situations

+ * (e.g., when a keyboard and mouse form a pair that should share the

+ * same private area).  If the requested private area cannot be located,

+ * then NULL is returned. */

+pointer dmxCommonCopyPrivate(DeviceIntPtr pDevice)

+{

+    GETDMXLOCALFROMPDEVICE;

+    DMXInputInfo *dmxInput = &dmxInputs[dmxLocal->inputIdx];

+    int          i;

+

+    for (i = 0; i < dmxInput->numDevs; i++)

+        if (dmxInput->devs[i] == dmxLocal && i)

+            return dmxInput->devs[i-1]->private;

+    return NULL;

+}

+

+/** This routine saves and resets some important state for the backend

+ * and console device drivers:

+ * - the modifier map is saved and set to 0 (so DMX controls the LEDs)

+ * - the key click, bell, led, and repeat masks are saved and set to the

+ * values that DMX claims to be using

+ *

+ * This routine and #dmxCommonRestoreState are used when the pointer

+ * enters and leaves the console window, or when the backend window is

+ * active or not active (for a full-screen window, this only happens at

+ * server startup and server shutdown).

+ */

+void dmxCommonSaveState(pointer private)

+{

+    GETPRIVFROMPRIVATE;

+    XKeyboardState   ks;

+    unsigned long    i;

+    XModifierKeymap  *modmap;

+

+    if (dmxInput->console) priv = dmxInput->devs[0]->private;

+    if (!priv->display || priv->stateSaved) return;

+    DMXDBG0("dmxCommonSaveState\n");

+    if (dmxUseXKB && (priv->xkb = XkbAllocKeyboard())) {

+        if (XkbGetIndicatorMap(priv->display, XkbAllIndicatorsMask, priv->xkb)

+            || XkbGetNames(priv->display, XkbAllNamesMask, priv->xkb)) {

+            dmxLogInput(dmxInput, "Could not get XKB information\n");

+            XkbFreeKeyboard(priv->xkb, 0, True);

+            priv->xkb = NULL;

+        } else {

+            if (priv->xkb->indicators) {

+                priv->savedIndicators = *priv->xkb->indicators;

+                for (i = 0; i < XkbNumIndicators; i++)

+                    if (priv->xkb->indicators->phys_indicators & (1 << i)) {

+                        priv->xkb->indicators->maps[i].flags

+                            = XkbIM_NoAutomatic;

+                    }

+                XkbSetIndicatorMap(priv->display, ~0, priv->xkb);

+            }

+        }

+    }

+

+    XGetKeyboardControl(priv->display, &ks);

+    priv->savedKctrl.click              = ks.key_click_percent;

+    priv->savedKctrl.bell               = ks.bell_percent;

+    priv->savedKctrl.bell_pitch         = ks.bell_pitch;

+    priv->savedKctrl.bell_duration      = ks.bell_duration;

+    priv->savedKctrl.leds               = ks.led_mask;

+    priv->savedKctrl.autoRepeat         = ks.global_auto_repeat;

+    for (i = 0; i < 32; i++)

+        priv->savedKctrl.autoRepeats[i] = ks.auto_repeats[i];

+    

+    dmxCommonKbdSetCtrl(priv->display, &priv->savedKctrl,

+                        &priv->dmxLocal->kctrl);

+

+    priv->savedModMap                   = XGetModifierMapping(priv->display);

+

+    modmap                              = XNewModifiermap(0);

+    XSetModifierMapping(priv->display, modmap);

+    if (dmxInput->scrnIdx != -1)

+        dmxSync(&dmxScreens[dmxInput->scrnIdx], TRUE);

+    XFreeModifiermap(modmap);

+

+    priv->stateSaved = 1;

+}

+

+/** This routine restores all the information saved by #dmxCommonSaveState. */

+void dmxCommonRestoreState(pointer private)

+{

+    GETPRIVFROMPRIVATE;

+    int retcode = -1;

+    CARD32 start;

+

+    if (dmxInput->console)

+        priv = dmxInput->devs[0]->private;

+    if (!priv->stateSaved)

+        return;

+    priv->stateSaved = 0;

+    

+    DMXDBG0("dmxCommonRestoreState\n");

+    if (priv->xkb) {

+        *priv->xkb->indicators = priv->savedIndicators;

+        XkbSetIndicatorMap(priv->display, ~0, priv->xkb);

+        XkbFreeKeyboard(priv->xkb, 0, True);

+        priv->xkb = 0;

+    }

+

+    for (start = GetTimeInMillis(); GetTimeInMillis() - start < 5000;) {

+        CARD32 tmp;

+        

+        retcode = XSetModifierMapping(priv->display, priv->savedModMap);

+        if (retcode == MappingSuccess)

+            break;

+        if (retcode == MappingBusy)

+            dmxLogInput(dmxInput, "Keyboard busy, waiting\n");

+        else

+            dmxLogInput(dmxInput, "Keyboard error, waiting\n");

+

+                                /* Don't generate X11 protocol for a bit */

+        for (tmp = GetTimeInMillis(); GetTimeInMillis() - tmp < 250;) {

+            usleep(250);            /* This ends up sleeping only until

+                                     * the next key press generates an

+                                     * interruption.  We make the delay

+                                     * relatively short in case the user

+                                     * pressed they keys quickly. */

+        }

+

+    }

+    if (retcode != MappingSuccess)

+        dmxLog(dmxWarning, "Unable to restore keyboard modifier state!\n");

+    

+    XFreeModifiermap(priv->savedModMap);

+    priv->savedModMap = NULL;

+

+    dmxCommonKbdSetCtrl(priv->display, NULL, &priv->savedKctrl);

+    priv->kctrlset = 0;         /* Invalidate copy */

+}

diff --git a/xorg-server/hw/dmx/input/dmxconsole.c b/xorg-server/hw/dmx/input/dmxconsole.c
index 9542efacd..d4d73f2e8 100644
--- a/xorg-server/hw/dmx/input/dmxconsole.c
+++ b/xorg-server/hw/dmx/input/dmxconsole.c
@@ -1,1030 +1,1029 @@
-/*
- * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   David H. Dawes <dawes@xfree86.org>
- *   Kevin E. Martin <kem@redhat.com>
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- *
- * This file implements the console input devices.
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#define DMX_CONSOLE_DEBUG 0
-#define DMX_WINDOW_DEBUG  0
-
-#include "dmxinputinit.h"
-#include "dmxevents.h"
-#include "dmxconsole.h"
-#include "dmxcommon.h"
-#include "dmxscrinit.h"
-#include "dmxcb.h"
-#include "dmxsync.h"
-
-#include "inputstr.h"
-#include "input.h"
-#include "mipointer.h"
-#include "windowstr.h"
-
-#define CONSOLE_NUM 3
-#define CONSOLE_DEN 4
-#define DMX_CONSOLE_NAME "DMX Console"
-#define DMX_RES_NAME     "Xdmx"
-#define DMX_RES_CLASS    "XDmx"
-#define CONSOLE_BG_COLOR "gray75"
-#define CONSOLE_FG_COLOR "black"
-#define CONSOLE_SCREEN_BG_COLOR "white"
-#define CONSOLE_SCREEN_FG_COLOR "black"
-#define CONSOLE_SCREEN_DET_COLOR "gray75"
-#define CONSOLE_SCREEN_CUR_COLOR "red"
-
-#if DMX_CONSOLE_DEBUG
-#define DMXDBG0(f)               dmxLog(dmxDebug,f)
-#define DMXDBG1(f,a)             dmxLog(dmxDebug,f,a)
-#define DMXDBG2(f,a,b)           dmxLog(dmxDebug,f,a,b)
-#define DMXDBG3(f,a,b,c)         dmxLog(dmxDebug,f,a,b,c)
-#define DMXDBG4(f,a,b,c,d)       dmxLog(dmxDebug,f,a,b,c,d)
-#define DMXDBG5(f,a,b,c,d,e)     dmxLog(dmxDebug,f,a,b,c,d,e)
-#define DMXDBG6(f,a,b,c,d,e,g)   dmxLog(dmxDebug,f,a,b,c,d,e,g)
-#define DMXDBG7(f,a,b,c,d,e,g,h) dmxLog(dmxDebug,f,a,b,c,d,e,g,h)
-#else
-#define DMXDBG0(f)
-#define DMXDBG1(f,a)
-#define DMXDBG2(f,a,b)
-#define DMXDBG3(f,a,b,c)
-#define DMXDBG4(f,a,b,c,d)
-#define DMXDBG5(f,a,b,c,d,e)
-#define DMXDBG6(f,a,b,c,d,e,g)
-#define DMXDBG7(f,a,b,c,d,e,g,h)
-#endif
-
-/* Private area for consoles. */
-typedef struct _myPrivate {
-    DMX_COMMON_PRIVATE;
-    int                     lastX;
-    int                     lastY;
-    int                     globalX;
-    int                     globalY;
-    int                     curX;
-    int                     curY;
-    int                     width;
-    int                     height;
-    int                     consWidth;
-    int                     consHeight;
-    double                  xScale;
-    double                  yScale;
-    XlibGC                  gc, gcDet, gcRev, gcCur;
-    int                     grabbed, fine, captured;
-    Cursor                  cursorNormal, cursorGrabbed, cursorEmpty;
-    Pixmap                  pixmap;
-    
-    CloseScreenProcPtr      CloseScreen;
-    struct _myPrivate       *next; /* for closing multiple consoles */
-    int                     initialized;
-    DevicePtr               mou, kbd;
-} myPrivate;
-
-static int scalex(myPrivate *priv, int x)
-{
-    return (int)((x * priv->xScale) + .5);
-}
-
-static int scaley(myPrivate *priv, int y)
-{
-    return (int)((y * priv->yScale) + .5);
-}
-
-static int unscalex(myPrivate *priv, int x)
-{
-    return (int)((x / priv->xScale) + .5);
-}
-
-static int unscaley(myPrivate *priv, int y)
-{
-    return (int)((y / priv->yScale) + .5);
-}
-
-/** Create the private area for \a pDevice. */
-pointer dmxConsoleCreatePrivate(DeviceIntPtr pDevice)
-{
-    GETDMXLOCALFROMPDEVICE;
-    myPrivate *priv = calloc(1, sizeof(*priv));
-    priv->dmxLocal  = dmxLocal;
-    return priv;
-}
-
-/** If \a private is non-NULL, free its associated memory. */
-void dmxConsoleDestroyPrivate(pointer private)
-{
-    if (private) free(private);
-}
-
-static void dmxConsoleDrawFineCursor(myPrivate *priv, XRectangle *rect)
-{
-    int size  = 6;
-    int x, y;
-    
-    XDrawLine(priv->display, priv->pixmap, priv->gcCur,
-              x = scalex(priv, priv->globalX) - size,
-              scaley(priv, priv->globalY),
-              scalex(priv, priv->globalX) + size,
-              scaley(priv, priv->globalY));
-    XDrawLine(priv->display, priv->pixmap, priv->gcCur,
-              scalex(priv, priv->globalX),
-              y = scaley(priv, priv->globalY) - size,
-              scalex(priv, priv->globalX),
-              scaley(priv, priv->globalY) + size);
-    if (priv->grabbed) {
-        XDrawLine(priv->display, priv->pixmap, priv->gcCur,
-                  scalex(priv, priv->globalX) - (int)(size / 1.4),
-                  scaley(priv, priv->globalY) - (int)(size / 1.4),
-                  scalex(priv, priv->globalX) + (int)(size / 1.4),
-                  scaley(priv, priv->globalY) + (int)(size / 1.4));
-        XDrawLine(priv->display, priv->pixmap, priv->gcCur,
-                  scalex(priv, priv->globalX) - (int)(size / 1.4),
-                  scaley(priv, priv->globalY) + (int)(size / 1.4),
-                  scalex(priv, priv->globalX) + (int)(size / 1.4),
-                  scaley(priv, priv->globalY) - (int)(size / 1.4));
-    }
-    if (rect) {
-        rect->x      = x;
-        rect->y      = y;
-        rect->width  = 2 * size;
-        rect->height = 2 * size;
-    }
-}
-
-static void dmxConsoleDrawWindows(pointer private)
-{
-    GETONLYPRIVFROMPRIVATE;
-    Display    *dpy   = priv->display;
-    int        i;
-    Region     whole, used, avail;
-    XRectangle rect;
-
-    whole       = XCreateRegion();
-    used        = XCreateRegion();
-    avail       = XCreateRegion();
-    rect.x      = 0;
-    rect.y      = 0;
-    rect.width  = priv->consWidth;
-    rect.height = priv->consHeight;
-    XUnionRectWithRegion(&rect, whole, whole);
-    
-    for (i = 0; i < dmxNumScreens; i++) {
-        WindowPtr     pRoot       = WindowTable[i];
-        WindowPtr     pChild;
-
-#if DMX_WINDOW_DEBUG
-        dmxLog(dmxDebug, "%lu %p %p %p 2\n",
-               pRoot->drawable.id,
-               pRoot->parent, pRoot->firstChild, pRoot->lastChild);
-#endif
-        
-        for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib) {
-            if (pChild->mapped
-                && pChild->realized) {
-#if DMX_WINDOW_DEBUG
-                dmxLog(dmxDebug, "  %p %d,%d %dx%d %d %d  %d RECTS\n",
-                       pChild,
-                       pChild->drawable.x,
-                       pChild->drawable.y,
-                       pChild->drawable.width,
-                       pChild->drawable.height,
-                       pChild->visibility,
-                       pChild->overrideRedirect,
-                       REGION_NUM_RECTS(&pChild->clipList));
-#endif
-                rect.x      = scalex(priv, pChild->drawable.x
-                                     + dixScreenOrigins[i].x);
-                rect.y      = scaley(priv, pChild->drawable.y
-                                     + dixScreenOrigins[i].y);
-                rect.width  = scalex(priv, pChild->drawable.width);
-                rect.height = scaley(priv, pChild->drawable.height);
-                XDrawRectangle(dpy, priv->pixmap, priv->gc,
-                               rect.x, rect.y, rect.width, rect.height);
-                XUnionRectWithRegion(&rect, used, used);
-                XSubtractRegion(whole, used, avail);
-                XSetRegion(dpy, priv->gc, avail);
-            }
-        }
-#ifdef PANORAMIX
-        if (!noPanoramiXExtension) break; /* Screen 0 valid with Xinerama */
-#endif
-    }
-    XDestroyRegion(avail);
-    XDestroyRegion(used);
-    XDestroyRegion(whole);
-    XSetClipMask(dpy, priv->gc, None);
-}
-
-static void dmxConsoleDraw(myPrivate *priv, int updateCursor, int update)
-{
-    GETDMXINPUTFROMPRIV;
-    Display       *dpy     = priv->display;
-    int           i;
-
-    XFillRectangle(dpy, priv->pixmap, priv->gc, 0, 0,
-                   priv->consWidth, priv->consHeight);
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        DMXScreenInfo *dmxScreen = &dmxScreens[i];
-	XFillRectangle(dpy, priv->pixmap,
-                       dmxScreen->beDisplay ? priv->gcRev : priv->gcDet,
-                       scalex(priv, dixScreenOrigins[i].x),
-                       scaley(priv, dixScreenOrigins[i].y),
-                       scalex(priv, screenInfo.screens[i]->width),
-                       scaley(priv, screenInfo.screens[i]->height));
-    }
-    for (i = 0; i < dmxNumScreens; i++) {
-        XDrawRectangle(dpy, priv->pixmap, priv->gc,
-                       scalex(priv, dixScreenOrigins[i].x),
-                       scaley(priv, dixScreenOrigins[i].y),
-                       scalex(priv, screenInfo.screens[i]->width),
-                       scaley(priv, screenInfo.screens[i]->height));
-    }
-    if (dmxInput->windows)          dmxConsoleDrawWindows(priv);
-    if (priv->fine && updateCursor) dmxConsoleDrawFineCursor(priv, 0);
-    if (update) {
-        XCopyArea(priv->display, priv->pixmap, priv->window, priv->gc,
-                  0, 0, priv->consWidth, priv->consHeight, 0, 0);
-        XSync(priv->display, False);          /* Not a backend display */
-    }
-}
-
-static void dmxConsoleClearCursor(myPrivate *priv, int x, int y,
-                                  XRectangle *rect)
-{
-    int        cw = 14, ch = 14;    /* Clear width and height */
-    
-    rect->x      = scalex(priv, x) - cw/2;
-    rect->y      = scaley(priv, y) - ch/2;
-    rect->width  = cw;
-    rect->height = ch;
-    XSetClipRectangles(priv->display, priv->gc, 0, 0, rect, 1, Unsorted);
-    XSetClipRectangles(priv->display, priv->gcDet, 0, 0, rect, 1, Unsorted);
-    XSetClipRectangles(priv->display, priv->gcRev, 0, 0, rect, 1, Unsorted);
-    dmxConsoleDraw(priv, 0, 0);
-    XSetClipMask(priv->display, priv->gc, None);
-    XSetClipMask(priv->display, priv->gcDet, None);
-    XSetClipMask(priv->display, priv->gcRev, None);
-}
-
-
-static void dmxConsoleUpdateFineCursor(myPrivate *priv)
-{
-    int        leave = 0;
-    XRectangle rects[2];
-
-    dmxConsoleClearCursor(priv, priv->globalX, priv->globalY, &rects[0]);
-    if (priv->dmxLocal->sendsCore) {
-        dmxGetGlobalPosition(&priv->globalX, &priv->globalY);
-    } else {
-        priv->globalX = priv->dmxLocal->lastX;
-        priv->globalY = priv->dmxLocal->lastY;
-    }
-    
-    priv->lastX   = scalex(priv, priv->width / 2);
-    priv->lastY   = scaley(priv, priv->height / 2);
-
-                                /* Compute new warp position, which may be
-                                   outside the window */
-    if (priv->globalX < 1 || priv->globalX >= priv->width) {
-        if (priv->globalX < 1) priv->lastX = 0;
-        else                   priv->lastX = scalex(priv, priv->width);
-        priv->lastY = scaley(priv, priv->globalY);
-        ++leave;
-    }
-    if (priv->globalY < 1 || priv->globalY >= priv->height) {
-        if (priv->globalY < 1) priv->lastY = 0;
-        else                   priv->lastY = scaley(priv, priv->height);
-        priv->lastX = scalex(priv, priv->globalX);
-        ++leave;
-    }
-
-                                /* Draw pseudo cursor in window */
-    dmxConsoleDrawFineCursor(priv, &rects[1]);
-
-    XSetClipRectangles(priv->display, priv->gc, 0, 0, rects, 2, Unsorted);
-    XCopyArea(priv->display, priv->pixmap, priv->window, priv->gc,
-              0, 0, priv->consWidth, priv->consHeight, 0, 0);
-    XSetClipMask(priv->display, priv->gc, None);
-
-    DMXDBG2("dmxConsoleUpdateFineCursor: WARP %d %d\n",
-            priv->lastX, priv->lastY);
-    XWarpPointer(priv->display, priv->window, priv->window,
-                 0, 0, 0, 0, priv->lastX, priv->lastY);
-    XSync(priv->display, False); /* Not a backend display */
-
-    if (leave) {
-        XEvent X;
-        while (XCheckMaskEvent(priv->display, PointerMotionMask, &X)) {
-            if (X.type == MotionNotify) {
-                if (X.xmotion.x != priv->lastX || X.xmotion.y != priv->lastY) {
-                    DMXDBG4("Ignoring motion to %d %d after leave frm %d %d\n",
-                            X.xmotion.x, X.xmotion.y,
-                            priv->lastX, priv->lastY);
-                }
-            } else {
-                dmxLog(dmxInfo, "Ignoring event (%d): %s ****************\n",
-                       X.type, dmxEventName(X.type));
-            }
-        }
-    }
-    DMXDBG6("dmxConsoleUpdateFineCursor: Warp %d %d on %d %d [%d %d]\n",
-            priv->lastX, priv->lastY,
-            scalex(priv, priv->width),
-            scaley(priv, priv->height),
-            priv->globalX, priv->globalY);
-}
-
-/** Whenever the window layout (size, position, stacking order) might be
- * changed, this routine is called with the \a pWindow that changed and
- * the \a type of change.  This routine is called in a conservative
- * fashion: the actual layout of the windows of the screen might not
- * have had any human-visible changes. */
-void dmxConsoleUpdateInfo(pointer private, DMXUpdateType type,
-                          WindowPtr pWindow)
-{
-    GETONLYPRIVFROMPRIVATE;
-    dmxConsoleDraw(priv, 1, 1);
-}
-
-static void dmxConsoleMoveAbsolute(myPrivate *priv, int x, int y,
-                                   DevicePtr pDev, dmxMotionProcPtr motion,
-                                   DMXBlockType block)
-{
-    int tmpX, tmpY, v[2];
-
-    tmpX = unscalex(priv, x);
-    tmpY = unscalex(priv, y);
-    DMXDBG6("dmxConsoleMoveAbsolute(,%d,%d) %d %d =? %d %d\n",
-            x, y, tmpX, tmpY, priv->curX, priv->curY);
-    if (tmpX == priv->curX && tmpY == priv->curY) return;
-    v[0] = unscalex(priv, x);
-    v[1] = unscaley(priv, y);
-    motion(pDev, v, 0, 2, DMX_ABSOLUTE_CONFINED, block);
-    /* dmxConsoleUpdatePosition gets called here by dmxCoreMotion */
-}
-
-static void dmxConsoleMoveRelative(myPrivate *priv, int x, int y,
-                                   DevicePtr pDev, dmxMotionProcPtr motion,
-                                   DMXBlockType block)
-{
-    int v[2];
-    /* Ignore the event generated from * warping back to middle */
-    if (x == priv->lastX && y == priv->lastY) return;
-    v[0] = priv->lastX - x;
-    v[1] = priv->lastY - y;
-    motion(pDev, v, 0, 2, DMX_RELATIVE, block);
-    /* dmxConsoleUpdatePosition gets called here by dmxCoreMotion */
-}
-
-/** This routine gets called from #dmxCoreMotion for each motion.  This
- * allows the console's notion of the cursor postion to change when
- * another input device actually caused the change. */
-void dmxConsoleUpdatePosition(pointer private, int x, int y)
-{
-    GETONLYPRIVFROMPRIVATE;
-    int                  tmpX, tmpY;
-    Display              *dpy          = priv->display;
-    static unsigned long dmxGeneration = 0;
-
-
-    tmpX = scalex(priv, x);
-    tmpY = scaley(priv, y);
-    DMXDBG6("dmxConsoleUpdatePosition(,%d,%d) new=%d,%d dims=%d,%d\n",
-            x, y, tmpX, tmpY, priv->consWidth, priv->consHeight);
-    
-    if (priv->fine) dmxConsoleUpdateFineCursor(priv);
-    if (tmpX != priv->curX || tmpY != priv->curY) {
-        if (tmpX < 0)                 tmpX = 0;
-        if (tmpY < 0)                 tmpY = 0;
-        if (tmpX >= priv->consWidth)  tmpX = priv->consWidth  - 1;
-        if (tmpY >= priv->consHeight) tmpY = priv->consHeight - 1;
-        priv->curX = tmpX;
-        priv->curY = tmpY;
-        if (!priv->fine) {
-            DMXDBG2("   WARP B %d %d\n", priv->curX, priv->curY);
-            XWarpPointer(dpy, priv->window,
-                         priv->window, 0, 0, 0, 0, tmpX, tmpY);
-            XSync(dpy, False); /* Not a backend display */
-        }
-    }
-    
-    if (dmxGeneration != serverGeneration) {
-        dmxGeneration = serverGeneration;
-        dmxConsoleDraw(priv, 1, 1);
-    }
-}
-
-/** Collect all pending events from the console's display.  Plase these
- * events on the server event queue using the \a motion and \a enqueue
- * routines.  The \a checkspecial routine is used to check for special
- * keys that need handling.  \a block tells if signals should be blocked
- * when updating the event queue. */
-void dmxConsoleCollectEvents(DevicePtr pDev,
-                             dmxMotionProcPtr motion,
-                             dmxEnqueueProcPtr enqueue,
-                             dmxCheckSpecialProcPtr checkspecial,
-                             DMXBlockType block)
-{
-    GETPRIVFROMPDEV;
-    GETDMXINPUTFROMPRIV;
-    Display              *dpy        = priv->display;
-    Window               win         = priv->window;
-    int                  width       = priv->width;
-    int                  height      = priv->height;
-    XEvent               X, N;
-    XSetWindowAttributes attribs;
-    static int           rInitialized = 0;
-    static Region        r;
-    XRectangle           rect;
-    static int           raising = 0, raiseX, raiseY; /* FIXME */
-
-    while (XPending(dpy)) {
-        XNextEvent(dpy, &X);
-	switch(X.type) {
-        case VisibilityNotify:
-            break;
-	case Expose:
-            DMXDBG5("dmxConsoleCollectEvents: Expose #%d %d %d %d %d\n",
-                    X.xexpose.count,
-                    X.xexpose.x, X.xexpose.y,
-                    X.xexpose.width, X.xexpose.height);
-            if (!rInitialized++) r = XCreateRegion();
-            rect.x      = X.xexpose.x;
-            rect.y      = X.xexpose.y;
-            rect.width  = X.xexpose.width;
-            rect.height = X.xexpose.height;
-            XUnionRectWithRegion(&rect, r, r);
-	    if (X.xexpose.count == 0) {
-                XSetRegion(dpy, priv->gc, r);
-                XSetRegion(dpy, priv->gcDet, r);
-                XSetRegion(dpy, priv->gcRev, r);
-                dmxConsoleDraw(priv, 1, 1);
-                XSetClipMask(dpy, priv->gc, None);
-                XSetClipMask(dpy, priv->gcDet, None);
-                XSetClipMask(dpy, priv->gcRev, None);
-                XDestroyRegion(r);
-                rInitialized = 0;
-            }
-	    break;
-	case ResizeRequest:
-            DMXDBG2("dmxConsoleCollectEvents: Resize %d %d\n",
-                    X.xresizerequest.width, X.xresizerequest.height);
-            priv->consWidth           = X.xresizerequest.width;
-            priv->consHeight          = X.xresizerequest.height;
-	    priv->xScale              = (double)priv->consWidth  / width;
-	    priv->yScale              = (double)priv->consHeight / height;
-	    attribs.override_redirect = True;
-	    XChangeWindowAttributes(dpy, win, CWOverrideRedirect, &attribs);
-	    XResizeWindow(dpy, win, priv->consWidth, priv->consHeight);
-            XFreePixmap(dpy, priv->pixmap);
-            priv->pixmap = XCreatePixmap(dpy,
-                                         RootWindow(dpy, DefaultScreen(dpy)),
-                                         priv->consWidth,
-                                         priv->consHeight,
-                                         DefaultDepth(dpy,DefaultScreen(dpy)));
-	    dmxConsoleDraw(priv, 1, 1);
-	    attribs.override_redirect = False;
-	    XChangeWindowAttributes(dpy, win, CWOverrideRedirect, &attribs);
-	    break;
-        case LeaveNotify:
-            DMXDBG4("dmxConsoleCollectEvents: Leave @ %d,%d; r=%d f=%d\n",
-                    X.xcrossing.x, X.xcrossing.y, raising, priv->fine);
-            if (!priv->captured) dmxCommonRestoreState(priv);
-            else {
-                dmxConsoleUncapture(dmxInput);
-                dmxCommonRestoreState(priv);
-            }
-            break;
-        case EnterNotify:
-            DMXDBG6("dmxConsoleCollectEvents: Enter %d,%d r=%d f=%d (%d,%d)\n",
-                    X.xcrossing.x, X.xcrossing.y, raising, priv->fine,
-                    priv->curX, priv->curY);
-            dmxCommonSaveState(priv);
-            if (raising) {
-                raising = 0;
-                dmxConsoleMoveAbsolute(priv, raiseX, raiseY,
-                                       priv->mou, motion, block);
-            } else {
-                if (priv->fine) {
-                    /* The raise will generate an event near the center,
-                     * which is not where the cursor should be.  So we
-                     * save the real position, do the raise, and move
-                     * the cursor here again after the raise generates
-                     * the event. */
-                    raising = 1;
-                    raiseX = X.xcrossing.x;
-                    raiseY = X.xcrossing.y;
-                    XRaiseWindow(dpy, priv->window);
-                }
-                XSync(dpy, False); /* Not a backend display */
-                if (!X.xcrossing.x && !X.xcrossing.y)
-                    dmxConsoleMoveAbsolute(priv, priv->curX, priv->curY,
-                                           priv->mou, motion, block);
-            }
-            break;
-	case MotionNotify:
-            if (priv->curX == X.xmotion.x && priv->curY == X.xmotion.y)
-                continue;
-            if (XPending(dpy)) { /* do motion compression */
-                XPeekEvent(dpy, &N);
-                if (N.type == MotionNotify) continue;
-            }
-            DMXDBG2("dmxConsoleCollectEvents: Motion %d %d\n",
-                    X.xmotion.x, X.xmotion.y);
-            if (raising) {
-                raising = 0;
-                dmxConsoleMoveAbsolute(priv, raiseX, raiseY,
-                                       priv->mou, motion, block);
-            } else {
-                if (priv->fine)
-                    dmxConsoleMoveRelative(priv, X.xmotion.x, X.xmotion.y,
-                                           priv->mou, motion, block);
-                else
-                    dmxConsoleMoveAbsolute(priv, X.xmotion.x, X.xmotion.y,
-                                           priv->mou, motion, block);
-            }
-	    break;
-        case KeyPress:
-        case KeyRelease:
-            enqueue(priv->kbd, X.type, X.xkey.keycode, 0, NULL, block);
-            break;
-        default:
-                                /* Pass the whole event here, because
-                                 * this may be an extension event. */
-            enqueue(priv->mou, X.type, X.xbutton.button, 0, &X, block);
-	    break;
-	}
-    }
-}
-
-static void dmxCloseConsole(myPrivate *priv)
-{
-    GETDMXINPUTFROMPRIV;
-    dmxCommonRestoreState(priv);
-    if (priv->display) {
-        XFreeGC(priv->display, priv->gc);
-        XFreeGC(priv->display, priv->gcDet);
-        XFreeGC(priv->display, priv->gcRev);
-        XFreeGC(priv->display, priv->gcCur);
-        if (!dmxInput->console) XCloseDisplay(priv->display);
-    }
-    priv->display = NULL;
-}
-
-static Bool dmxCloseConsoleScreen(int idx, ScreenPtr pScreen)
-{
-    myPrivate *priv, *last;
-
-    for (last = priv = (myPrivate *)dixLookupPrivate(&pScreen->devPrivates,
-						     dmxScreenPrivateKey);
-         priv;
-         priv = priv->next) dmxCloseConsole(last = priv);
-    
-    DMX_UNWRAP(CloseScreen, last, pScreen);
-    return pScreen->CloseScreen(idx, pScreen);
-}
-
-static Cursor dmxConsoleCreateEmptyCursor(myPrivate *priv)
-{
-    char    noCursorData[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-    Pixmap  pixmap;
-    Cursor  cursor;
-    XColor  color, tmpColor;
-    Display *dpy = priv->display;
-
-                                 /* Create empty cursor for window */
-    pixmap = XCreateBitmapFromData(priv->display, priv->window,
-                                   noCursorData, 8, 8);
-    if (!XAllocNamedColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)),
-                          "black",
-                          &color,
-                          &tmpColor))
-        dmxLog(dmxFatal, "Cannot allocate color for cursor\n");
-    cursor = XCreatePixmapCursor(dpy, pixmap, pixmap, &color, &color, 0, 0);
-    XFreePixmap(dpy, pixmap);
-    return cursor;
-}
-
-static void dmxConsoleComputeWidthHeight(myPrivate *priv,
-                                         int *width, int *height,
-                                         double *xScale, double *yScale,
-                                         int *consWidth, int *consHeight)
-{
-    int     screen;
-    Display *dpy = priv->display;
-
-    *width      = 0;
-    *height     = 0;
-    *xScale     = 1.0;
-    *yScale     = 1.0;
-
-    screen      = DefaultScreen(dpy);
-    *consWidth  = DisplayWidth(dpy, screen)  * CONSOLE_NUM / CONSOLE_DEN;
-    *consHeight = DisplayHeight(dpy, screen) * CONSOLE_NUM / CONSOLE_DEN;
-
-    if (*consWidth  < 1) *consWidth  = 1;
-    if (*consHeight < 1) *consHeight = 1;
-
-#if 1
-                                /* Always keep the console size similar
-                                 * to the global bounding box. */
-    *width  = dmxGlobalWidth;
-    *height = dmxGlobalHeight;
-#else
-                                /* Make the console window as big as
-                                 * possible by computing the visible
-                                 * bounding box. */
-    for (i = 0; i < dmxNumScreens; i++) {
-	if (dixScreenOrigins[i].x+screenInfo.screens[i]->width > *width)
-	    *width = dixScreenOrigins[i].x+screenInfo.screens[i]->width;
-        
-	if (dixScreenOrigins[i].y+screenInfo.screens[i]->height > *height)
-	    *height = dixScreenOrigins[i].y+screenInfo.screens[i]->height;
-    }
-#endif
-
-    if ((double)*consWidth / *width < (double)*consHeight / *height)
-	*xScale = *yScale = (double)*consWidth / *width;
-    else
-	*xScale = *yScale = (double)*consHeight / *height;
-
-    *consWidth  = scalex(priv, *width);
-    *consHeight = scaley(priv, *height);
-    if (*consWidth  < 1) *consWidth  = 1;
-    if (*consHeight < 1) *consHeight = 1;
-}
-
-/** Re-initialized the console device described by \a pDev (after a
- * reconfig). */
-void dmxConsoleReInit(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    Display *dpy;
-
-    if (!priv || !priv->initialized) return;
-    dpy = priv->display;
-
-    dmxConsoleComputeWidthHeight(priv,
-                                 &priv->width, &priv->height,
-                                 &priv->xScale, &priv->yScale,
-                                 &priv->consWidth, &priv->consHeight);
-    XResizeWindow(dpy, priv->window, priv->consWidth, priv->consHeight);
-    XFreePixmap(dpy, priv->pixmap);
-    priv->pixmap = XCreatePixmap(dpy,
-                                 RootWindow(dpy, DefaultScreen(dpy)),
-                                 priv->consWidth,
-                                 priv->consHeight,
-                                 DefaultDepth(dpy,DefaultScreen(dpy)));
-    dmxConsoleDraw(priv, 1, 1);
-}
-
-/** Initialized the console device described by \a pDev. */
-void dmxConsoleInit(DevicePtr pDev)
-{
-    GETPRIVFROMPDEV;
-    DMXInputInfo         *dmxInput = &dmxInputs[dmxLocal->inputIdx];
-    int                  screen;
-    unsigned long        mask;
-    XSetWindowAttributes attribs;
-    Display              *dpy;
-    Window               win;
-    XGCValues            gcvals;
-    XColor               color;
-    XClassHint           class_hints;
-    unsigned long        tmp;
-
-    if (dmxLocal->type == DMX_LOCAL_MOUSE)    priv->mou = pDev;
-    if (dmxLocal->type == DMX_LOCAL_KEYBOARD) priv->kbd = pDev;
-    if (priv->initialized++) return; /* Only do once for mouse/keyboard pair */
-
-    if (!(dpy = priv->display = XOpenDisplay(dmxInput->name)))
-        dmxLog(dmxFatal,
-               "dmxOpenConsole: cannot open console display %s\n",
-               dmxInput->name);
-
-    /* Set up defaults */
-    dmxConsoleComputeWidthHeight(priv,
-                                 &priv->width, &priv->height,
-                                 &priv->xScale, &priv->yScale,
-                                 &priv->consWidth, &priv->consHeight);
-
-    /* Private initialization using computed values or constants. */
-    screen                   = DefaultScreen(dpy);
-    priv->initPointerX       = scalex(priv, priv->width / 2);
-    priv->initPointerY       = scaley(priv, priv->height / 2);
-    priv->eventMask          = (ButtonPressMask
-                                | ButtonReleaseMask
-                                | PointerMotionMask
-                                | EnterWindowMask
-                                | LeaveWindowMask
-                                | KeyPressMask
-                                | KeyReleaseMask
-                                | ExposureMask
-                                | ResizeRedirectMask);
-
-    mask = CWBackPixel | CWEventMask | CWColormap | CWOverrideRedirect;
-    attribs.colormap = DefaultColormap(dpy, screen);
-    if (XParseColor(dpy, attribs.colormap, CONSOLE_BG_COLOR, &color)
-        && XAllocColor(dpy, attribs.colormap, &color)) {
-	attribs.background_pixel = color.pixel;
-    } else 
-        attribs.background_pixel = WhitePixel(dpy, screen);
-
-    attribs.event_mask        = priv->eventMask;
-    attribs.override_redirect = False;
-    
-    win = priv->window = XCreateWindow(dpy,
-                                       RootWindow(dpy, screen),
-                                       0, 0, priv->consWidth, priv->consHeight,
-                                       0,
-                                       DefaultDepth(dpy, screen),
-                                       InputOutput,
-                                       DefaultVisual(dpy, screen),
-                                       mask, &attribs);
-    priv->pixmap = XCreatePixmap(dpy, RootWindow(dpy, screen),
-                                 priv->consWidth, priv->consHeight,
-                                 DefaultDepth(dpy, screen));
-
-                                /* Set up properties */
-    XStoreName(dpy, win, DMX_CONSOLE_NAME);
-    class_hints.res_name  = DMX_RES_NAME;
-    class_hints.res_class = DMX_RES_CLASS;
-    XSetClassHint(dpy, win, &class_hints);
-
-
-                                /* Map the window */
-    XMapWindow(dpy, win);
-
-                                /* Create cursors */
-    priv->cursorNormal  = XCreateFontCursor(dpy, XC_circle);
-    priv->cursorGrabbed = XCreateFontCursor(dpy, XC_spider);
-    priv->cursorEmpty   = dmxConsoleCreateEmptyCursor(priv);
-    XDefineCursor(dpy, priv->window, priv->cursorNormal);
-
-                                /* Create GC */
-    mask = (GCFunction | GCPlaneMask | GCClipMask | GCForeground |
-	    GCBackground | GCLineWidth | GCLineStyle | GCCapStyle |
-	    GCFillStyle | GCGraphicsExposures);
-    gcvals.function = GXcopy;
-    gcvals.plane_mask = AllPlanes;
-    gcvals.clip_mask = None;
-    if (XParseColor(dpy, attribs.colormap, CONSOLE_SCREEN_FG_COLOR, &color)
-        && XAllocColor(dpy, attribs.colormap, &color)) {
-	gcvals.foreground = color.pixel;
-    } else
-	gcvals.foreground = BlackPixel(dpy, screen);
-    if (XParseColor(dpy, attribs.colormap, CONSOLE_SCREEN_BG_COLOR, &color)
-        && XAllocColor(dpy, attribs.colormap, &color)) {
-	gcvals.background = color.pixel;
-    } else
-	gcvals.background = WhitePixel(dpy, screen);
-    gcvals.line_width         = 0;
-    gcvals.line_style         = LineSolid;
-    gcvals.cap_style          = CapNotLast;
-    gcvals.fill_style         = FillSolid;
-    gcvals.graphics_exposures = False;
-    
-    priv->gc = XCreateGC(dpy, win, mask, &gcvals);
-
-    tmp               = gcvals.foreground;
-    if (XParseColor(dpy, attribs.colormap, CONSOLE_SCREEN_DET_COLOR, &color)
-        && XAllocColor(dpy, attribs.colormap, &color)) {
-        gcvals.foreground = color.pixel;
-    } else
-        gcvals.foreground = BlackPixel(dpy, screen);
-    priv->gcDet = XCreateGC(dpy, win, mask, &gcvals);
-    gcvals.foreground = tmp;
-
-    tmp               = gcvals.background;
-    gcvals.background = gcvals.foreground;
-    gcvals.foreground = tmp;
-    priv->gcRev = XCreateGC(dpy, win, mask, &gcvals);
-    
-    gcvals.background = gcvals.foreground;
-    if (XParseColor(dpy, attribs.colormap, CONSOLE_SCREEN_CUR_COLOR, &color)
-        && XAllocColor(dpy, attribs.colormap, &color)) {
-        gcvals.foreground = color.pixel;
-    } else
-        gcvals.foreground = BlackPixel(dpy, screen);
-    priv->gcCur = XCreateGC(dpy, win, mask, &gcvals);
-
-    dmxConsoleDraw(priv, 1, 1);
-
-    if (dixLookupPrivate(&screenInfo.screens[0]->devPrivates,
-			 dmxScreenPrivateKey))
-        priv->next = dixLookupPrivate(&screenInfo.screens[0]->devPrivates,
-				      dmxScreenPrivateKey);
-    else 
-        DMX_WRAP(CloseScreen, dmxCloseConsoleScreen,
-                 priv, screenInfo.screens[0]);
-    dixSetPrivate(&screenInfo.screens[0]->devPrivates, dmxScreenPrivateKey,
-		  priv);
-}
-
-/** Fill in the \a info structure for the specified \a pDev.  Only used
- * for pointers. */
-void dmxConsoleMouGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)
-{
-    GETPRIVFROMPDEV;
-
-    info->buttonClass      = 1;
-    dmxCommonMouGetMap(pDev, info->map, &info->numButtons);
-    info->valuatorClass    = 1;
-    info->numRelAxes       = 2;
-    info->minval[0] = 0;
-    info->minval[1] = 0;
-    /* max possible console window size: */
-    info->maxval[0] = DisplayWidth(priv->display, DefaultScreen(priv->display));
-    info->maxval[1] = DisplayHeight(priv->display, DefaultScreen(priv->display));
-    info->res[0]           = 1;
-    info->minres[0]        = 0;
-    info->maxres[0]        = 1;
-    info->ptrFeedbackClass = 1;
-}
-
-/** Fill in the \a info structure for the specified \a pDev.  Only used
- * for keyboard. */
-void dmxConsoleKbdGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)
-{
-    dmxCommonKbdGetInfo(pDev, info);
-    info->keyboard         = 1;
-    info->keyClass         = 1;
-    dmxCommonKbdGetMap(pDev, &info->keySyms, info->modMap);
-    info->freemap          = 1;
-    info->focusClass       = 1;
-    info->kbdFeedbackClass = 1;
-}
-
-/** Handle special console-only keys. */
-int dmxConsoleFunctions(pointer private, DMXFunctionType function)
-{
-    GETONLYPRIVFROMPRIVATE;
-    XRectangle rect;
-    Display    *dpy = priv->display;
-
-    switch (function) {
-    case DMX_FUNCTION_FINE:
-        if (priv->fine) {
-            priv->fine = 0;
-            dmxConsoleClearCursor(priv, priv->globalX, priv->globalY, &rect);
-            XSetClipRectangles(dpy, priv->gc, 0, 0, &rect, 1, Unsorted);
-            XCopyArea(dpy, priv->pixmap, priv->window, priv->gc,
-                      0, 0, priv->consWidth, priv->consHeight, 0, 0);
-            XSetClipMask(dpy, priv->gc, None);
-            
-            XDefineCursor(dpy, priv->window,
-                          priv->grabbed
-                          ? priv->cursorGrabbed
-                          : priv->cursorNormal);
-            XWarpPointer(dpy, priv->window, priv->window,
-                         0, 0, 0, 0,
-                         scalex(priv, priv->globalX),
-                         scaley(priv, priv->globalY));
-            XSync(dpy, False); /* Not a backend display */
-        } else {
-            priv->fine = 1;
-            XRaiseWindow(dpy, priv->window);
-            XDefineCursor(dpy, priv->window, priv->cursorEmpty);
-            dmxConsoleUpdateFineCursor(priv);
-        }
-        return 1;
-    case DMX_FUNCTION_GRAB:
-        if (priv->grabbed) {
-            XUngrabKeyboard(dpy, CurrentTime);
-            XUngrabPointer(dpy, CurrentTime);
-            XDefineCursor(dpy, priv->window,
-                          priv->fine
-                          ? priv->cursorEmpty
-                          : priv->cursorNormal);
-        } else {
-            if (XGrabPointer(dpy, priv->window, True,
-                             0, GrabModeAsync, GrabModeAsync, priv->window,
-                             None, CurrentTime)) {
-                dmxLog(dmxError, "XGrabPointer failed\n");
-                return 0;
-            }
-            if (XGrabKeyboard(dpy, priv->window, True,
-                              GrabModeAsync, GrabModeAsync, CurrentTime)) {
-                dmxLog(dmxError, "XGrabKeyboard failed\n");
-                XUngrabPointer(dpy, CurrentTime);
-                return 0;
-            }
-            XDefineCursor(dpy, priv->window,
-                          priv->fine
-                          ? priv->cursorEmpty
-                          : priv->cursorGrabbed);
-        }
-        priv->grabbed = !priv->grabbed;
-        if (priv->fine) dmxConsoleUpdateFineCursor(priv);
-        return 1;
-    case DMX_FUNCTION_TERMINATE:
-        return 1;
-    default:
-        return 0;
-    }
-}
-
-static void dmxDump(void)
-{
-    int          i, j;
-    DMXInputInfo *dmxInput;
-    XEvent       X;
-    
-    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++) {
-        for (j = 0; j < dmxInput->numDevs; j++) {
-            DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[j];
-            myPrivate            *priv    = dmxLocal->private;
-            while (priv
-                   && priv->display
-                   && XCheckTypedEvent(priv->display, MotionNotify, &X)) {
-                DMXDBG4("dmxDump: %s/%d threw event away %d %s\n",
-                        dmxInput->name, j, X.type, dmxEventName(X.type));
-            }
-        }
-    }
-}
-
-/** This routine is used to warp the pointer into the console window
- * from anywhere on the screen.  It is used when backend and console
- * input are both being taken from the same X display. */
-void dmxConsoleCapture(DMXInputInfo *dmxInput)
-{
-    int     i;
-    XEvent  X;
-
-    DMXDBG0("dmxConsoleCapture\n");
-    dmxSync(NULL, TRUE);
-    for (i = 0; i < dmxInput->numDevs; i++) {
-        DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[i];
-        myPrivate            *priv    = dmxLocal->private;
-        if (dmxLocal->extType != DMX_LOCAL_TYPE_CONSOLE) continue;
-        if (dmxLocal->type    != DMX_LOCAL_MOUSE)        continue;
-        if (priv->captured)                              continue;
-        priv->captured = 2;     /* Ungrab only after proximal events. */
-        XRaiseWindow(priv->display, priv->window);
-        XSync(priv->display, False); /* Not a backend display */
-        while (XCheckTypedEvent(priv->display, MotionNotify, &X)) {
-            DMXDBG3("   Ignoring motion to %d %d after capture on %s\n",
-                    X.xmotion.x, X.xmotion.y, dmxInput->name);
-        }
-        XWarpPointer(priv->display, None,
-                     priv->window, 0, 0, 0, 0, priv->curX, priv->curY);
-        XSync(priv->display, False); /* Not a backend display */
-        dmxDump();
-        if (priv->fine) dmxConsoleUpdateFineCursor(priv);
-    }
-}
-
-/** Undo the capture that was done by #dmxConsoleCapture. */
-void dmxConsoleUncapture(DMXInputInfo *dmxInput)
-{
-    int i;
-
-    DMXDBG0("dmxConsoleUncapture\n");
-    dmxSync(NULL, TRUE);
-    for (i = 0; i < dmxInput->numDevs; i++) {
-        DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[i];
-        myPrivate            *priv    = dmxLocal->private;
-        if (dmxLocal->extType != DMX_LOCAL_TYPE_CONSOLE) continue;
-        if (dmxLocal->type    != DMX_LOCAL_MOUSE)        continue;
-        if (!priv->captured)                             continue;
-        priv->captured = 0;
-        XSync(priv->display, False); /* Not a backend display */
-    }
-}
+/*

+ * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   David H. Dawes <dawes@xfree86.org>

+ *   Kevin E. Martin <kem@redhat.com>

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ *

+ * This file implements the console input devices.

+ */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#define DMX_CONSOLE_DEBUG 0

+#define DMX_WINDOW_DEBUG  0

+

+#include "dmxinputinit.h"

+#include "dmxevents.h"

+#include "dmxconsole.h"

+#include "dmxcommon.h"

+#include "dmxscrinit.h"

+#include "dmxcb.h"

+#include "dmxsync.h"

+

+#include "inputstr.h"

+#include "input.h"

+#include "mipointer.h"

+#include "windowstr.h"

+

+#define CONSOLE_NUM 3

+#define CONSOLE_DEN 4

+#define DMX_CONSOLE_NAME "DMX Console"

+#define DMX_RES_NAME     "Xdmx"

+#define DMX_RES_CLASS    "XDmx"

+#define CONSOLE_BG_COLOR "gray75"

+#define CONSOLE_FG_COLOR "black"

+#define CONSOLE_SCREEN_BG_COLOR "white"

+#define CONSOLE_SCREEN_FG_COLOR "black"

+#define CONSOLE_SCREEN_DET_COLOR "gray75"

+#define CONSOLE_SCREEN_CUR_COLOR "red"

+

+#if DMX_CONSOLE_DEBUG

+#define DMXDBG0(f)               dmxLog(dmxDebug,f)

+#define DMXDBG1(f,a)             dmxLog(dmxDebug,f,a)

+#define DMXDBG2(f,a,b)           dmxLog(dmxDebug,f,a,b)

+#define DMXDBG3(f,a,b,c)         dmxLog(dmxDebug,f,a,b,c)

+#define DMXDBG4(f,a,b,c,d)       dmxLog(dmxDebug,f,a,b,c,d)

+#define DMXDBG5(f,a,b,c,d,e)     dmxLog(dmxDebug,f,a,b,c,d,e)

+#define DMXDBG6(f,a,b,c,d,e,g)   dmxLog(dmxDebug,f,a,b,c,d,e,g)

+#define DMXDBG7(f,a,b,c,d,e,g,h) dmxLog(dmxDebug,f,a,b,c,d,e,g,h)

+#else

+#define DMXDBG0(f)

+#define DMXDBG1(f,a)

+#define DMXDBG2(f,a,b)

+#define DMXDBG3(f,a,b,c)

+#define DMXDBG4(f,a,b,c,d)

+#define DMXDBG5(f,a,b,c,d,e)

+#define DMXDBG6(f,a,b,c,d,e,g)

+#define DMXDBG7(f,a,b,c,d,e,g,h)

+#endif

+

+/* Private area for consoles. */

+typedef struct _myPrivate {

+    DMX_COMMON_PRIVATE;

+    int                     lastX;

+    int                     lastY;

+    int                     globalX;

+    int                     globalY;

+    int                     curX;

+    int                     curY;

+    int                     width;

+    int                     height;

+    int                     consWidth;

+    int                     consHeight;

+    double                  xScale;

+    double                  yScale;

+    XlibGC                  gc, gcDet, gcRev, gcCur;

+    int                     grabbed, fine, captured;

+    Cursor                  cursorNormal, cursorGrabbed, cursorEmpty;

+    Pixmap                  pixmap;

+    

+    CloseScreenProcPtr      CloseScreen;

+    struct _myPrivate       *next; /* for closing multiple consoles */

+    int                     initialized;

+    DevicePtr               mou, kbd;

+} myPrivate;

+

+static int scalex(myPrivate *priv, int x)

+{

+    return (int)((x * priv->xScale) + .5);

+}

+

+static int scaley(myPrivate *priv, int y)

+{

+    return (int)((y * priv->yScale) + .5);

+}

+

+static int unscalex(myPrivate *priv, int x)

+{

+    return (int)((x / priv->xScale) + .5);

+}

+

+static int unscaley(myPrivate *priv, int y)

+{

+    return (int)((y / priv->yScale) + .5);

+}

+

+/** Create the private area for \a pDevice. */

+pointer dmxConsoleCreatePrivate(DeviceIntPtr pDevice)

+{

+    GETDMXLOCALFROMPDEVICE;

+    myPrivate *priv = calloc(1, sizeof(*priv));

+    priv->dmxLocal  = dmxLocal;

+    return priv;

+}

+

+/** If \a private is non-NULL, free its associated memory. */

+void dmxConsoleDestroyPrivate(pointer private)

+{

+    free(private);

+}

+

+static void dmxConsoleDrawFineCursor(myPrivate *priv, XRectangle *rect)

+{

+    int size  = 6;

+    int x, y;

+    

+    XDrawLine(priv->display, priv->pixmap, priv->gcCur,

+              x = scalex(priv, priv->globalX) - size,

+              scaley(priv, priv->globalY),

+              scalex(priv, priv->globalX) + size,

+              scaley(priv, priv->globalY));

+    XDrawLine(priv->display, priv->pixmap, priv->gcCur,

+              scalex(priv, priv->globalX),

+              y = scaley(priv, priv->globalY) - size,

+              scalex(priv, priv->globalX),

+              scaley(priv, priv->globalY) + size);

+    if (priv->grabbed) {

+        XDrawLine(priv->display, priv->pixmap, priv->gcCur,

+                  scalex(priv, priv->globalX) - (int)(size / 1.4),

+                  scaley(priv, priv->globalY) - (int)(size / 1.4),

+                  scalex(priv, priv->globalX) + (int)(size / 1.4),

+                  scaley(priv, priv->globalY) + (int)(size / 1.4));

+        XDrawLine(priv->display, priv->pixmap, priv->gcCur,

+                  scalex(priv, priv->globalX) - (int)(size / 1.4),

+                  scaley(priv, priv->globalY) + (int)(size / 1.4),

+                  scalex(priv, priv->globalX) + (int)(size / 1.4),

+                  scaley(priv, priv->globalY) - (int)(size / 1.4));

+    }

+    if (rect) {

+        rect->x      = x;

+        rect->y      = y;

+        rect->width  = 2 * size;

+        rect->height = 2 * size;

+    }

+}

+

+static void dmxConsoleDrawWindows(pointer private)

+{

+    GETONLYPRIVFROMPRIVATE;

+    Display    *dpy   = priv->display;

+    int        i;

+    Region     whole, used, avail;

+    XRectangle rect;

+

+    whole       = XCreateRegion();

+    used        = XCreateRegion();

+    avail       = XCreateRegion();

+    rect.x      = 0;

+    rect.y      = 0;

+    rect.width  = priv->consWidth;

+    rect.height = priv->consHeight;

+    XUnionRectWithRegion(&rect, whole, whole);

+    

+    for (i = 0; i < dmxNumScreens; i++) {

+        ScreenPtr     pScreen     = screenInfo.screens[i];

+        WindowPtr     pRoot       = pScreen->root;

+        WindowPtr     pChild;

+

+#if DMX_WINDOW_DEBUG

+        dmxLog(dmxDebug, "%lu %p %p %p 2\n",

+               pRoot->drawable.id,

+               pRoot->parent, pRoot->firstChild, pRoot->lastChild);

+#endif

+        

+        for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib) {

+            if (pChild->mapped

+                && pChild->realized) {

+#if DMX_WINDOW_DEBUG

+                dmxLog(dmxDebug, "  %p %d,%d %dx%d %d %d  %d RECTS\n",

+                       pChild,

+                       pChild->drawable.x,

+                       pChild->drawable.y,

+                       pChild->drawable.width,

+                       pChild->drawable.height,

+                       pChild->visibility,

+                       pChild->overrideRedirect,

+                       RegionNumRects(&pChild->clipList));

+#endif

+                rect.x      = scalex(priv, pChild->drawable.x + pScreen->x);

+                rect.y      = scaley(priv, pChild->drawable.y + pScreen->y);

+                rect.width  = scalex(priv, pChild->drawable.width);

+                rect.height = scaley(priv, pChild->drawable.height);

+                XDrawRectangle(dpy, priv->pixmap, priv->gc,

+                               rect.x, rect.y, rect.width, rect.height);

+                XUnionRectWithRegion(&rect, used, used);

+                XSubtractRegion(whole, used, avail);

+                XSetRegion(dpy, priv->gc, avail);

+            }

+        }

+#ifdef PANORAMIX

+        if (!noPanoramiXExtension) break; /* Screen 0 valid with Xinerama */

+#endif

+    }

+    XDestroyRegion(avail);

+    XDestroyRegion(used);

+    XDestroyRegion(whole);

+    XSetClipMask(dpy, priv->gc, None);

+}

+

+static void dmxConsoleDraw(myPrivate *priv, int updateCursor, int update)

+{

+    GETDMXINPUTFROMPRIV;

+    Display       *dpy     = priv->display;

+    int           i;

+

+    XFillRectangle(dpy, priv->pixmap, priv->gc, 0, 0,

+                   priv->consWidth, priv->consHeight);

+

+    for (i = 0; i < dmxNumScreens; i++) {

+        DMXScreenInfo *dmxScreen = &dmxScreens[i];

+	XFillRectangle(dpy, priv->pixmap,

+                       dmxScreen->beDisplay ? priv->gcRev : priv->gcDet,

+                       scalex(priv, screenInfo.screens[i]->x),

+                       scaley(priv, screenInfo.screens[i]->y),

+                       scalex(priv, screenInfo.screens[i]->width),

+                       scaley(priv, screenInfo.screens[i]->height));

+    }

+    for (i = 0; i < dmxNumScreens; i++) {

+        XDrawRectangle(dpy, priv->pixmap, priv->gc,

+                       scalex(priv, screenInfo.screens[i]->x),

+                       scaley(priv, screenInfo.screens[i]->y),

+                       scalex(priv, screenInfo.screens[i]->width),

+                       scaley(priv, screenInfo.screens[i]->height));

+    }

+    if (dmxInput->windows)          dmxConsoleDrawWindows(priv);

+    if (priv->fine && updateCursor) dmxConsoleDrawFineCursor(priv, 0);

+    if (update) {

+        XCopyArea(priv->display, priv->pixmap, priv->window, priv->gc,

+                  0, 0, priv->consWidth, priv->consHeight, 0, 0);

+        XSync(priv->display, False);          /* Not a backend display */

+    }

+}

+

+static void dmxConsoleClearCursor(myPrivate *priv, int x, int y,

+                                  XRectangle *rect)

+{

+    int        cw = 14, ch = 14;    /* Clear width and height */

+    

+    rect->x      = scalex(priv, x) - cw/2;

+    rect->y      = scaley(priv, y) - ch/2;

+    rect->width  = cw;

+    rect->height = ch;

+    XSetClipRectangles(priv->display, priv->gc, 0, 0, rect, 1, Unsorted);

+    XSetClipRectangles(priv->display, priv->gcDet, 0, 0, rect, 1, Unsorted);

+    XSetClipRectangles(priv->display, priv->gcRev, 0, 0, rect, 1, Unsorted);

+    dmxConsoleDraw(priv, 0, 0);

+    XSetClipMask(priv->display, priv->gc, None);

+    XSetClipMask(priv->display, priv->gcDet, None);

+    XSetClipMask(priv->display, priv->gcRev, None);

+}

+

+

+static void dmxConsoleUpdateFineCursor(myPrivate *priv)

+{

+    int        leave = 0;

+    XRectangle rects[2];

+

+    dmxConsoleClearCursor(priv, priv->globalX, priv->globalY, &rects[0]);

+    if (priv->dmxLocal->sendsCore) {

+        dmxGetGlobalPosition(&priv->globalX, &priv->globalY);

+    } else {

+        priv->globalX = priv->dmxLocal->lastX;

+        priv->globalY = priv->dmxLocal->lastY;

+    }

+    

+    priv->lastX   = scalex(priv, priv->width / 2);

+    priv->lastY   = scaley(priv, priv->height / 2);

+

+                                /* Compute new warp position, which may be

+                                   outside the window */

+    if (priv->globalX < 1 || priv->globalX >= priv->width) {

+        if (priv->globalX < 1) priv->lastX = 0;

+        else                   priv->lastX = scalex(priv, priv->width);

+        priv->lastY = scaley(priv, priv->globalY);

+        ++leave;

+    }

+    if (priv->globalY < 1 || priv->globalY >= priv->height) {

+        if (priv->globalY < 1) priv->lastY = 0;

+        else                   priv->lastY = scaley(priv, priv->height);

+        priv->lastX = scalex(priv, priv->globalX);

+        ++leave;

+    }

+

+                                /* Draw pseudo cursor in window */

+    dmxConsoleDrawFineCursor(priv, &rects[1]);

+

+    XSetClipRectangles(priv->display, priv->gc, 0, 0, rects, 2, Unsorted);

+    XCopyArea(priv->display, priv->pixmap, priv->window, priv->gc,

+              0, 0, priv->consWidth, priv->consHeight, 0, 0);

+    XSetClipMask(priv->display, priv->gc, None);

+

+    DMXDBG2("dmxConsoleUpdateFineCursor: WARP %d %d\n",

+            priv->lastX, priv->lastY);

+    XWarpPointer(priv->display, priv->window, priv->window,

+                 0, 0, 0, 0, priv->lastX, priv->lastY);

+    XSync(priv->display, False); /* Not a backend display */

+

+    if (leave) {

+        XEvent X;

+        while (XCheckMaskEvent(priv->display, PointerMotionMask, &X)) {

+            if (X.type == MotionNotify) {

+                if (X.xmotion.x != priv->lastX || X.xmotion.y != priv->lastY) {

+                    DMXDBG4("Ignoring motion to %d %d after leave frm %d %d\n",

+                            X.xmotion.x, X.xmotion.y,

+                            priv->lastX, priv->lastY);

+                }

+            } else {

+                dmxLog(dmxInfo, "Ignoring event (%d): %s ****************\n",

+                       X.type, dmxEventName(X.type));

+            }

+        }

+    }

+    DMXDBG6("dmxConsoleUpdateFineCursor: Warp %d %d on %d %d [%d %d]\n",

+            priv->lastX, priv->lastY,

+            scalex(priv, priv->width),

+            scaley(priv, priv->height),

+            priv->globalX, priv->globalY);

+}

+

+/** Whenever the window layout (size, position, stacking order) might be

+ * changed, this routine is called with the \a pWindow that changed and

+ * the \a type of change.  This routine is called in a conservative

+ * fashion: the actual layout of the windows of the screen might not

+ * have had any human-visible changes. */

+void dmxConsoleUpdateInfo(pointer private, DMXUpdateType type,

+                          WindowPtr pWindow)

+{

+    GETONLYPRIVFROMPRIVATE;

+    dmxConsoleDraw(priv, 1, 1);

+}

+

+static void dmxConsoleMoveAbsolute(myPrivate *priv, int x, int y,

+                                   DevicePtr pDev, dmxMotionProcPtr motion,

+                                   DMXBlockType block)

+{

+    int tmpX, tmpY, v[2];

+

+    tmpX = unscalex(priv, x);

+    tmpY = unscalex(priv, y);

+    DMXDBG6("dmxConsoleMoveAbsolute(,%d,%d) %d %d =? %d %d\n",

+            x, y, tmpX, tmpY, priv->curX, priv->curY);

+    if (tmpX == priv->curX && tmpY == priv->curY) return;

+    v[0] = unscalex(priv, x);

+    v[1] = unscaley(priv, y);

+    motion(pDev, v, 0, 2, DMX_ABSOLUTE_CONFINED, block);

+    /* dmxConsoleUpdatePosition gets called here by dmxCoreMotion */

+}

+

+static void dmxConsoleMoveRelative(myPrivate *priv, int x, int y,

+                                   DevicePtr pDev, dmxMotionProcPtr motion,

+                                   DMXBlockType block)

+{

+    int v[2];

+    /* Ignore the event generated from * warping back to middle */

+    if (x == priv->lastX && y == priv->lastY) return;

+    v[0] = priv->lastX - x;

+    v[1] = priv->lastY - y;

+    motion(pDev, v, 0, 2, DMX_RELATIVE, block);

+    /* dmxConsoleUpdatePosition gets called here by dmxCoreMotion */

+}

+

+/** This routine gets called from #dmxCoreMotion for each motion.  This

+ * allows the console's notion of the cursor postion to change when

+ * another input device actually caused the change. */

+void dmxConsoleUpdatePosition(pointer private, int x, int y)

+{

+    GETONLYPRIVFROMPRIVATE;

+    int                  tmpX, tmpY;

+    Display              *dpy          = priv->display;

+    static unsigned long dmxGeneration = 0;

+

+

+    tmpX = scalex(priv, x);

+    tmpY = scaley(priv, y);

+    DMXDBG6("dmxConsoleUpdatePosition(,%d,%d) new=%d,%d dims=%d,%d\n",

+            x, y, tmpX, tmpY, priv->consWidth, priv->consHeight);

+    

+    if (priv->fine) dmxConsoleUpdateFineCursor(priv);

+    if (tmpX != priv->curX || tmpY != priv->curY) {

+        if (tmpX < 0)                 tmpX = 0;

+        if (tmpY < 0)                 tmpY = 0;

+        if (tmpX >= priv->consWidth)  tmpX = priv->consWidth  - 1;

+        if (tmpY >= priv->consHeight) tmpY = priv->consHeight - 1;

+        priv->curX = tmpX;

+        priv->curY = tmpY;

+        if (!priv->fine) {

+            DMXDBG2("   WARP B %d %d\n", priv->curX, priv->curY);

+            XWarpPointer(dpy, priv->window,

+                         priv->window, 0, 0, 0, 0, tmpX, tmpY);

+            XSync(dpy, False); /* Not a backend display */

+        }

+    }

+    

+    if (dmxGeneration != serverGeneration) {

+        dmxGeneration = serverGeneration;

+        dmxConsoleDraw(priv, 1, 1);

+    }

+}

+

+/** Collect all pending events from the console's display.  Plase these

+ * events on the server event queue using the \a motion and \a enqueue

+ * routines.  The \a checkspecial routine is used to check for special

+ * keys that need handling.  \a block tells if signals should be blocked

+ * when updating the event queue. */

+void dmxConsoleCollectEvents(DevicePtr pDev,

+                             dmxMotionProcPtr motion,

+                             dmxEnqueueProcPtr enqueue,

+                             dmxCheckSpecialProcPtr checkspecial,

+                             DMXBlockType block)

+{

+    GETPRIVFROMPDEV;

+    GETDMXINPUTFROMPRIV;

+    Display              *dpy        = priv->display;

+    Window               win         = priv->window;

+    int                  width       = priv->width;

+    int                  height      = priv->height;

+    XEvent               X, N;

+    XSetWindowAttributes attribs;

+    static int           rInitialized = 0;

+    static Region        r;

+    XRectangle           rect;

+    static int           raising = 0, raiseX, raiseY; /* FIXME */

+

+    while (XPending(dpy)) {

+        XNextEvent(dpy, &X);

+	switch(X.type) {

+        case VisibilityNotify:

+            break;

+	case Expose:

+            DMXDBG5("dmxConsoleCollectEvents: Expose #%d %d %d %d %d\n",

+                    X.xexpose.count,

+                    X.xexpose.x, X.xexpose.y,

+                    X.xexpose.width, X.xexpose.height);

+            if (!rInitialized++) r = XCreateRegion();

+            rect.x      = X.xexpose.x;

+            rect.y      = X.xexpose.y;

+            rect.width  = X.xexpose.width;

+            rect.height = X.xexpose.height;

+            XUnionRectWithRegion(&rect, r, r);

+	    if (X.xexpose.count == 0) {

+                XSetRegion(dpy, priv->gc, r);

+                XSetRegion(dpy, priv->gcDet, r);

+                XSetRegion(dpy, priv->gcRev, r);

+                dmxConsoleDraw(priv, 1, 1);

+                XSetClipMask(dpy, priv->gc, None);

+                XSetClipMask(dpy, priv->gcDet, None);

+                XSetClipMask(dpy, priv->gcRev, None);

+                XDestroyRegion(r);

+                rInitialized = 0;

+            }

+	    break;

+	case ResizeRequest:

+            DMXDBG2("dmxConsoleCollectEvents: Resize %d %d\n",

+                    X.xresizerequest.width, X.xresizerequest.height);

+            priv->consWidth           = X.xresizerequest.width;

+            priv->consHeight          = X.xresizerequest.height;

+	    priv->xScale              = (double)priv->consWidth  / width;

+	    priv->yScale              = (double)priv->consHeight / height;

+	    attribs.override_redirect = True;

+	    XChangeWindowAttributes(dpy, win, CWOverrideRedirect, &attribs);

+	    XResizeWindow(dpy, win, priv->consWidth, priv->consHeight);

+            XFreePixmap(dpy, priv->pixmap);

+            priv->pixmap = XCreatePixmap(dpy,

+                                         RootWindow(dpy, DefaultScreen(dpy)),

+                                         priv->consWidth,

+                                         priv->consHeight,

+                                         DefaultDepth(dpy,DefaultScreen(dpy)));

+	    dmxConsoleDraw(priv, 1, 1);

+	    attribs.override_redirect = False;

+	    XChangeWindowAttributes(dpy, win, CWOverrideRedirect, &attribs);

+	    break;

+        case LeaveNotify:

+            DMXDBG4("dmxConsoleCollectEvents: Leave @ %d,%d; r=%d f=%d\n",

+                    X.xcrossing.x, X.xcrossing.y, raising, priv->fine);

+            if (!priv->captured) dmxCommonRestoreState(priv);

+            else {

+                dmxConsoleUncapture(dmxInput);

+                dmxCommonRestoreState(priv);

+            }

+            break;

+        case EnterNotify:

+            DMXDBG6("dmxConsoleCollectEvents: Enter %d,%d r=%d f=%d (%d,%d)\n",

+                    X.xcrossing.x, X.xcrossing.y, raising, priv->fine,

+                    priv->curX, priv->curY);

+            dmxCommonSaveState(priv);

+            if (raising) {

+                raising = 0;

+                dmxConsoleMoveAbsolute(priv, raiseX, raiseY,

+                                       priv->mou, motion, block);

+            } else {

+                if (priv->fine) {

+                    /* The raise will generate an event near the center,

+                     * which is not where the cursor should be.  So we

+                     * save the real position, do the raise, and move

+                     * the cursor here again after the raise generates

+                     * the event. */

+                    raising = 1;

+                    raiseX = X.xcrossing.x;

+                    raiseY = X.xcrossing.y;

+                    XRaiseWindow(dpy, priv->window);

+                }

+                XSync(dpy, False); /* Not a backend display */

+                if (!X.xcrossing.x && !X.xcrossing.y)

+                    dmxConsoleMoveAbsolute(priv, priv->curX, priv->curY,

+                                           priv->mou, motion, block);

+            }

+            break;

+	case MotionNotify:

+            if (priv->curX == X.xmotion.x && priv->curY == X.xmotion.y)

+                continue;

+            if (XPending(dpy)) { /* do motion compression */

+                XPeekEvent(dpy, &N);

+                if (N.type == MotionNotify) continue;

+            }

+            DMXDBG2("dmxConsoleCollectEvents: Motion %d %d\n",

+                    X.xmotion.x, X.xmotion.y);

+            if (raising) {

+                raising = 0;

+                dmxConsoleMoveAbsolute(priv, raiseX, raiseY,

+                                       priv->mou, motion, block);

+            } else {

+                if (priv->fine)

+                    dmxConsoleMoveRelative(priv, X.xmotion.x, X.xmotion.y,

+                                           priv->mou, motion, block);

+                else

+                    dmxConsoleMoveAbsolute(priv, X.xmotion.x, X.xmotion.y,

+                                           priv->mou, motion, block);

+            }

+	    break;

+        case KeyPress:

+        case KeyRelease:

+            enqueue(priv->kbd, X.type, X.xkey.keycode, 0, NULL, block);

+            break;

+        default:

+                                /* Pass the whole event here, because

+                                 * this may be an extension event. */

+            enqueue(priv->mou, X.type, X.xbutton.button, 0, &X, block);

+	    break;

+	}

+    }

+}

+

+static void dmxCloseConsole(myPrivate *priv)

+{

+    GETDMXINPUTFROMPRIV;

+    dmxCommonRestoreState(priv);

+    if (priv->display) {

+        XFreeGC(priv->display, priv->gc);

+        XFreeGC(priv->display, priv->gcDet);

+        XFreeGC(priv->display, priv->gcRev);

+        XFreeGC(priv->display, priv->gcCur);

+        if (!dmxInput->console) XCloseDisplay(priv->display);

+    }

+    priv->display = NULL;

+}

+

+static Bool dmxCloseConsoleScreen(int idx, ScreenPtr pScreen)

+{

+    myPrivate *priv, *last;

+

+    for (last = priv = (myPrivate *)dixLookupPrivate(&pScreen->devPrivates,

+						     dmxScreenPrivateKey);

+         priv;

+         priv = priv->next) dmxCloseConsole(last = priv);

+    

+    DMX_UNWRAP(CloseScreen, last, pScreen);

+    return pScreen->CloseScreen(idx, pScreen);

+}

+

+static Cursor dmxConsoleCreateEmptyCursor(myPrivate *priv)

+{

+    char    noCursorData[] = { 0, 0, 0, 0, 0, 0, 0, 0 };

+    Pixmap  pixmap;

+    Cursor  cursor;

+    XColor  color, tmpColor;

+    Display *dpy = priv->display;

+

+                                 /* Create empty cursor for window */

+    pixmap = XCreateBitmapFromData(priv->display, priv->window,

+                                   noCursorData, 8, 8);

+    if (!XAllocNamedColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)),

+                          "black",

+                          &color,

+                          &tmpColor))

+        dmxLog(dmxFatal, "Cannot allocate color for cursor\n");

+    cursor = XCreatePixmapCursor(dpy, pixmap, pixmap, &color, &color, 0, 0);

+    XFreePixmap(dpy, pixmap);

+    return cursor;

+}

+

+static void dmxConsoleComputeWidthHeight(myPrivate *priv,

+                                         int *width, int *height,

+                                         double *xScale, double *yScale,

+                                         int *consWidth, int *consHeight)

+{

+    int     screen;

+    Display *dpy = priv->display;

+

+    *width      = 0;

+    *height     = 0;

+    *xScale     = 1.0;

+    *yScale     = 1.0;

+

+    screen      = DefaultScreen(dpy);

+    *consWidth  = DisplayWidth(dpy, screen)  * CONSOLE_NUM / CONSOLE_DEN;

+    *consHeight = DisplayHeight(dpy, screen) * CONSOLE_NUM / CONSOLE_DEN;

+

+    if (*consWidth  < 1) *consWidth  = 1;

+    if (*consHeight < 1) *consHeight = 1;

+

+#if 1

+                                /* Always keep the console size similar

+                                 * to the global bounding box. */

+    *width  = dmxGlobalWidth;

+    *height = dmxGlobalHeight;

+#else

+                                /* Make the console window as big as

+                                 * possible by computing the visible

+                                 * bounding box. */

+    for (i = 0; i < dmxNumScreens; i++) {

+	if (screenInfo.screens[i]->x+screenInfo.screens[i]->width > *width)

+	    *width = screenInfo.screens[i]->x+screenInfo.screens[i]->width;

+        

+	if (screenInfo.screens[i]->y+screenInfo.screens[i]->height > *height)

+	    *height = screenInfo.screens[i]->y+screenInfo.screens[i]->height;

+    }

+#endif

+

+    if ((double)*consWidth / *width < (double)*consHeight / *height)

+	*xScale = *yScale = (double)*consWidth / *width;

+    else

+	*xScale = *yScale = (double)*consHeight / *height;

+

+    *consWidth  = scalex(priv, *width);

+    *consHeight = scaley(priv, *height);

+    if (*consWidth  < 1) *consWidth  = 1;

+    if (*consHeight < 1) *consHeight = 1;

+}

+

+/** Re-initialized the console device described by \a pDev (after a

+ * reconfig). */

+void dmxConsoleReInit(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    Display *dpy;

+

+    if (!priv || !priv->initialized) return;

+    dpy = priv->display;

+

+    dmxConsoleComputeWidthHeight(priv,

+                                 &priv->width, &priv->height,

+                                 &priv->xScale, &priv->yScale,

+                                 &priv->consWidth, &priv->consHeight);

+    XResizeWindow(dpy, priv->window, priv->consWidth, priv->consHeight);

+    XFreePixmap(dpy, priv->pixmap);

+    priv->pixmap = XCreatePixmap(dpy,

+                                 RootWindow(dpy, DefaultScreen(dpy)),

+                                 priv->consWidth,

+                                 priv->consHeight,

+                                 DefaultDepth(dpy,DefaultScreen(dpy)));

+    dmxConsoleDraw(priv, 1, 1);

+}

+

+/** Initialized the console device described by \a pDev. */

+void dmxConsoleInit(DevicePtr pDev)

+{

+    GETPRIVFROMPDEV;

+    DMXInputInfo         *dmxInput = &dmxInputs[dmxLocal->inputIdx];

+    int                  screen;

+    unsigned long        mask;

+    XSetWindowAttributes attribs;

+    Display              *dpy;

+    Window               win;

+    XGCValues            gcvals;

+    XColor               color;

+    XClassHint           class_hints;

+    unsigned long        tmp;

+

+    if (dmxLocal->type == DMX_LOCAL_MOUSE)    priv->mou = pDev;

+    if (dmxLocal->type == DMX_LOCAL_KEYBOARD) priv->kbd = pDev;

+    if (priv->initialized++) return; /* Only do once for mouse/keyboard pair */

+

+    if (!(dpy = priv->display = XOpenDisplay(dmxInput->name)))

+        dmxLog(dmxFatal,

+               "dmxOpenConsole: cannot open console display %s\n",

+               dmxInput->name);

+

+    /* Set up defaults */

+    dmxConsoleComputeWidthHeight(priv,

+                                 &priv->width, &priv->height,

+                                 &priv->xScale, &priv->yScale,

+                                 &priv->consWidth, &priv->consHeight);

+

+    /* Private initialization using computed values or constants. */

+    screen                   = DefaultScreen(dpy);

+    priv->initPointerX       = scalex(priv, priv->width / 2);

+    priv->initPointerY       = scaley(priv, priv->height / 2);

+    priv->eventMask          = (ButtonPressMask

+                                | ButtonReleaseMask

+                                | PointerMotionMask

+                                | EnterWindowMask

+                                | LeaveWindowMask

+                                | KeyPressMask

+                                | KeyReleaseMask

+                                | ExposureMask

+                                | ResizeRedirectMask);

+

+    mask = CWBackPixel | CWEventMask | CWColormap | CWOverrideRedirect;

+    attribs.colormap = DefaultColormap(dpy, screen);

+    if (XParseColor(dpy, attribs.colormap, CONSOLE_BG_COLOR, &color)

+        && XAllocColor(dpy, attribs.colormap, &color)) {

+	attribs.background_pixel = color.pixel;

+    } else 

+        attribs.background_pixel = WhitePixel(dpy, screen);

+

+    attribs.event_mask        = priv->eventMask;

+    attribs.override_redirect = False;

+    

+    win = priv->window = XCreateWindow(dpy,

+                                       RootWindow(dpy, screen),

+                                       0, 0, priv->consWidth, priv->consHeight,

+                                       0,

+                                       DefaultDepth(dpy, screen),

+                                       InputOutput,

+                                       DefaultVisual(dpy, screen),

+                                       mask, &attribs);

+    priv->pixmap = XCreatePixmap(dpy, RootWindow(dpy, screen),

+                                 priv->consWidth, priv->consHeight,

+                                 DefaultDepth(dpy, screen));

+

+                                /* Set up properties */

+    XStoreName(dpy, win, DMX_CONSOLE_NAME);

+    class_hints.res_name  = DMX_RES_NAME;

+    class_hints.res_class = DMX_RES_CLASS;

+    XSetClassHint(dpy, win, &class_hints);

+

+

+                                /* Map the window */

+    XMapWindow(dpy, win);

+

+                                /* Create cursors */

+    priv->cursorNormal  = XCreateFontCursor(dpy, XC_circle);

+    priv->cursorGrabbed = XCreateFontCursor(dpy, XC_spider);

+    priv->cursorEmpty   = dmxConsoleCreateEmptyCursor(priv);

+    XDefineCursor(dpy, priv->window, priv->cursorNormal);

+

+                                /* Create GC */

+    mask = (GCFunction | GCPlaneMask | GCClipMask | GCForeground |

+	    GCBackground | GCLineWidth | GCLineStyle | GCCapStyle |

+	    GCFillStyle | GCGraphicsExposures);

+    gcvals.function = GXcopy;

+    gcvals.plane_mask = AllPlanes;

+    gcvals.clip_mask = None;

+    if (XParseColor(dpy, attribs.colormap, CONSOLE_SCREEN_FG_COLOR, &color)

+        && XAllocColor(dpy, attribs.colormap, &color)) {

+	gcvals.foreground = color.pixel;

+    } else

+	gcvals.foreground = BlackPixel(dpy, screen);

+    if (XParseColor(dpy, attribs.colormap, CONSOLE_SCREEN_BG_COLOR, &color)

+        && XAllocColor(dpy, attribs.colormap, &color)) {

+	gcvals.background = color.pixel;

+    } else

+	gcvals.background = WhitePixel(dpy, screen);

+    gcvals.line_width         = 0;

+    gcvals.line_style         = LineSolid;

+    gcvals.cap_style          = CapNotLast;

+    gcvals.fill_style         = FillSolid;

+    gcvals.graphics_exposures = False;

+    

+    priv->gc = XCreateGC(dpy, win, mask, &gcvals);

+

+    tmp               = gcvals.foreground;

+    if (XParseColor(dpy, attribs.colormap, CONSOLE_SCREEN_DET_COLOR, &color)

+        && XAllocColor(dpy, attribs.colormap, &color)) {

+        gcvals.foreground = color.pixel;

+    } else

+        gcvals.foreground = BlackPixel(dpy, screen);

+    priv->gcDet = XCreateGC(dpy, win, mask, &gcvals);

+    gcvals.foreground = tmp;

+

+    tmp               = gcvals.background;

+    gcvals.background = gcvals.foreground;

+    gcvals.foreground = tmp;

+    priv->gcRev = XCreateGC(dpy, win, mask, &gcvals);

+    

+    gcvals.background = gcvals.foreground;

+    if (XParseColor(dpy, attribs.colormap, CONSOLE_SCREEN_CUR_COLOR, &color)

+        && XAllocColor(dpy, attribs.colormap, &color)) {

+        gcvals.foreground = color.pixel;

+    } else

+        gcvals.foreground = BlackPixel(dpy, screen);

+    priv->gcCur = XCreateGC(dpy, win, mask, &gcvals);

+

+    dmxConsoleDraw(priv, 1, 1);

+

+    if (dixLookupPrivate(&screenInfo.screens[0]->devPrivates,

+			 dmxScreenPrivateKey))

+        priv->next = dixLookupPrivate(&screenInfo.screens[0]->devPrivates,

+				      dmxScreenPrivateKey);

+    else 

+        DMX_WRAP(CloseScreen, dmxCloseConsoleScreen,

+                 priv, screenInfo.screens[0]);

+    dixSetPrivate(&screenInfo.screens[0]->devPrivates, dmxScreenPrivateKey,

+		  priv);

+}

+

+/** Fill in the \a info structure for the specified \a pDev.  Only used

+ * for pointers. */

+void dmxConsoleMouGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)

+{

+    GETPRIVFROMPDEV;

+

+    info->buttonClass      = 1;

+    dmxCommonMouGetMap(pDev, info->map, &info->numButtons);

+    info->valuatorClass    = 1;

+    info->numRelAxes       = 2;

+    info->minval[0] = 0;

+    info->minval[1] = 0;

+    /* max possible console window size: */

+    info->maxval[0] = DisplayWidth(priv->display, DefaultScreen(priv->display));

+    info->maxval[1] = DisplayHeight(priv->display, DefaultScreen(priv->display));

+    info->res[0]           = 1;

+    info->minres[0]        = 0;

+    info->maxres[0]        = 1;

+    info->ptrFeedbackClass = 1;

+}

+

+/** Fill in the \a info structure for the specified \a pDev.  Only used

+ * for keyboard. */

+void dmxConsoleKbdGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)

+{

+    dmxCommonKbdGetInfo(pDev, info);

+    info->keyboard         = 1;

+    info->keyClass         = 1;

+    dmxCommonKbdGetMap(pDev, &info->keySyms, info->modMap);

+    info->freemap          = 1;

+    info->focusClass       = 1;

+    info->kbdFeedbackClass = 1;

+}

+

+/** Handle special console-only keys. */

+int dmxConsoleFunctions(pointer private, DMXFunctionType function)

+{

+    GETONLYPRIVFROMPRIVATE;

+    XRectangle rect;

+    Display    *dpy = priv->display;

+

+    switch (function) {

+    case DMX_FUNCTION_FINE:

+        if (priv->fine) {

+            priv->fine = 0;

+            dmxConsoleClearCursor(priv, priv->globalX, priv->globalY, &rect);

+            XSetClipRectangles(dpy, priv->gc, 0, 0, &rect, 1, Unsorted);

+            XCopyArea(dpy, priv->pixmap, priv->window, priv->gc,

+                      0, 0, priv->consWidth, priv->consHeight, 0, 0);

+            XSetClipMask(dpy, priv->gc, None);

+            

+            XDefineCursor(dpy, priv->window,

+                          priv->grabbed

+                          ? priv->cursorGrabbed

+                          : priv->cursorNormal);

+            XWarpPointer(dpy, priv->window, priv->window,

+                         0, 0, 0, 0,

+                         scalex(priv, priv->globalX),

+                         scaley(priv, priv->globalY));

+            XSync(dpy, False); /* Not a backend display */

+        } else {

+            priv->fine = 1;

+            XRaiseWindow(dpy, priv->window);

+            XDefineCursor(dpy, priv->window, priv->cursorEmpty);

+            dmxConsoleUpdateFineCursor(priv);

+        }

+        return 1;

+    case DMX_FUNCTION_GRAB:

+        if (priv->grabbed) {

+            XUngrabKeyboard(dpy, CurrentTime);

+            XUngrabPointer(dpy, CurrentTime);

+            XDefineCursor(dpy, priv->window,

+                          priv->fine

+                          ? priv->cursorEmpty

+                          : priv->cursorNormal);

+        } else {

+            if (XGrabPointer(dpy, priv->window, True,

+                             0, GrabModeAsync, GrabModeAsync, priv->window,

+                             None, CurrentTime)) {

+                dmxLog(dmxError, "XGrabPointer failed\n");

+                return 0;

+            }

+            if (XGrabKeyboard(dpy, priv->window, True,

+                              GrabModeAsync, GrabModeAsync, CurrentTime)) {

+                dmxLog(dmxError, "XGrabKeyboard failed\n");

+                XUngrabPointer(dpy, CurrentTime);

+                return 0;

+            }

+            XDefineCursor(dpy, priv->window,

+                          priv->fine

+                          ? priv->cursorEmpty

+                          : priv->cursorGrabbed);

+        }

+        priv->grabbed = !priv->grabbed;

+        if (priv->fine) dmxConsoleUpdateFineCursor(priv);

+        return 1;

+    case DMX_FUNCTION_TERMINATE:

+        return 1;

+    default:

+        return 0;

+    }

+}

+

+static void dmxDump(void)

+{

+    int          i, j;

+    DMXInputInfo *dmxInput;

+    XEvent       X;

+    

+    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++) {

+        for (j = 0; j < dmxInput->numDevs; j++) {

+            DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[j];

+            myPrivate            *priv    = dmxLocal->private;

+            while (priv

+                   && priv->display

+                   && XCheckTypedEvent(priv->display, MotionNotify, &X)) {

+                DMXDBG4("dmxDump: %s/%d threw event away %d %s\n",

+                        dmxInput->name, j, X.type, dmxEventName(X.type));

+            }

+        }

+    }

+}

+

+/** This routine is used to warp the pointer into the console window

+ * from anywhere on the screen.  It is used when backend and console

+ * input are both being taken from the same X display. */

+void dmxConsoleCapture(DMXInputInfo *dmxInput)

+{

+    int     i;

+    XEvent  X;

+

+    DMXDBG0("dmxConsoleCapture\n");

+    dmxSync(NULL, TRUE);

+    for (i = 0; i < dmxInput->numDevs; i++) {

+        DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[i];

+        myPrivate            *priv    = dmxLocal->private;

+        if (dmxLocal->extType != DMX_LOCAL_TYPE_CONSOLE) continue;

+        if (dmxLocal->type    != DMX_LOCAL_MOUSE)        continue;

+        if (priv->captured)                              continue;

+        priv->captured = 2;     /* Ungrab only after proximal events. */

+        XRaiseWindow(priv->display, priv->window);

+        XSync(priv->display, False); /* Not a backend display */

+        while (XCheckTypedEvent(priv->display, MotionNotify, &X)) {

+            DMXDBG3("   Ignoring motion to %d %d after capture on %s\n",

+                    X.xmotion.x, X.xmotion.y, dmxInput->name);

+        }

+        XWarpPointer(priv->display, None,

+                     priv->window, 0, 0, 0, 0, priv->curX, priv->curY);

+        XSync(priv->display, False); /* Not a backend display */

+        dmxDump();

+        if (priv->fine) dmxConsoleUpdateFineCursor(priv);

+    }

+}

+

+/** Undo the capture that was done by #dmxConsoleCapture. */

+void dmxConsoleUncapture(DMXInputInfo *dmxInput)

+{

+    int i;

+

+    DMXDBG0("dmxConsoleUncapture\n");

+    dmxSync(NULL, TRUE);

+    for (i = 0; i < dmxInput->numDevs; i++) {

+        DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[i];

+        myPrivate            *priv    = dmxLocal->private;

+        if (dmxLocal->extType != DMX_LOCAL_TYPE_CONSOLE) continue;

+        if (dmxLocal->type    != DMX_LOCAL_MOUSE)        continue;

+        if (!priv->captured)                             continue;

+        priv->captured = 0;

+        XSync(priv->display, False); /* Not a backend display */

+    }

+}

diff --git a/xorg-server/hw/dmx/input/dmxinputinit.c b/xorg-server/hw/dmx/input/dmxinputinit.c
index c700a1246..2e062ef79 100644
--- a/xorg-server/hw/dmx/input/dmxinputinit.c
+++ b/xorg-server/hw/dmx/input/dmxinputinit.c
@@ -570,7 +570,7 @@ static void dmxUpdateWindowInformation(DMXInputInfo *dmxInput,
     int i;

 

 #ifdef PANORAMIX

-    if (!noPanoramiXExtension && pWindow && pWindow->parent != WindowTable[0])

+    if (!noPanoramiXExtension && pWindow && pWindow->parent != screenInfo.screens[0]->root)

         return;

 #endif

 #if DMX_WINDOW_DEBUG

@@ -827,7 +827,7 @@ static void dmxPopulateLocal(DMXInputInfo *dmxInput, dmxArg a)
     }

 }

 

-int dmxInputExtensionErrorHandler(Display *dsp, char *name, char *reason)

+int dmxInputExtensionErrorHandler(Display *dsp, _Xconst char *name, _Xconst char *reason)

 {

     return 0;

 }

@@ -839,7 +839,7 @@ static void dmxInputScanForExtensions(DMXInputInfo *dmxInput, int doXI)
     Display              *display;

     int                  num;

     int                  i, j;

-    int                  (*handler)(Display *, char *, char *);

+    XextErrorHandler     handler;

 

     if (!(display = XOpenDisplay(dmxInput->name))) return;

     

@@ -1084,9 +1084,9 @@ static void dmxInputFreeLocal(DMXLocalInputInfoRec *local)
     if (local->isCore && local->type == DMX_LOCAL_KEYBOARD)

         dmxLocalCoreKeyboard = NULL;

     if (local->destroy_private) local->destroy_private(local->private);

-    if (local->history)         free(local->history);

-    if (local->valuators)       free(local->valuators);

-    if (local->deviceName)      free(local->deviceName);

+    free(local->history);

+    free(local->valuators);

+    free(local->deviceName);

     local->private    = NULL;

     local->history    = NULL;

     local->deviceName = NULL;

@@ -1100,9 +1100,9 @@ void dmxInputFree(DMXInputInfo *dmxInput)
     

     if (!dmxInput) return;

 

-    if (dmxInput->keycodes) free(dmxInput->keycodes);

-    if (dmxInput->symbols)  free(dmxInput->symbols);

-    if (dmxInput->geometry) free(dmxInput->geometry);

+    free(dmxInput->keycodes);

+    free(dmxInput->symbols);

+    free(dmxInput->geometry);

 

     for (i = 0; i < dmxInput->numDevs; i++) {

         dmxInputFreeLocal(dmxInput->devs[i]);

diff --git a/xorg-server/hw/dmx/input/dmxinputinit.h b/xorg-server/hw/dmx/input/dmxinputinit.h
index 2e625cfd4..d23ad7a38 100644
--- a/xorg-server/hw/dmx/input/dmxinputinit.h
+++ b/xorg-server/hw/dmx/input/dmxinputinit.h
@@ -1,291 +1,291 @@
-/*
- * Copyright 2002 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- * Interface for low-level input support.  \see dmxinputinit.c */
-
-#ifndef _DMXINPUTINIT_H_
-#define _DMXINPUTINIT_H_
-
-#include "dmx.h"
-#include "dmxinput.h"
-#include "dmxlog.h"
-
-
-#define DMX_LOCAL_DEFAULT_KEYBOARD "kbd"
-#define DMX_LOCAL_DEFAULT_POINTER  "ps2"
-#define DMX_MAX_BUTTONS            256
-#define DMX_MOTION_SIZE            256
-#define DMX_MAX_VALUATORS          32
-#define DMX_MAX_AXES               32
-#define DMX_MAX_XINPUT_EVENT_TYPES 100
-#define DMX_MAP_ENTRIES            16 /* Must be a power of 2 */
-#define DMX_MAP_MASK               (DMX_MAP_ENTRIES - 1)
-
-typedef enum {
-    DMX_FUNCTION_GRAB,
-    DMX_FUNCTION_TERMINATE,
-    DMX_FUNCTION_FINE
-} DMXFunctionType;
-
-typedef enum {
-    DMX_LOCAL_HIGHLEVEL,
-    DMX_LOCAL_KEYBOARD,
-    DMX_LOCAL_MOUSE,
-    DMX_LOCAL_OTHER
-} DMXLocalInputType;
-
-typedef enum {
-    DMX_LOCAL_TYPE_LOCAL,
-    DMX_LOCAL_TYPE_CONSOLE,
-    DMX_LOCAL_TYPE_BACKEND,
-    DMX_LOCAL_TYPE_COMMON
-} DMXLocalInputExtType;
-
-typedef enum {
-    DMX_RELATIVE,
-    DMX_ABSOLUTE,
-    DMX_ABSOLUTE_CONFINED
-} DMXMotionType;
-
-/** Stores information from low-level device that is used to initialize
- * the device at the dix level. */
-typedef struct _DMXLocalInitInfo {
-    int                  keyboard; /**< Non-zero if the device is a keyboard */
-    
-    int                  keyClass; /**< Non-zero if keys are present */
-    KeySymsRec           keySyms;  /**< Key symbols */
-    int                  freemap;  /**< If non-zero, free keySyms.map */
-    CARD8                modMap[MAP_LENGTH]; /**< Modifier map */
-    XkbDescPtr           xkb;       /**< XKB description */
-    XkbComponentNamesRec names;     /**< XKB component names */
-    int                  freenames; /**< Non-zero if names should be free'd */
-    int                  force;     /**< Do not allow command line override */
-
-    int                  buttonClass; /**< Non-zero if buttons are present */
-    int                  numButtons;  /**< Number of buttons */
-    unsigned char        map[DMX_MAX_BUTTONS]; /**< Button map */
-
-    int                  valuatorClass; /**< Non-zero if valuators are
-                                         * present */
-    int                  numRelAxes;    /**< Number of relative axes */
-    int                  numAbsAxes;    /**< Number of absolute axes */
-    int                  minval[DMX_MAX_AXES]; /**< Minimum values */
-    int                  maxval[DMX_MAX_AXES]; /**< Maximum values */
-    int                  res[DMX_MAX_AXES];    /**< Resolution */
-    int                  minres[DMX_MAX_AXES]; /**< Minimum resolutions */
-    int                  maxres[DMX_MAX_AXES]; /**< Maximum resolutions */
-
-    int                  focusClass;       /**< Non-zero if device can
-                                            * cause focus */
-    int                  proximityClass;   /**< Non-zero if device
-                                            * causes proximity events */
-    int                  kbdFeedbackClass; /**< Non-zero if device has
-                                            * keyboard feedback */ 
-    int                  ptrFeedbackClass; /**< Non-zero if device has
-                                            * pointer feedback */
-    int                  ledFeedbackClass; /**< Non-zero if device has
-                                            * LED indicators */
-    int                  belFeedbackClass; /**< Non-zero if device has a
-                                            * bell */ 
-    int                  intFeedbackClass; /**< Non-zero if device has
-                                            * integer feedback */
-    int                  strFeedbackClass; /**< Non-zero if device has
-                                            * string feedback */
-
-    int                  maxSymbols;          /**< Maximum symbols */
-    int                  maxSymbolsSupported; /**< Maximum symbols supported */
-    KeySym               *symbols;            /**< Key symbols */
-} DMXLocalInitInfo, *DMXLocalInitInfoPtr;
-
-typedef pointer (*dmxCreatePrivateProcPtr)(DeviceIntPtr);
-typedef void    (*dmxDestroyPrivateProcPtr)(pointer);
-                
-typedef void    (*dmxInitProcPtr)(DevicePtr);
-typedef void    (*dmxReInitProcPtr)(DevicePtr);
-typedef void    (*dmxLateReInitProcPtr)(DevicePtr);
-typedef void    (*dmxGetInfoProcPtr)(DevicePtr, DMXLocalInitInfoPtr);
-typedef int     (*dmxOnProcPtr)(DevicePtr);
-typedef void    (*dmxOffProcPtr)(DevicePtr);
-typedef void    (*dmxUpdatePositionProcPtr)(pointer, int x, int y);
-                
-typedef void    (*dmxVTPreSwitchProcPtr)(pointer);  /* Turn I/O Off */
-typedef void    (*dmxVTPostSwitchProcPtr)(pointer); /* Turn I/O On */
-typedef void    (*dmxVTSwitchReturnProcPtr)(pointer);
-typedef int     (*dmxVTSwitchProcPtr)(pointer, int vt,
-                                      dmxVTSwitchReturnProcPtr, pointer);
-                
-typedef void    (*dmxMotionProcPtr)(DevicePtr,
-                                    int *valuators,
-                                    int firstAxis,
-                                    int axesCount,
-                                    DMXMotionType type,
-                                    DMXBlockType block);
-typedef void    (*dmxEnqueueProcPtr)(DevicePtr, int type, int detail,
-                                     KeySym keySym, XEvent *e,
-                                     DMXBlockType block);
-typedef int     (*dmxCheckSpecialProcPtr)(DevicePtr, KeySym keySym);
-typedef void    (*dmxCollectEventsProcPtr)(DevicePtr,
-                                           dmxMotionProcPtr,
-                                           dmxEnqueueProcPtr,
-                                           dmxCheckSpecialProcPtr,
-                                           DMXBlockType);
-typedef void    (*dmxProcessInputProcPtr)(pointer);
-typedef void    (*dmxUpdateInfoProcPtr)(pointer, DMXUpdateType, WindowPtr);
-typedef int     (*dmxFunctionsProcPtr)(pointer, DMXFunctionType);
-                
-typedef void    (*dmxKBCtrlProcPtr)(DevicePtr, KeybdCtrl *ctrl);
-typedef void    (*dmxMCtrlProcPtr)(DevicePtr, PtrCtrl *ctrl);
-typedef void    (*dmxKBBellProcPtr)(DevicePtr, int percent,
-                                    int volume, int pitch, int duration);
-
-/** Stores a mapping between the device id on the remote X server and
- * the id on the DMX server */
-typedef struct _DMXEventMap {
-    int remote;                 /**< Event number on remote X server */
-    int server;                 /**< Event number (unbiased) on DMX server */
-} DMXEventMap;
-
-/** This is the device-independent structure used by the low-level input
- * routines.  The contents are not exposed to top-level .c files (except
- * dmxextensions.c).  \see dmxinput.h \see dmxextensions.c */
-typedef struct _DMXLocalInputInfo {
-    const char               *name;   /**< Device name */
-    DMXLocalInputType        type;    /**< Device type  */
-    DMXLocalInputExtType     extType; /**< Extended device type */
-    int                      binding; /**< Count of how many consecutive
-                                       * structs are bound to the same
-                                       * device */
-    
-                                /* Low-level (e.g., keyboard/mouse drivers) */
-
-    dmxCreatePrivateProcPtr  create_private;  /**< Create
-                                               * device-dependent
-                                               * private */
-    dmxDestroyPrivateProcPtr destroy_private; /**< Destroy
-                                               * device-dependent
-                                               * private */
-    dmxInitProcPtr           init;            /**< Initialize device  */
-    dmxReInitProcPtr         reinit;          /**< Reinitialize device
-                                               * (during a
-                                               * reconfiguration) */
-    dmxLateReInitProcPtr     latereinit;      /**< Reinitialize a device
-                                               * (called very late
-                                               * during a
-                                               * reconfiguration) */
-    dmxGetInfoProcPtr        get_info;        /**< Get device information */
-    dmxOnProcPtr             on;              /**< Turn device on */
-    dmxOffProcPtr            off;             /**< Turn device off */
-    dmxUpdatePositionProcPtr update_position; /**< Called when another
-                                               * device updates the
-                                               * cursor position */
-    dmxVTPreSwitchProcPtr    vt_pre_switch;   /**< Called before a VT switch */
-    dmxVTPostSwitchProcPtr   vt_post_switch;  /**< Called after a VT switch */
-    dmxVTSwitchProcPtr       vt_switch;       /**< Causes a VT switch */
-
-    dmxCollectEventsProcPtr  collect_events;  /**< Collect and enqueue
-                                               * events from the
-                                               * device*/
-    dmxProcessInputProcPtr   process_input;   /**< Process event (from
-                                               * queue)  */
-    dmxFunctionsProcPtr      functions;
-    dmxUpdateInfoProcPtr     update_info;     /**< Update window layout
-                                               * information */
-
-    dmxMCtrlProcPtr          mCtrl;           /**< Pointer control */
-    dmxKBCtrlProcPtr         kCtrl;           /**< Keyboard control */
-    dmxKBBellProcPtr         kBell;           /**< Bell control */
-
-    pointer                  private;         /**< Device-dependent private  */
-    int                      isCore;          /**< Is a DMX core device  */
-    int                      sendsCore;       /**< Sends DMX core events */
-    KeybdCtrl                kctrl;           /**< Keyboard control */
-    PtrCtrl                  mctrl;           /**< Pointer control */
-
-    DeviceIntPtr             pDevice;         /**< X-level device  */
-    int                      inputIdx;        /**< High-level index */
-    int                      lastX, lastY;    /**< Last known position;
-                                               * for XInput in
-                                               * dmxevents.c */ 
-
-    int                      head;            /**< XInput motion history
-                                               * head */
-    int                      tail;            /**< XInput motion history
-                                               * tail */
-    unsigned long            *history;        /**< XInput motion history */
-    int                      *valuators;      /**< Cache of previous values */
-    
-                                /* for XInput ChangePointerDevice */
-    int                      (*savedMotionProc)(DeviceIntPtr,
-                                                xTimecoord *,
-                                                unsigned long,
-                                                unsigned long,
-                                                ScreenPtr);
-    int                      savedMotionEvents; /**< Saved motion events */
-    int                      savedSendsCore;    /**< Saved sends-core flag */
-
-    DMXEventMap              map[DMX_MAP_ENTRIES]; /**< XInput device id map */
-    int                      mapOptimize;          /**< XInput device id
-                                                    * map
-                                                    * optimization */
-
-    long                     deviceId;    /**< device id on remote side,
-                                           * if any */
-    const char               *deviceName; /**< devive name on remote
-                                           * side, if any */
-} DMXLocalInputInfoRec;
-
-extern DMXLocalInputInfoPtr dmxLocalCorePointer, dmxLocalCoreKeyboard;
-
-extern void                 dmxLocalInitInput(DMXInputInfo *dmxInput);
-extern DMXLocalInputInfoPtr dmxInputCopyLocal(DMXInputInfo *dmxInput,
-                                              DMXLocalInputInfoPtr s);
-
-extern void dmxChangePointerControl(DeviceIntPtr pDevice, PtrCtrl *ctrl);
-extern void dmxKeyboardKbdCtrlProc(DeviceIntPtr pDevice, KeybdCtrl *ctrl);
-extern void dmxKeyboardBellProc(int percent, DeviceIntPtr pDevice,
-                                pointer ctrl, int unknown);
-
-extern int  dmxInputExtensionErrorHandler(Display *dsp, char *name,
-                                          char *reason);
-
-extern int          dmxInputDetach(DMXInputInfo *dmxInput);
-extern void         dmxInputDetachAll(DMXScreenInfo *dmxScreen);
-extern int          dmxInputDetachId(int id);
-extern DMXInputInfo *dmxInputLocateId(int id);
-extern int          dmxInputAttachConsole(const char *name, int isCore,
-                                          int *id);
-extern int          dmxInputAttachBackend(int physicalScreen, int isCore,
-                                          int *id);
-
-#endif
+/*

+ * Copyright 2002 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ * Interface for low-level input support.  \see dmxinputinit.c */

+

+#ifndef _DMXINPUTINIT_H_

+#define _DMXINPUTINIT_H_

+

+#include "dmx.h"

+#include "dmxinput.h"

+#include "dmxlog.h"

+

+

+#define DMX_LOCAL_DEFAULT_KEYBOARD "kbd"

+#define DMX_LOCAL_DEFAULT_POINTER  "ps2"

+#define DMX_MAX_BUTTONS            256

+#define DMX_MOTION_SIZE            256

+#define DMX_MAX_VALUATORS          32

+#define DMX_MAX_AXES               32

+#define DMX_MAX_XINPUT_EVENT_TYPES 100

+#define DMX_MAP_ENTRIES            16 /* Must be a power of 2 */

+#define DMX_MAP_MASK               (DMX_MAP_ENTRIES - 1)

+

+typedef enum {

+    DMX_FUNCTION_GRAB,

+    DMX_FUNCTION_TERMINATE,

+    DMX_FUNCTION_FINE

+} DMXFunctionType;

+

+typedef enum {

+    DMX_LOCAL_HIGHLEVEL,

+    DMX_LOCAL_KEYBOARD,

+    DMX_LOCAL_MOUSE,

+    DMX_LOCAL_OTHER

+} DMXLocalInputType;

+

+typedef enum {

+    DMX_LOCAL_TYPE_LOCAL,

+    DMX_LOCAL_TYPE_CONSOLE,

+    DMX_LOCAL_TYPE_BACKEND,

+    DMX_LOCAL_TYPE_COMMON

+} DMXLocalInputExtType;

+

+typedef enum {

+    DMX_RELATIVE,

+    DMX_ABSOLUTE,

+    DMX_ABSOLUTE_CONFINED

+} DMXMotionType;

+

+/** Stores information from low-level device that is used to initialize

+ * the device at the dix level. */

+typedef struct _DMXLocalInitInfo {

+    int                  keyboard; /**< Non-zero if the device is a keyboard */

+    

+    int                  keyClass; /**< Non-zero if keys are present */

+    KeySymsRec           keySyms;  /**< Key symbols */

+    int                  freemap;  /**< If non-zero, free keySyms.map */

+    CARD8                modMap[MAP_LENGTH]; /**< Modifier map */

+    XkbDescPtr           xkb;       /**< XKB description */

+    XkbComponentNamesRec names;     /**< XKB component names */

+    int                  freenames; /**< Non-zero if names should be free'd */

+    int                  force;     /**< Do not allow command line override */

+

+    int                  buttonClass; /**< Non-zero if buttons are present */

+    int                  numButtons;  /**< Number of buttons */

+    unsigned char        map[DMX_MAX_BUTTONS]; /**< Button map */

+

+    int                  valuatorClass; /**< Non-zero if valuators are

+                                         * present */

+    int                  numRelAxes;    /**< Number of relative axes */

+    int                  numAbsAxes;    /**< Number of absolute axes */

+    int                  minval[DMX_MAX_AXES]; /**< Minimum values */

+    int                  maxval[DMX_MAX_AXES]; /**< Maximum values */

+    int                  res[DMX_MAX_AXES];    /**< Resolution */

+    int                  minres[DMX_MAX_AXES]; /**< Minimum resolutions */

+    int                  maxres[DMX_MAX_AXES]; /**< Maximum resolutions */

+

+    int                  focusClass;       /**< Non-zero if device can

+                                            * cause focus */

+    int                  proximityClass;   /**< Non-zero if device

+                                            * causes proximity events */

+    int                  kbdFeedbackClass; /**< Non-zero if device has

+                                            * keyboard feedback */ 

+    int                  ptrFeedbackClass; /**< Non-zero if device has

+                                            * pointer feedback */

+    int                  ledFeedbackClass; /**< Non-zero if device has

+                                            * LED indicators */

+    int                  belFeedbackClass; /**< Non-zero if device has a

+                                            * bell */ 

+    int                  intFeedbackClass; /**< Non-zero if device has

+                                            * integer feedback */

+    int                  strFeedbackClass; /**< Non-zero if device has

+                                            * string feedback */

+

+    int                  maxSymbols;          /**< Maximum symbols */

+    int                  maxSymbolsSupported; /**< Maximum symbols supported */

+    KeySym               *symbols;            /**< Key symbols */

+} DMXLocalInitInfo, *DMXLocalInitInfoPtr;

+

+typedef pointer (*dmxCreatePrivateProcPtr)(DeviceIntPtr);

+typedef void    (*dmxDestroyPrivateProcPtr)(pointer);

+                

+typedef void    (*dmxInitProcPtr)(DevicePtr);

+typedef void    (*dmxReInitProcPtr)(DevicePtr);

+typedef void    (*dmxLateReInitProcPtr)(DevicePtr);

+typedef void    (*dmxGetInfoProcPtr)(DevicePtr, DMXLocalInitInfoPtr);

+typedef int     (*dmxOnProcPtr)(DevicePtr);

+typedef void    (*dmxOffProcPtr)(DevicePtr);

+typedef void    (*dmxUpdatePositionProcPtr)(pointer, int x, int y);

+                

+typedef void    (*dmxVTPreSwitchProcPtr)(pointer);  /* Turn I/O Off */

+typedef void    (*dmxVTPostSwitchProcPtr)(pointer); /* Turn I/O On */

+typedef void    (*dmxVTSwitchReturnProcPtr)(pointer);

+typedef int     (*dmxVTSwitchProcPtr)(pointer, int vt,

+                                      dmxVTSwitchReturnProcPtr, pointer);

+                

+typedef void    (*dmxMotionProcPtr)(DevicePtr,

+                                    int *valuators,

+                                    int firstAxis,

+                                    int axesCount,

+                                    DMXMotionType type,

+                                    DMXBlockType block);

+typedef void    (*dmxEnqueueProcPtr)(DevicePtr, int type, int detail,

+                                     KeySym keySym, XEvent *e,

+                                     DMXBlockType block);

+typedef int     (*dmxCheckSpecialProcPtr)(DevicePtr, KeySym keySym);

+typedef void    (*dmxCollectEventsProcPtr)(DevicePtr,

+                                           dmxMotionProcPtr,

+                                           dmxEnqueueProcPtr,

+                                           dmxCheckSpecialProcPtr,

+                                           DMXBlockType);

+typedef void    (*dmxProcessInputProcPtr)(pointer);

+typedef void    (*dmxUpdateInfoProcPtr)(pointer, DMXUpdateType, WindowPtr);

+typedef int     (*dmxFunctionsProcPtr)(pointer, DMXFunctionType);

+                

+typedef void    (*dmxKBCtrlProcPtr)(DevicePtr, KeybdCtrl *ctrl);

+typedef void    (*dmxMCtrlProcPtr)(DevicePtr, PtrCtrl *ctrl);

+typedef void    (*dmxKBBellProcPtr)(DevicePtr, int percent,

+                                    int volume, int pitch, int duration);

+

+/** Stores a mapping between the device id on the remote X server and

+ * the id on the DMX server */

+typedef struct _DMXEventMap {

+    int remote;                 /**< Event number on remote X server */

+    int server;                 /**< Event number (unbiased) on DMX server */

+} DMXEventMap;

+

+/** This is the device-independent structure used by the low-level input

+ * routines.  The contents are not exposed to top-level .c files (except

+ * dmxextensions.c).  \see dmxinput.h \see dmxextensions.c */

+typedef struct _DMXLocalInputInfo {

+    const char               *name;   /**< Device name */

+    DMXLocalInputType        type;    /**< Device type  */

+    DMXLocalInputExtType     extType; /**< Extended device type */

+    int                      binding; /**< Count of how many consecutive

+                                       * structs are bound to the same

+                                       * device */

+    

+                                /* Low-level (e.g., keyboard/mouse drivers) */

+

+    dmxCreatePrivateProcPtr  create_private;  /**< Create

+                                               * device-dependent

+                                               * private */

+    dmxDestroyPrivateProcPtr destroy_private; /**< Destroy

+                                               * device-dependent

+                                               * private */

+    dmxInitProcPtr           init;            /**< Initialize device  */

+    dmxReInitProcPtr         reinit;          /**< Reinitialize device

+                                               * (during a

+                                               * reconfiguration) */

+    dmxLateReInitProcPtr     latereinit;      /**< Reinitialize a device

+                                               * (called very late

+                                               * during a

+                                               * reconfiguration) */

+    dmxGetInfoProcPtr        get_info;        /**< Get device information */

+    dmxOnProcPtr             on;              /**< Turn device on */

+    dmxOffProcPtr            off;             /**< Turn device off */

+    dmxUpdatePositionProcPtr update_position; /**< Called when another

+                                               * device updates the

+                                               * cursor position */

+    dmxVTPreSwitchProcPtr    vt_pre_switch;   /**< Called before a VT switch */

+    dmxVTPostSwitchProcPtr   vt_post_switch;  /**< Called after a VT switch */

+    dmxVTSwitchProcPtr       vt_switch;       /**< Causes a VT switch */

+

+    dmxCollectEventsProcPtr  collect_events;  /**< Collect and enqueue

+                                               * events from the

+                                               * device*/

+    dmxProcessInputProcPtr   process_input;   /**< Process event (from

+                                               * queue)  */

+    dmxFunctionsProcPtr      functions;

+    dmxUpdateInfoProcPtr     update_info;     /**< Update window layout

+                                               * information */

+

+    dmxMCtrlProcPtr          mCtrl;           /**< Pointer control */

+    dmxKBCtrlProcPtr         kCtrl;           /**< Keyboard control */

+    dmxKBBellProcPtr         kBell;           /**< Bell control */

+

+    pointer                  private;         /**< Device-dependent private  */

+    int                      isCore;          /**< Is a DMX core device  */

+    int                      sendsCore;       /**< Sends DMX core events */

+    KeybdCtrl                kctrl;           /**< Keyboard control */

+    PtrCtrl                  mctrl;           /**< Pointer control */

+

+    DeviceIntPtr             pDevice;         /**< X-level device  */

+    int                      inputIdx;        /**< High-level index */

+    int                      lastX, lastY;    /**< Last known position;

+                                               * for XInput in

+                                               * dmxevents.c */ 

+

+    int                      head;            /**< XInput motion history

+                                               * head */

+    int                      tail;            /**< XInput motion history

+                                               * tail */

+    unsigned long            *history;        /**< XInput motion history */

+    int                      *valuators;      /**< Cache of previous values */

+    

+                                /* for XInput ChangePointerDevice */

+    int                      (*savedMotionProc)(DeviceIntPtr,

+                                                xTimecoord *,

+                                                unsigned long,

+                                                unsigned long,

+                                                ScreenPtr);

+    int                      savedMotionEvents; /**< Saved motion events */

+    int                      savedSendsCore;    /**< Saved sends-core flag */

+

+    DMXEventMap              map[DMX_MAP_ENTRIES]; /**< XInput device id map */

+    int                      mapOptimize;          /**< XInput device id

+                                                    * map

+                                                    * optimization */

+

+    long                     deviceId;    /**< device id on remote side,

+                                           * if any */

+    const char               *deviceName; /**< devive name on remote

+                                           * side, if any */

+} DMXLocalInputInfoRec;

+

+extern DMXLocalInputInfoPtr dmxLocalCorePointer, dmxLocalCoreKeyboard;

+

+extern void                 dmxLocalInitInput(DMXInputInfo *dmxInput);

+extern DMXLocalInputInfoPtr dmxInputCopyLocal(DMXInputInfo *dmxInput,

+                                              DMXLocalInputInfoPtr s);

+

+extern void dmxChangePointerControl(DeviceIntPtr pDevice, PtrCtrl *ctrl);

+extern void dmxKeyboardKbdCtrlProc(DeviceIntPtr pDevice, KeybdCtrl *ctrl);

+extern void dmxKeyboardBellProc(int percent, DeviceIntPtr pDevice,

+                                pointer ctrl, int unknown);

+

+extern int  dmxInputExtensionErrorHandler(Display *dsp, _Xconst char *name,

+                                          _Xconst char *reason);

+

+extern int          dmxInputDetach(DMXInputInfo *dmxInput);

+extern void         dmxInputDetachAll(DMXScreenInfo *dmxScreen);

+extern int          dmxInputDetachId(int id);

+extern DMXInputInfo *dmxInputLocateId(int id);

+extern int          dmxInputAttachConsole(const char *name, int isCore,

+                                          int *id);

+extern int          dmxInputAttachBackend(int physicalScreen, int isCore,

+                                          int *id);

+

+#endif

diff --git a/xorg-server/hw/dmx/input/lnx-keyboard.c b/xorg-server/hw/dmx/input/lnx-keyboard.c
index 11f21e25c..269e84435 100644
--- a/xorg-server/hw/dmx/input/lnx-keyboard.c
+++ b/xorg-server/hw/dmx/input/lnx-keyboard.c
@@ -368,7 +368,7 @@ pointer kbdLinuxCreatePrivate(DeviceIntPtr pKeyboard)
 /** Destroy a private structure. */

 void kbdLinuxDestroyPrivate(pointer priv)

 {

-    if (priv) free(priv);

+    free(priv);

 }

 

 /** Ring the bell.

diff --git a/xorg-server/hw/dmx/input/lnx-ms.c b/xorg-server/hw/dmx/input/lnx-ms.c
index 549df46e2..e6d203c4b 100644
--- a/xorg-server/hw/dmx/input/lnx-ms.c
+++ b/xorg-server/hw/dmx/input/lnx-ms.c
@@ -1,321 +1,321 @@
-/* Portions of this file were derived from the following files:
- *
- **********************************************************************
- *
- * Xserver/hw/kdrive/linux/ms.c
- *
- * Copyright (c) 2001 by Juliusz Chroboczek
- * Copyright (c) 1999 by Keith Packard
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- */
-
-/*
- * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- *
- * This code implements a low-level device driver for a serial MS mouse.
- * The code is derived from code by Juliusz Chroboczek and Keith Packard
- * (see the source code for complete references). */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "inputstr.h"
-#include <X11/Xos.h>
-#include <errno.h>
-#include <termios.h>
-
-/*****************************************************************************/
-/* Define some macros to make it easier to move this file to another
- * part of the Xserver tree.  All calls to the dmx* layer are #defined
- * here for the .c file.  The .h file will also have to be edited. */
-#include "dmxinputinit.h"
-#include "lnx-ms.h"
-
-#define GETPRIV       myPrivate *priv                            \
-                      = ((DMXLocalInputInfoPtr)(pDev->devicePrivate))->private
-
-#define LOG0(f)       dmxLog(dmxDebug,f)
-#define LOG1(f,a)     dmxLog(dmxDebug,f,a)
-#define LOG2(f,a,b)   dmxLog(dmxDebug,f,a,b)
-#define LOG3(f,a,b,c) dmxLog(dmxDebug,f,a,b,c)
-#define FATAL0(f)     dmxLog(dmxFatal,f)
-#define FATAL1(f,a)   dmxLog(dmxFatal,f,a)
-#define FATAL2(f,a,b) dmxLog(dmxFatal,f,a,b)
-#define MOTIONPROC    dmxMotionProcPtr
-#define ENQUEUEPROC   dmxEnqueueProcPtr
-#define CHECKPROC     dmxCheckSpecialProcPtr
-#define BLOCK         DMXBlockType
-
-/* End of interface definitions. */
-/*****************************************************************************/
-
-/* Private area for MS mouse devices. */
-typedef struct _myPrivate {
-    DeviceIntPtr   pMouse;
-    int            fd;
-    struct termios tty;
-    enum {
-        button1 = 0x0001,
-        button2 = 0x0002,
-        button3 = 0x0004,
-        button4 = 0x0008,
-        button5 = 0x0010
-    }              buttons;
-} myPrivate;
-
-static int msLinuxReadBytes(int fd, unsigned char *buf, int len, int min)
-{
-    int		    n, tot;
-    fd_set	    set;
-    struct timeval  tv;
-    
-    tot = 0;
-    while (len) {
-        n = read(fd, buf, len);
-        if (n > 0) {
-            tot += n;
-	    buf += n;
-	    len -= n;
-	}
-	if (tot % min == 0) break;
-	FD_ZERO(&set);
-	FD_SET(fd, &set);
-	tv.tv_sec = 0;
-	tv.tv_usec = 100 * 1000;
-	n = select(fd + 1, &set, 0, 0, &tv);
-	if (n <= 0) break;
-    }
-    return tot;
-}
-
-static void msLinuxButton(DevicePtr pDev, ENQUEUEPROC enqueue, int buttons,
-                          BLOCK block)
-{
-    GETPRIV;
-
-#define PRESS(b)                                         \
-    do {                                                 \
-        enqueue(pDev, ButtonPress, 0, 0, NULL, block);   \
-    } while (0)
-
-#define RELEASE(b)                                       \
-    do {                                                 \
-        enqueue(pDev, ButtonRelease, 0, 0, NULL, block); \
-    } while (0)
-          
-    if ((buttons & button1) && !(priv->buttons & button1)) PRESS(1);
-    if (!(buttons & button1) && (priv->buttons & button1)) RELEASE(1);
-
-    if ((buttons & button2) && !(priv->buttons & button2)) PRESS(2);
-    if (!(buttons & button2) && (priv->buttons & button2)) RELEASE(2);
-
-    if ((buttons & button3) && !(priv->buttons & button3)) PRESS(3);
-    if (!(buttons & button3) && (priv->buttons & button3)) RELEASE(3);
-
-    if ((buttons & button4) && !(priv->buttons & button4)) PRESS(4);
-    if (!(buttons & button4) && (priv->buttons & button4)) RELEASE(4);
-    
-    if ((buttons & button5) && !(priv->buttons & button5)) PRESS(5);
-    if (!(buttons & button5) && (priv->buttons & button5)) RELEASE(5);
-
-    priv->buttons = buttons;
-}
-
-/** Read an event from the \a pDev device.  If the event is a motion
- * event, enqueue it with the \a motion function.  Otherwise, check for
- * special keys with the \a checkspecial function and enqueue the event
- * with the \a enqueue function.  The \a block type is passed to the
- * functions so that they may block SIGIO handling as appropriate to the
- * caller of this function. */
-void msLinuxRead(DevicePtr pDev,
-                 MOTIONPROC motion,
-                 ENQUEUEPROC enqueue,
-                 CHECKPROC checkspecial,
-                 BLOCK block)
-{
-    GETPRIV;
-    unsigned char   buf[3 * 200]; /* RATS: Use ok */
-    unsigned char   *b;
-    int		    n;
-    int		    dx, dy, v[2];
-
-    while ((n = msLinuxReadBytes(priv->fd, buf, sizeof(buf), 3)) > 0) {
-	b = buf;
-	while (n >= 3) {
-	    dx   = (char)(((b[0] & 0x03) << 6) | (b[1] & 0x3f));
-	    dy   = (char)(((b[0] & 0x0c) << 4) | (b[2] & 0x3f));
-            v[0] = -dx;
-            v[1] = -dy;
-            
-            motion(pDev, v, 0, 2, 1, block);
-            msLinuxButton(pDev, enqueue, (((b[0] & 0x10) ? button3 : 0)
-                                          | ((b[0] & 0x20) ? button1 : 0)),
-                          block);
-            n -= 3;
-            b += 3;
-	}
-    }
-}
-
-/** Initialize \a pDev. */
-void msLinuxInit(DevicePtr pDev)
-{
-    GETPRIV;
-    const char *names[] = { "/dev/serialmouse", "/dev/mouse", NULL };
-    int        i;
-
-    if (priv->fd >=0) return;
-
-    for (i = 0; names[i]; i++) {
-        if ((priv->fd = open(names[i], O_RDWR | O_NONBLOCK, 0)) >= 0) break;
-    }
-    if (priv->fd < 0)
-        FATAL1("msLinuxInit: Cannot open mouse port (%s)\n",
-               strerror(errno));
-    
-    if (!isatty(priv->fd))
-        FATAL1("msLinuxInit: Mouse port %s is not a tty\n", names[i]);
-
-    if (tcgetattr(priv->fd, &priv->tty) < 0)
-        FATAL1("msLinuxInit: tcgetattr failed (%s)\n", strerror(errno));
-
-    write(priv->fd, "*n", 2);   /* 1200 baud */
-    usleep(100000);
-}
-
-/** Turn \a pDev on (i.e., take input from \a pDev). */
-int msLinuxOn(DevicePtr pDev)
-{
-    GETPRIV;
-    struct termios nTty;
-
-    if (priv->fd < 0) msLinuxInit(pDev);
-    
-    nTty             = priv->tty;
-    nTty.c_iflag    &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR
-                         | IGNCR | ICRNL | IXON | IXOFF);
-    nTty.c_oflag    &= ~OPOST;
-    nTty.c_lflag    &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
-    nTty.c_cflag    &= ~(CSIZE | PARENB);
-    nTty.c_cflag    |= CS8 | CLOCAL | CSTOPB;
-    nTty.c_cc[VTIME] = 0;
-    nTty.c_cc[VMIN]  = 1;
-    cfsetispeed (&nTty, B1200);
-    cfsetospeed (&nTty, B1200);
-    if (tcsetattr(priv->fd, TCSANOW, &nTty) < 0)
-        FATAL1("msLinuxInit: tcsetattr failed (%s)\n", strerror(errno));
-    write(priv->fd, "*V", 2);   /* 2 button 3 byte protocol */
-    return priv->fd;
-}
-
-/** Turn \a pDev off (i.e., stop taking input from \a pDev). */
-void msLinuxOff(DevicePtr pDev)
-{
-    GETPRIV;
-
-    tcsetattr(priv->fd, TCSANOW, &priv->tty);
-    close(priv->fd);
-    priv->fd = -1;
-}
-
-static void msLinuxGetMap(DevicePtr pDev, unsigned char *map, int *nButtons)
-{
-    int i;
-    
-    if (nButtons) *nButtons = 3;
-    if (map) for (i = 0; i <= *nButtons; i++) map[i] = i;
-}
-
-/** Currently unused hook called prior to an VT switch. */
-void msLinuxVTPreSwitch(pointer p)
-{
-}
-
-/** Currently unused hook called after returning from a VT switch. */
-void msLinuxVTPostSwitch(pointer p)
-{
-}
-
-/** Create a private structure for use within this file. */
-pointer msLinuxCreatePrivate(DeviceIntPtr pMouse)
-{
-    myPrivate *priv = calloc(1, sizeof(*priv));
-    priv->fd     = -1;
-    priv->pMouse = pMouse;
-    return priv;
-}
-
-/** Destroy a private structure. */
-void msLinuxDestroyPrivate(pointer priv)
-{
-    if (priv) free(priv);
-}
-
-/** Fill the \a info structure with information needed to initialize \a
- * pDev. */ 
-void msLinuxGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)
-{
-    info->buttonClass      = 1;
-    msLinuxGetMap(pDev, info->map, &info->numButtons);
-    info->valuatorClass    = 1;
-    info->numRelAxes       = 2;
-    info->minval[0]        = 0;
-    info->maxval[0]        = 0;
-    info->res[0]           = 1;
-    info->minres[0]        = 0;
-    info->maxres[0]        = 1;
-    info->ptrFeedbackClass = 1;
-}
+/* Portions of this file were derived from the following files:

+ *

+ **********************************************************************

+ *

+ * Xserver/hw/kdrive/linux/ms.c

+ *

+ * Copyright (c) 2001 by Juliusz Chroboczek

+ * Copyright (c) 1999 by Keith Packard

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation the rights to use, copy, modify, merge, publish,

+ * distribute, sublicense, and/or sell copies of the Software, and to

+ * permit persons to whom the Software is furnished to do so, subject to

+ * the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be

+ * included in all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ */

+

+/*

+ * Copyright 2001-2003 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ *

+ * This code implements a low-level device driver for a serial MS mouse.

+ * The code is derived from code by Juliusz Chroboczek and Keith Packard

+ * (see the source code for complete references). */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include "inputstr.h"

+#include <X11/Xos.h>

+#include <errno.h>

+#include <termios.h>

+

+/*****************************************************************************/

+/* Define some macros to make it easier to move this file to another

+ * part of the Xserver tree.  All calls to the dmx* layer are #defined

+ * here for the .c file.  The .h file will also have to be edited. */

+#include "dmxinputinit.h"

+#include "lnx-ms.h"

+

+#define GETPRIV       myPrivate *priv                            \

+                      = ((DMXLocalInputInfoPtr)(pDev->devicePrivate))->private

+

+#define LOG0(f)       dmxLog(dmxDebug,f)

+#define LOG1(f,a)     dmxLog(dmxDebug,f,a)

+#define LOG2(f,a,b)   dmxLog(dmxDebug,f,a,b)

+#define LOG3(f,a,b,c) dmxLog(dmxDebug,f,a,b,c)

+#define FATAL0(f)     dmxLog(dmxFatal,f)

+#define FATAL1(f,a)   dmxLog(dmxFatal,f,a)

+#define FATAL2(f,a,b) dmxLog(dmxFatal,f,a,b)

+#define MOTIONPROC    dmxMotionProcPtr

+#define ENQUEUEPROC   dmxEnqueueProcPtr

+#define CHECKPROC     dmxCheckSpecialProcPtr

+#define BLOCK         DMXBlockType

+

+/* End of interface definitions. */

+/*****************************************************************************/

+

+/* Private area for MS mouse devices. */

+typedef struct _myPrivate {

+    DeviceIntPtr   pMouse;

+    int            fd;

+    struct termios tty;

+    enum {

+        button1 = 0x0001,

+        button2 = 0x0002,

+        button3 = 0x0004,

+        button4 = 0x0008,

+        button5 = 0x0010

+    }              buttons;

+} myPrivate;

+

+static int msLinuxReadBytes(int fd, unsigned char *buf, int len, int min)

+{

+    int		    n, tot;

+    fd_set	    set;

+    struct timeval  tv;

+    

+    tot = 0;

+    while (len) {

+        n = read(fd, buf, len);

+        if (n > 0) {

+            tot += n;

+	    buf += n;

+	    len -= n;

+	}

+	if (tot % min == 0) break;

+	FD_ZERO(&set);

+	FD_SET(fd, &set);

+	tv.tv_sec = 0;

+	tv.tv_usec = 100 * 1000;

+	n = select(fd + 1, &set, 0, 0, &tv);

+	if (n <= 0) break;

+    }

+    return tot;

+}

+

+static void msLinuxButton(DevicePtr pDev, ENQUEUEPROC enqueue, int buttons,

+                          BLOCK block)

+{

+    GETPRIV;

+

+#define PRESS(b)                                         \

+    do {                                                 \

+        enqueue(pDev, ButtonPress, 0, 0, NULL, block);   \

+    } while (0)

+

+#define RELEASE(b)                                       \

+    do {                                                 \

+        enqueue(pDev, ButtonRelease, 0, 0, NULL, block); \

+    } while (0)

+          

+    if ((buttons & button1) && !(priv->buttons & button1)) PRESS(1);

+    if (!(buttons & button1) && (priv->buttons & button1)) RELEASE(1);

+

+    if ((buttons & button2) && !(priv->buttons & button2)) PRESS(2);

+    if (!(buttons & button2) && (priv->buttons & button2)) RELEASE(2);

+

+    if ((buttons & button3) && !(priv->buttons & button3)) PRESS(3);

+    if (!(buttons & button3) && (priv->buttons & button3)) RELEASE(3);

+

+    if ((buttons & button4) && !(priv->buttons & button4)) PRESS(4);

+    if (!(buttons & button4) && (priv->buttons & button4)) RELEASE(4);

+    

+    if ((buttons & button5) && !(priv->buttons & button5)) PRESS(5);

+    if (!(buttons & button5) && (priv->buttons & button5)) RELEASE(5);

+

+    priv->buttons = buttons;

+}

+

+/** Read an event from the \a pDev device.  If the event is a motion

+ * event, enqueue it with the \a motion function.  Otherwise, check for

+ * special keys with the \a checkspecial function and enqueue the event

+ * with the \a enqueue function.  The \a block type is passed to the

+ * functions so that they may block SIGIO handling as appropriate to the

+ * caller of this function. */

+void msLinuxRead(DevicePtr pDev,

+                 MOTIONPROC motion,

+                 ENQUEUEPROC enqueue,

+                 CHECKPROC checkspecial,

+                 BLOCK block)

+{

+    GETPRIV;

+    unsigned char   buf[3 * 200]; /* RATS: Use ok */

+    unsigned char   *b;

+    int		    n;

+    int		    dx, dy, v[2];

+

+    while ((n = msLinuxReadBytes(priv->fd, buf, sizeof(buf), 3)) > 0) {

+	b = buf;

+	while (n >= 3) {

+	    dx   = (char)(((b[0] & 0x03) << 6) | (b[1] & 0x3f));

+	    dy   = (char)(((b[0] & 0x0c) << 4) | (b[2] & 0x3f));

+            v[0] = -dx;

+            v[1] = -dy;

+            

+            motion(pDev, v, 0, 2, 1, block);

+            msLinuxButton(pDev, enqueue, (((b[0] & 0x10) ? button3 : 0)

+                                          | ((b[0] & 0x20) ? button1 : 0)),

+                          block);

+            n -= 3;

+            b += 3;

+	}

+    }

+}

+

+/** Initialize \a pDev. */

+void msLinuxInit(DevicePtr pDev)

+{

+    GETPRIV;

+    const char *names[] = { "/dev/serialmouse", "/dev/mouse", NULL };

+    int        i;

+

+    if (priv->fd >=0) return;

+

+    for (i = 0; names[i]; i++) {

+        if ((priv->fd = open(names[i], O_RDWR | O_NONBLOCK, 0)) >= 0) break;

+    }

+    if (priv->fd < 0)

+        FATAL1("msLinuxInit: Cannot open mouse port (%s)\n",

+               strerror(errno));

+    

+    if (!isatty(priv->fd))

+        FATAL1("msLinuxInit: Mouse port %s is not a tty\n", names[i]);

+

+    if (tcgetattr(priv->fd, &priv->tty) < 0)

+        FATAL1("msLinuxInit: tcgetattr failed (%s)\n", strerror(errno));

+

+    write(priv->fd, "*n", 2);   /* 1200 baud */

+    usleep(100000);

+}

+

+/** Turn \a pDev on (i.e., take input from \a pDev). */

+int msLinuxOn(DevicePtr pDev)

+{

+    GETPRIV;

+    struct termios nTty;

+

+    if (priv->fd < 0) msLinuxInit(pDev);

+    

+    nTty             = priv->tty;

+    nTty.c_iflag    &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR

+                         | IGNCR | ICRNL | IXON | IXOFF);

+    nTty.c_oflag    &= ~OPOST;

+    nTty.c_lflag    &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);

+    nTty.c_cflag    &= ~(CSIZE | PARENB);

+    nTty.c_cflag    |= CS8 | CLOCAL | CSTOPB;

+    nTty.c_cc[VTIME] = 0;

+    nTty.c_cc[VMIN]  = 1;

+    cfsetispeed (&nTty, B1200);

+    cfsetospeed (&nTty, B1200);

+    if (tcsetattr(priv->fd, TCSANOW, &nTty) < 0)

+        FATAL1("msLinuxInit: tcsetattr failed (%s)\n", strerror(errno));

+    write(priv->fd, "*V", 2);   /* 2 button 3 byte protocol */

+    return priv->fd;

+}

+

+/** Turn \a pDev off (i.e., stop taking input from \a pDev). */

+void msLinuxOff(DevicePtr pDev)

+{

+    GETPRIV;

+

+    tcsetattr(priv->fd, TCSANOW, &priv->tty);

+    close(priv->fd);

+    priv->fd = -1;

+}

+

+static void msLinuxGetMap(DevicePtr pDev, unsigned char *map, int *nButtons)

+{

+    int i;

+    

+    if (nButtons) *nButtons = 3;

+    if (map) for (i = 0; i <= *nButtons; i++) map[i] = i;

+}

+

+/** Currently unused hook called prior to an VT switch. */

+void msLinuxVTPreSwitch(pointer p)

+{

+}

+

+/** Currently unused hook called after returning from a VT switch. */

+void msLinuxVTPostSwitch(pointer p)

+{

+}

+

+/** Create a private structure for use within this file. */

+pointer msLinuxCreatePrivate(DeviceIntPtr pMouse)

+{

+    myPrivate *priv = calloc(1, sizeof(*priv));

+    priv->fd     = -1;

+    priv->pMouse = pMouse;

+    return priv;

+}

+

+/** Destroy a private structure. */

+void msLinuxDestroyPrivate(pointer priv)

+{

+    free(priv);

+}

+

+/** Fill the \a info structure with information needed to initialize \a

+ * pDev. */ 

+void msLinuxGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)

+{

+    info->buttonClass      = 1;

+    msLinuxGetMap(pDev, info->map, &info->numButtons);

+    info->valuatorClass    = 1;

+    info->numRelAxes       = 2;

+    info->minval[0]        = 0;

+    info->maxval[0]        = 0;

+    info->res[0]           = 1;

+    info->minres[0]        = 0;

+    info->maxres[0]        = 1;

+    info->ptrFeedbackClass = 1;

+}

diff --git a/xorg-server/hw/dmx/input/lnx-ps2.c b/xorg-server/hw/dmx/input/lnx-ps2.c
index 70918eef4..f40441fe7 100644
--- a/xorg-server/hw/dmx/input/lnx-ps2.c
+++ b/xorg-server/hw/dmx/input/lnx-ps2.c
@@ -1,289 +1,289 @@
-/* Portions of this file were derived from the following files:
- *
- **********************************************************************
- *
- * Xserver/hw/kdrive/linux/ps2.c
- *
- * Copyright (c) 1999 by 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.
- *
- */
-
-/*
- * Copyright 2001,2003 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- *
- * This code implements a low-level device driver for a serial MS mouse.
- * The code is derived from code by Keith Packard (see the source code
- * for complete references). */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "inputstr.h"
-#include <X11/Xos.h>
-#include <errno.h>
-#include <termios.h>
-
-/*****************************************************************************/
-/* Define some macros to make it easier to move this file to another
- * part of the Xserver tree.  All calls to the dmx* layer are #defined
- * here for the .c file.  The .h file will also have to be edited. */
-#include "dmxinputinit.h"
-#include "lnx-ps2.h"
-
-#define GETPRIV       myPrivate *priv                            \
-                      = ((DMXLocalInputInfoPtr)(pDev->devicePrivate))->private
-
-#define LOG0(f)       dmxLog(dmxDebug,f)
-#define LOG1(f,a)     dmxLog(dmxDebug,f,a)
-#define LOG2(f,a,b)   dmxLog(dmxDebug,f,a,b)
-#define LOG3(f,a,b,c) dmxLog(dmxDebug,f,a,b,c)
-#define FATAL0(f)     dmxLog(dmxFatal,f)
-#define FATAL1(f,a)   dmxLog(dmxFatal,f,a)
-#define FATAL2(f,a,b) dmxLog(dmxFatal,f,a,b)
-#define MOTIONPROC    dmxMotionProcPtr
-#define ENQUEUEPROC   dmxEnqueueProcPtr
-#define CHECKPROC     dmxCheckSpecialProcPtr
-#define BLOCK         DMXBlockType
-
-/* End of interface definitions. */
-/*****************************************************************************/
-
-/* Private area for PS/2 devices. */
-typedef struct _myPrivate {
-    DeviceIntPtr   pMouse;
-    int            fd;
-    enum {
-        button1 = 0x0001,
-        button2 = 0x0002,
-        button3 = 0x0004,
-        button4 = 0x0008,
-        button5 = 0x0010
-    }              buttons;
-} myPrivate;
-
-static int ps2LinuxReadBytes(int fd, unsigned char *buf, int len, int min)
-{
-    int		    n, tot;
-    fd_set	    set;
-    struct timeval  tv;
-    
-    tot = 0;
-    while (len) {
-        n = read(fd, buf, len);
-        if (n > 0) {
-            tot += n;
-	    buf += n;
-	    len -= n;
-	}
-	if (tot % min == 0) break;
-	FD_ZERO(&set);
-	FD_SET(fd, &set);
-	tv.tv_sec = 0;
-	tv.tv_usec = 100 * 1000;
-	n = select(fd + 1, &set, 0, 0, &tv);
-	if (n <= 0) break;
-    }
-    return tot;
-}
-
-static void ps2LinuxButton(DevicePtr pDev, ENQUEUEPROC enqueue,
-                           int buttons, BLOCK block)
-{
-    GETPRIV;
-    
-#define PRESS(b)                                         \
-    do {                                                 \
-        enqueue(pDev, ButtonPress, 0, 0, NULL, block);   \
-    } while (0)
-
-#define RELEASE(b)                                       \
-    do {                                                 \
-        enqueue(pDev, ButtonRelease, 0, 0, NULL, block); \
-    } while (0)
-          
-    if ((buttons & button1) && !(priv->buttons & button1)) PRESS(1);
-    if (!(buttons & button1) && (priv->buttons & button1)) RELEASE(1);
-
-    if ((buttons & button2) && !(priv->buttons & button2)) PRESS(2);
-    if (!(buttons & button2) && (priv->buttons & button2)) RELEASE(2);
-
-    if ((buttons & button3) && !(priv->buttons & button3)) PRESS(3);
-    if (!(buttons & button3) && (priv->buttons & button3)) RELEASE(3);
-
-    if ((buttons & button4) && !(priv->buttons & button4)) PRESS(4);
-    if (!(buttons & button4) && (priv->buttons & button4)) RELEASE(4);
-    
-    if ((buttons & button5) && !(priv->buttons & button5)) PRESS(5);
-    if (!(buttons & button5) && (priv->buttons & button5)) RELEASE(5);
-
-    priv->buttons = buttons;
-}
-
-/** Read an event from the \a pDev device.  If the event is a motion
- * event, enqueue it with the \a motion function.  Otherwise, check for
- * special keys with the \a checkspecial function and enqueue the event
- * with the \a enqueue function.  The \a block type is passed to the
- * functions so that they may block SIGIO handling as appropriate to the
- * caller of this function. */
-void ps2LinuxRead(DevicePtr pDev, MOTIONPROC motion,
-                  ENQUEUEPROC enqueue, CHECKPROC checkspecial, BLOCK block)
-{
-    GETPRIV;
-    unsigned char   buf[3 * 200]; /* RATS: Use ok */
-    unsigned char   *b;
-    int		    n;
-    int		    dx, dy, v[2];
-
-    while ((n = ps2LinuxReadBytes(priv->fd, buf, sizeof(buf), 3)) > 0) {
-	b = buf;
-	while (n >= 3) {
-            dx   =  b[1] - ((b[0] & 0x10) ? 256 : 0);
-            dy   = -b[2] + ((b[0] & 0x20) ? 256 : 0);
-            v[0] = -dx;
-            v[1] = -dy;
-
-            motion(pDev, v, 0, 2, 1, block);
-            ps2LinuxButton(pDev, enqueue, (((b[0] & 4) ? button2 : 0)
-                                           | ((b[0] & 2) ? button3 : 0)
-                                           | ((b[0] & 1) ? button1 : 0)),
-                           block);
-            n -= 3;
-            b += 3;
-	}
-    }
-}
-
-/** Initialize \a pDev. */
-void ps2LinuxInit(DevicePtr pDev)
-{
-    GETPRIV;
-    const char *names[] = { "/dev/mouse", "/dev/psaux", NULL };
-    int        i;
-
-    if (priv->fd >=0) return;
-
-    for (i = 0; names[i]; i++) {
-        if ((priv->fd = open(names[i], O_RDWR | O_NONBLOCK, 0)) >= 0) break;
-    }
-    if (priv->fd < 0)
-        FATAL1("ps2LinuxInit: Cannot open mouse port (%s)\n",
-               strerror(errno));
-}
-
-/** Turn \a pDev on (i.e., take input from \a pDev). */
-int ps2LinuxOn(DevicePtr pDev)
-{
-    GETPRIV;
-
-    if (priv->fd < 0) ps2LinuxInit(pDev);
-    return priv->fd;
-}
-
-/** Turn \a pDev off (i.e., stop taking input from \a pDev). */
-void ps2LinuxOff(DevicePtr pDev)
-{
-    GETPRIV;
-
-    close(priv->fd);
-    priv->fd = -1;
-}
-
-static void ps2LinuxGetMap(DevicePtr pDev, unsigned char *map, int *nButtons)
-{
-    int i;
-    
-    if (nButtons) *nButtons = 3;
-    if (map) for (i = 0; i <= *nButtons; i++) map[i] = i;
-}
-
-/** Currently unused hook called prior to an VT switch. */
-void ps2LinuxVTPreSwitch(pointer p)
-{
-}
-
-/** Currently unused hook called after returning from a VT switch. */
-void ps2LinuxVTPostSwitch(pointer p)
-{
-}
-
-/** Create a private structure for use within this file. */
-pointer ps2LinuxCreatePrivate(DeviceIntPtr pMouse)
-{
-    myPrivate *priv = calloc(1, sizeof(*priv));
-    priv->fd     = -1;
-    priv->pMouse = pMouse;
-    return priv;
-}
-
-/** Destroy a private structure. */
-void ps2LinuxDestroyPrivate(pointer priv)
-{
-    if (priv) free(priv);
-}
-
-/** Fill the \a info structure with information needed to initialize \a
- * pDev. */ 
-void ps2LinuxGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)
-{
-    info->buttonClass      = 1;
-    ps2LinuxGetMap(pDev, info->map, &info->numButtons);
-    info->valuatorClass    = 1;
-    info->numRelAxes       = 2;
-    info->minval[0]        = 0;
-    info->maxval[0]        = 0;
-    info->res[0]           = 1;
-    info->minres[0]        = 0;
-    info->maxres[0]        = 1;
-    info->ptrFeedbackClass = 1;
-}
+/* Portions of this file were derived from the following files:

+ *

+ **********************************************************************

+ *

+ * Xserver/hw/kdrive/linux/ps2.c

+ *

+ * Copyright (c) 1999 by 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.

+ *

+ */

+

+/*

+ * Copyright 2001,2003 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ *

+ * This code implements a low-level device driver for a serial MS mouse.

+ * The code is derived from code by Keith Packard (see the source code

+ * for complete references). */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include "inputstr.h"

+#include <X11/Xos.h>

+#include <errno.h>

+#include <termios.h>

+

+/*****************************************************************************/

+/* Define some macros to make it easier to move this file to another

+ * part of the Xserver tree.  All calls to the dmx* layer are #defined

+ * here for the .c file.  The .h file will also have to be edited. */

+#include "dmxinputinit.h"

+#include "lnx-ps2.h"

+

+#define GETPRIV       myPrivate *priv                            \

+                      = ((DMXLocalInputInfoPtr)(pDev->devicePrivate))->private

+

+#define LOG0(f)       dmxLog(dmxDebug,f)

+#define LOG1(f,a)     dmxLog(dmxDebug,f,a)

+#define LOG2(f,a,b)   dmxLog(dmxDebug,f,a,b)

+#define LOG3(f,a,b,c) dmxLog(dmxDebug,f,a,b,c)

+#define FATAL0(f)     dmxLog(dmxFatal,f)

+#define FATAL1(f,a)   dmxLog(dmxFatal,f,a)

+#define FATAL2(f,a,b) dmxLog(dmxFatal,f,a,b)

+#define MOTIONPROC    dmxMotionProcPtr

+#define ENQUEUEPROC   dmxEnqueueProcPtr

+#define CHECKPROC     dmxCheckSpecialProcPtr

+#define BLOCK         DMXBlockType

+

+/* End of interface definitions. */

+/*****************************************************************************/

+

+/* Private area for PS/2 devices. */

+typedef struct _myPrivate {

+    DeviceIntPtr   pMouse;

+    int            fd;

+    enum {

+        button1 = 0x0001,

+        button2 = 0x0002,

+        button3 = 0x0004,

+        button4 = 0x0008,

+        button5 = 0x0010

+    }              buttons;

+} myPrivate;

+

+static int ps2LinuxReadBytes(int fd, unsigned char *buf, int len, int min)

+{

+    int		    n, tot;

+    fd_set	    set;

+    struct timeval  tv;

+    

+    tot = 0;

+    while (len) {

+        n = read(fd, buf, len);

+        if (n > 0) {

+            tot += n;

+	    buf += n;

+	    len -= n;

+	}

+	if (tot % min == 0) break;

+	FD_ZERO(&set);

+	FD_SET(fd, &set);

+	tv.tv_sec = 0;

+	tv.tv_usec = 100 * 1000;

+	n = select(fd + 1, &set, 0, 0, &tv);

+	if (n <= 0) break;

+    }

+    return tot;

+}

+

+static void ps2LinuxButton(DevicePtr pDev, ENQUEUEPROC enqueue,

+                           int buttons, BLOCK block)

+{

+    GETPRIV;

+    

+#define PRESS(b)                                         \

+    do {                                                 \

+        enqueue(pDev, ButtonPress, 0, 0, NULL, block);   \

+    } while (0)

+

+#define RELEASE(b)                                       \

+    do {                                                 \

+        enqueue(pDev, ButtonRelease, 0, 0, NULL, block); \

+    } while (0)

+          

+    if ((buttons & button1) && !(priv->buttons & button1)) PRESS(1);

+    if (!(buttons & button1) && (priv->buttons & button1)) RELEASE(1);

+

+    if ((buttons & button2) && !(priv->buttons & button2)) PRESS(2);

+    if (!(buttons & button2) && (priv->buttons & button2)) RELEASE(2);

+

+    if ((buttons & button3) && !(priv->buttons & button3)) PRESS(3);

+    if (!(buttons & button3) && (priv->buttons & button3)) RELEASE(3);

+

+    if ((buttons & button4) && !(priv->buttons & button4)) PRESS(4);

+    if (!(buttons & button4) && (priv->buttons & button4)) RELEASE(4);

+    

+    if ((buttons & button5) && !(priv->buttons & button5)) PRESS(5);

+    if (!(buttons & button5) && (priv->buttons & button5)) RELEASE(5);

+

+    priv->buttons = buttons;

+}

+

+/** Read an event from the \a pDev device.  If the event is a motion

+ * event, enqueue it with the \a motion function.  Otherwise, check for

+ * special keys with the \a checkspecial function and enqueue the event

+ * with the \a enqueue function.  The \a block type is passed to the

+ * functions so that they may block SIGIO handling as appropriate to the

+ * caller of this function. */

+void ps2LinuxRead(DevicePtr pDev, MOTIONPROC motion,

+                  ENQUEUEPROC enqueue, CHECKPROC checkspecial, BLOCK block)

+{

+    GETPRIV;

+    unsigned char   buf[3 * 200]; /* RATS: Use ok */

+    unsigned char   *b;

+    int		    n;

+    int		    dx, dy, v[2];

+

+    while ((n = ps2LinuxReadBytes(priv->fd, buf, sizeof(buf), 3)) > 0) {

+	b = buf;

+	while (n >= 3) {

+            dx   =  b[1] - ((b[0] & 0x10) ? 256 : 0);

+            dy   = -b[2] + ((b[0] & 0x20) ? 256 : 0);

+            v[0] = -dx;

+            v[1] = -dy;

+

+            motion(pDev, v, 0, 2, 1, block);

+            ps2LinuxButton(pDev, enqueue, (((b[0] & 4) ? button2 : 0)

+                                           | ((b[0] & 2) ? button3 : 0)

+                                           | ((b[0] & 1) ? button1 : 0)),

+                           block);

+            n -= 3;

+            b += 3;

+	}

+    }

+}

+

+/** Initialize \a pDev. */

+void ps2LinuxInit(DevicePtr pDev)

+{

+    GETPRIV;

+    const char *names[] = { "/dev/mouse", "/dev/psaux", NULL };

+    int        i;

+

+    if (priv->fd >=0) return;

+

+    for (i = 0; names[i]; i++) {

+        if ((priv->fd = open(names[i], O_RDWR | O_NONBLOCK, 0)) >= 0) break;

+    }

+    if (priv->fd < 0)

+        FATAL1("ps2LinuxInit: Cannot open mouse port (%s)\n",

+               strerror(errno));

+}

+

+/** Turn \a pDev on (i.e., take input from \a pDev). */

+int ps2LinuxOn(DevicePtr pDev)

+{

+    GETPRIV;

+

+    if (priv->fd < 0) ps2LinuxInit(pDev);

+    return priv->fd;

+}

+

+/** Turn \a pDev off (i.e., stop taking input from \a pDev). */

+void ps2LinuxOff(DevicePtr pDev)

+{

+    GETPRIV;

+

+    close(priv->fd);

+    priv->fd = -1;

+}

+

+static void ps2LinuxGetMap(DevicePtr pDev, unsigned char *map, int *nButtons)

+{

+    int i;

+    

+    if (nButtons) *nButtons = 3;

+    if (map) for (i = 0; i <= *nButtons; i++) map[i] = i;

+}

+

+/** Currently unused hook called prior to an VT switch. */

+void ps2LinuxVTPreSwitch(pointer p)

+{

+}

+

+/** Currently unused hook called after returning from a VT switch. */

+void ps2LinuxVTPostSwitch(pointer p)

+{

+}

+

+/** Create a private structure for use within this file. */

+pointer ps2LinuxCreatePrivate(DeviceIntPtr pMouse)

+{

+    myPrivate *priv = calloc(1, sizeof(*priv));

+    priv->fd     = -1;

+    priv->pMouse = pMouse;

+    return priv;

+}

+

+/** Destroy a private structure. */

+void ps2LinuxDestroyPrivate(pointer priv)

+{

+    free(priv);

+}

+

+/** Fill the \a info structure with information needed to initialize \a

+ * pDev. */ 

+void ps2LinuxGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)

+{

+    info->buttonClass      = 1;

+    ps2LinuxGetMap(pDev, info->map, &info->numButtons);

+    info->valuatorClass    = 1;

+    info->numRelAxes       = 2;

+    info->minval[0]        = 0;

+    info->maxval[0]        = 0;

+    info->res[0]           = 1;

+    info->minres[0]        = 0;

+    info->maxres[0]        = 1;

+    info->ptrFeedbackClass = 1;

+}

diff --git a/xorg-server/hw/dmx/input/usb-common.c b/xorg-server/hw/dmx/input/usb-common.c
index 95c00b839..c655a2984 100644
--- a/xorg-server/hw/dmx/input/usb-common.c
+++ b/xorg-server/hw/dmx/input/usb-common.c
@@ -1,381 +1,381 @@
-/*
- * Copyright 2002-2003 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- *
- * Routines that are common between \a usb-keyboard.c, \a usb-mouse.c, and
- * \a usb-other.c */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "usb-private.h"
-
-#define USB_COMMON_DEBUG 1
-
-/*****************************************************************************/
-/* Define some macros to make it easier to move this file to another
- * part of the Xserver tree.  All calls to the dmx* layer are #defined
- * here for the .c file.  The .h file will also have to be edited. */
-#include "usb-mouse.h"
-
-#define GETPRIV       myPrivate *priv                                         \
-                      = ((DMXLocalInputInfoPtr)(pDev->devicePrivate))->private
-
-#define GETNAME       ((DMXLocalInputInfoPtr)(pDevice->public.devicePrivate)) \
-                      ->name
-
-#define LOG0(f)       dmxLog(dmxDebug,f)
-#define LOG1(f,a)     dmxLog(dmxDebug,f,a)
-#define LOG2(f,a,b)   dmxLog(dmxDebug,f,a,b)
-#define LOG3(f,a,b,c) dmxLog(dmxDebug,f,a,b,c)
-#define LOG1INPUT(p,f,a)         dmxLogInput(p->dmxInput,f,a)
-#define LOG3INPUT(p,f,a,b,c)     dmxLogInput(p->dmxInput,f,a,b,c)
-#define LOG5INPUT(p,f,a,b,c,d,e) dmxLogInput(p->dmxInput,f,a,b,c,d,e)
-#define FATAL0(f)     dmxLog(dmxFatal,f)
-#define FATAL1(f,a)   dmxLog(dmxFatal,f,a)
-#define FATAL2(f,a,b) dmxLog(dmxFatal,f,a,b)
-#define MOTIONPROC    dmxMotionProcPtr
-#define ENQUEUEPROC   dmxEnqueueProcPtr
-#define CHECKPROC     dmxCheckSpecialProcPtr
-#define BLOCK         DMXBlockType
-
-/* End of interface definitions. */
-/*****************************************************************************/
-
-
-/** Read an event from the \a pDev device.  If the event is a motion
- * event, enqueue it with the \a motion function.  Otherwise, enqueue
- * the event with the \a enqueue function.  The \a block type is passed
- * to the functions so that they may block SIGIO handling as appropriate
- * to the caller of this function.
- *
- * Since USB devices return EV_KEY events for buttons and keys, \a
- * minButton is used to decide if a Button or Key event should be
- * queued.*/
-void usbRead(DevicePtr pDev,
-             MOTIONPROC motion,
-             ENQUEUEPROC enqueue,
-             int minButton,
-             BLOCK block)
-{
-    GETPRIV;
-    struct input_event raw;
-    int                v[DMX_MAX_AXES];
-    int                axis;
-
-#define PRESS(b)                                         \
-    do {                                                 \
-        enqueue(pDev, ButtonPress, 0, 0, NULL, block);   \
-    } while (0)
-
-#define RELEASE(b)                                       \
-    do {                                                 \
-        enqueue(pDev, ButtonRelease, 0, 0, NULL, block); \
-    } while (0)
-
-    while (read(priv->fd, &raw, sizeof(raw)) > 0) {
-#if USB_COMMON_DEBUG > 1
-        LOG3("USB: type = %d, code = 0x%02x, value = %d\n",
-             raw.type, raw.code, raw.value);
-#endif
-        switch (raw.type) {
-        case EV_KEY:
-                                /* raw.value = 1 for first, 2 for repeat */
-            if (raw.code > minButton) {
-                if (raw.value) PRESS((raw.code & 0x0f) + 1);
-                else           RELEASE((raw.code & 0x0f) + 1);
-            } else {
-                enqueue(pDev, raw.value ? KeyPress : KeyRelease,
-                        0, 0, NULL, block);
-            }
-            break;
-        case EV_REL:
-            switch (raw.code) {
-            case REL_X:
-                v[0] = -raw.value;
-                v[1] = 0;
-                motion(pDev, v, 0, 2, DMX_RELATIVE, block);
-                break;
-            case REL_Y:
-                v[0] = 0;
-                v[1] = -raw.value;
-                motion(pDev, v, 0, 2, DMX_RELATIVE, block);
-                break;
-            case REL_WHEEL:
-                if ((int)raw.value > 0) {
-                    PRESS(4);
-                    RELEASE(4);
-                } else if ((int)raw.value < 0) {
-                    PRESS(5);
-                    RELEASE(5);
-                }
-                break;
-            default:
-                memset(v, 0, sizeof(v));
-                axis = priv->relmap[raw.code];
-                v[axis] = raw.value;
-                motion(pDev, v, axis, 1, DMX_RELATIVE, block);
-            }
-            break;
-        case EV_ABS:
-            memset(v, 0, sizeof(v));
-            axis = priv->absmap[raw.code];
-            v[axis] = raw.value;
-            motion(pDev, v, axis, 1, DMX_ABSOLUTE, block);
-            break;
-        }
-    }
-}
-
-#define test_bit(bit)  (priv->mask[(bit)/8] & (1 << ((bit)%8)))
-#define test_bits(bit) (bits[(bit)/8] & (1 << ((bit)%8)))
-
-static void usbPrint(myPrivate *priv,
-                     const char *filename, const char *devname, int fd)
-{
-    int           j, k;
-    DeviceIntPtr  pDevice = priv->pDevice;
-    unsigned char bits[KEY_MAX/8 + 1]; /* RATS: Use ok assuming that
-                                        * KEY_MAX is greater than
-                                        * REL_MAX, ABS_MAX, SND_MAX, and
-                                        * LED_MAX. */
-
-    LOG3INPUT(priv, "%s (%s) using %s\n", pDevice->name, GETNAME, filename);
-    LOG1INPUT(priv, "    %s\n", devname);
-    for (j = 0; j < EV_MAX; j++) {
-        if (test_bit(j)) {
-            const char *type  = "unknown";
-            char       extra[256]; /* FIXME: may cause buffer overflow */
-            extra[0] = '\0';
-            switch(j) {
-            case EV_KEY: type = "keys/buttons"; break;
-            case EV_REL: type = "relative";
-                memset(bits, 0, sizeof(bits));
-                ioctl(priv->fd, EVIOCGBIT(EV_REL, sizeof(bits)), bits);
-                for (k = 0; k < REL_MAX; k++) {
-                    if (test_bits(k)) switch (k) {
-                    case REL_X:      strcat(extra, " X");      break;
-                    case REL_Y:      strcat(extra, " Y");      break;
-                    case REL_Z:      strcat(extra, " Z");      break;
-                    case REL_HWHEEL: strcat(extra, " HWheel"); break;
-                    case REL_DIAL:   strcat(extra, " Dial");   break;
-                    case REL_WHEEL:  strcat(extra, " Wheel");  break;
-                    case REL_MISC:   strcat(extra, " Misc");   break;
-                    }
-                }
-                break;
-            case EV_ABS: type = "absolute";
-                memset(bits, 0, sizeof(bits));
-                ioctl(priv->fd, EVIOCGBIT(EV_ABS, sizeof(bits)), bits);
-                for (k = 0; k < ABS_MAX; k++) {
-                    if (test_bits(k)) switch (k) {
-                    case ABS_X:        strcat(extra," X");       break;
-                    case ABS_Y:        strcat(extra," Y");       break;
-                    case ABS_Z:        strcat(extra," Z");       break;
-                    case ABS_RX:       strcat(extra," RX");      break;
-                    case ABS_RY:       strcat(extra," RY");      break;
-                    case ABS_RZ:       strcat(extra," RZ");      break;
-                    case ABS_THROTTLE: strcat(extra," Throttle");break;
-                    case ABS_RUDDER:   strcat(extra," Rudder");  break;
-                    case ABS_WHEEL:    strcat(extra," Wheel");   break;
-                    case ABS_GAS:      strcat(extra," Gas");     break;
-                    case ABS_BRAKE:    strcat(extra," Break");   break;
-                    case ABS_HAT0X:    strcat(extra," Hat0X");   break;
-                    case ABS_HAT0Y:    strcat(extra," Hat0Y");   break;
-                    case ABS_HAT1X:    strcat(extra," Hat1X");   break;
-                    case ABS_HAT1Y:    strcat(extra," Hat1Y");   break;
-                    case ABS_HAT2X:    strcat(extra," Hat2X");   break;
-                    case ABS_HAT2Y:    strcat(extra," Hat2Y");   break;
-                    case ABS_HAT3X:    strcat(extra," Hat3X");   break;
-                    case ABS_HAT3Y:    strcat(extra," Hat3Y");   break;
-                    case ABS_PRESSURE: strcat(extra," Pressure");break;
-                    case ABS_DISTANCE: strcat(extra," Distance");break;
-                    case ABS_TILT_X:   strcat(extra," TiltX");   break;
-                    case ABS_TILT_Y:   strcat(extra," TiltY");   break;
-                    case ABS_MISC:     strcat(extra," Misc");    break;
-                    }
-                }
-                break;
-            case EV_MSC: type = "reserved";     break;
-            case EV_LED: type = "leds";
-                memset(bits, 0, sizeof(bits));
-                ioctl(priv->fd, EVIOCGBIT(EV_LED, sizeof(bits)), bits);
-                for (k = 0; k < LED_MAX; k++) {
-                    if (test_bits(k)) switch (k) {
-                    case LED_NUML:    strcat(extra," NumLock");  break;
-                    case LED_CAPSL:   strcat(extra," CapsLock"); break;
-                    case LED_SCROLLL: strcat(extra," ScrlLock"); break;
-                    case LED_COMPOSE: strcat(extra," Compose");  break;
-                    case LED_KANA:    strcat(extra," Kana");     break;
-                    case LED_SLEEP:   strcat(extra," Sleep");    break;
-                    case LED_SUSPEND: strcat(extra," Suspend");  break;
-                    case LED_MUTE:    strcat(extra," Mute");     break;
-                    case LED_MISC:    strcat(extra," Misc");     break;
-                    }
-                }
-                break;
-            case EV_SND: type = "sound";
-                memset(bits, 0, sizeof(bits));
-                ioctl(priv->fd, EVIOCGBIT(EV_SND, sizeof(bits)), bits);
-                for (k = 0; k < SND_MAX; k++) {
-                    if (test_bits(k)) switch (k) {
-                    case SND_CLICK:   strcat(extra," Click");    break;
-                    case SND_BELL:    strcat(extra," Bell");     break;
-                    }
-                }
-                break;
-            case EV_REP: type = "repeat";       break;
-            case EV_FF:  type = "feedback";     break;
-            }
-            LOG5INPUT(priv, "    Feature 0x%02x = %s%s%s%s\n", j, type,
-                      extra[0] ? " [" : "",
-                      extra[0] ? extra+1 : "",
-                      extra[0] ? "]" : "");
-        }
-    }
-}
-
-/** Initialized \a pDev as a \a usbMouse, \a usbKeyboard, or \a usbOther
-device. */ 
-void usbInit(DevicePtr pDev, usbType type)
-{
-    GETPRIV;
-    char          name[64];            /* RATS: Only used in XmuSnprintf */
-    int           i, j, k;
-    char          buf[256] = { 0, };   /* RATS: Use ok */
-    int           version;
-    unsigned char bits[KEY_MAX/8 + 1]; /* RATS: Use ok assuming that
-                                        * KEY_MAX is greater than
-                                        * REL_MAX, ABS_MAX, SND_MAX, and
-                                        * LED_MAX. */
-
-    if (priv->fd >=0) return;
-
-    for (i = 0; i < 32; i++) {
-        XmuSnprintf(name, sizeof(name), "/dev/input/event%d", i);
-        if ((priv->fd = open(name, O_RDWR | O_NONBLOCK, 0)) >= 0) {
-            ioctl(priv->fd, EVIOCGVERSION, &version);
-            ioctl(priv->fd, EVIOCGNAME(sizeof(buf)), buf);
-            memset(priv->mask, 0, sizeof(priv->mask));
-            ioctl(priv->fd, EVIOCGBIT(0, sizeof(priv->mask)), priv->mask);
-
-            for (j = 0; j < EV_MAX; j++) {
-                if (test_bit(j)) {
-                    switch(j) {
-                    case EV_REL:
-                        memset(bits, 0, sizeof(bits));
-                        ioctl(priv->fd, EVIOCGBIT(EV_REL, sizeof(bits)), bits);
-                        for (k = 0; k < REL_MAX; k++) {
-                            if (test_bits(k)) {
-                                if (k == REL_X)      priv->relmap[k] = 0;
-                                else if (k == REL_Y) priv->relmap[k] = 1;
-                                else priv->relmap[k] = 2 + priv->numAbs;
-                                ++priv->numRel;
-                            }
-                        }
-                        break;
-                    case EV_ABS:
-                        memset(bits, 0, sizeof(bits));
-                        ioctl(priv->fd, EVIOCGBIT(EV_ABS, sizeof(bits)), bits);
-                        for (k = 0; k < ABS_MAX; k++) {
-                            if (test_bits(k)) {
-                                priv->absmap[k] = priv->numAbs;
-                                ++priv->numAbs;
-                            }
-                        }
-                        break;
-                    case EV_LED:
-                        memset(bits, 0, sizeof(bits));
-                        ioctl(priv->fd, EVIOCGBIT(EV_LED, sizeof(bits)), bits);
-                        for (k = 0; k < LED_MAX; k++) {
-                            if (test_bits(k)) ++priv->numLeds;
-                        }
-                        break;
-                    }
-                }
-            }
-            switch (type) {
-            case usbMouse:
-                if (test_bit(EV_REL) && test_bit(EV_KEY))
-                    goto found;
-                break;
-            case usbKeyboard:
-                if (test_bit(EV_KEY) && test_bit(EV_LED) && !test_bit(EV_ABS))
-                    goto found;
-                break;
-            case usbOther:
-                if (!(test_bit(EV_REL) && test_bit(EV_KEY))
-                    && !(test_bit(EV_KEY) && test_bit(EV_LED)
-                         && !test_bit(EV_ABS)))
-                    goto found;
-                break;
-            }
-            close(priv->fd);
-            priv->fd = -1;
-        }
-    }
-    if (priv->fd < 0)
-        FATAL1("usbInit: Cannot open /dev/input/event* port (%s)\n"
-               "         If you have not done so, you may need to:\n"
-               "           rmmod mousedev; rmmod keybdev\n"
-               "           modprobe evdev\n",
-               strerror(errno));
-  found:
-    usbPrint(priv, name, buf, priv->fd);
-}
-
-/** Turn \a pDev off (i.e., stop taking input from \a pDev). */
-void usbOff(DevicePtr pDev)
-{
-    GETPRIV;
-
-    if (priv->fd >= 0) close(priv->fd);
-    priv->fd = -1;
-}
-
-/** Create a private structure for use within this file. */
-pointer usbCreatePrivate(DeviceIntPtr pDevice)
-{
-    myPrivate *priv = calloc(1, sizeof(*priv));
-    priv->fd        = -1;
-    priv->pDevice   = pDevice;
-    return priv;
-}
-
-/** Destroy a private structure. */
-void usbDestroyPrivate(pointer priv)
-{
-    if (priv) free(priv);
-}
+/*

+ * Copyright 2002-2003 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ *

+ * Routines that are common between \a usb-keyboard.c, \a usb-mouse.c, and

+ * \a usb-other.c */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include "usb-private.h"

+

+#define USB_COMMON_DEBUG 1

+

+/*****************************************************************************/

+/* Define some macros to make it easier to move this file to another

+ * part of the Xserver tree.  All calls to the dmx* layer are #defined

+ * here for the .c file.  The .h file will also have to be edited. */

+#include "usb-mouse.h"

+

+#define GETPRIV       myPrivate *priv                                         \

+                      = ((DMXLocalInputInfoPtr)(pDev->devicePrivate))->private

+

+#define GETNAME       ((DMXLocalInputInfoPtr)(pDevice->public.devicePrivate)) \

+                      ->name

+

+#define LOG0(f)       dmxLog(dmxDebug,f)

+#define LOG1(f,a)     dmxLog(dmxDebug,f,a)

+#define LOG2(f,a,b)   dmxLog(dmxDebug,f,a,b)

+#define LOG3(f,a,b,c) dmxLog(dmxDebug,f,a,b,c)

+#define LOG1INPUT(p,f,a)         dmxLogInput(p->dmxInput,f,a)

+#define LOG3INPUT(p,f,a,b,c)     dmxLogInput(p->dmxInput,f,a,b,c)

+#define LOG5INPUT(p,f,a,b,c,d,e) dmxLogInput(p->dmxInput,f,a,b,c,d,e)

+#define FATAL0(f)     dmxLog(dmxFatal,f)

+#define FATAL1(f,a)   dmxLog(dmxFatal,f,a)

+#define FATAL2(f,a,b) dmxLog(dmxFatal,f,a,b)

+#define MOTIONPROC    dmxMotionProcPtr

+#define ENQUEUEPROC   dmxEnqueueProcPtr

+#define CHECKPROC     dmxCheckSpecialProcPtr

+#define BLOCK         DMXBlockType

+

+/* End of interface definitions. */

+/*****************************************************************************/

+

+

+/** Read an event from the \a pDev device.  If the event is a motion

+ * event, enqueue it with the \a motion function.  Otherwise, enqueue

+ * the event with the \a enqueue function.  The \a block type is passed

+ * to the functions so that they may block SIGIO handling as appropriate

+ * to the caller of this function.

+ *

+ * Since USB devices return EV_KEY events for buttons and keys, \a

+ * minButton is used to decide if a Button or Key event should be

+ * queued.*/

+void usbRead(DevicePtr pDev,

+             MOTIONPROC motion,

+             ENQUEUEPROC enqueue,

+             int minButton,

+             BLOCK block)

+{

+    GETPRIV;

+    struct input_event raw;

+    int                v[DMX_MAX_AXES];

+    int                axis;

+

+#define PRESS(b)                                         \

+    do {                                                 \

+        enqueue(pDev, ButtonPress, 0, 0, NULL, block);   \

+    } while (0)

+

+#define RELEASE(b)                                       \

+    do {                                                 \

+        enqueue(pDev, ButtonRelease, 0, 0, NULL, block); \

+    } while (0)

+

+    while (read(priv->fd, &raw, sizeof(raw)) > 0) {

+#if USB_COMMON_DEBUG > 1

+        LOG3("USB: type = %d, code = 0x%02x, value = %d\n",

+             raw.type, raw.code, raw.value);

+#endif

+        switch (raw.type) {

+        case EV_KEY:

+                                /* raw.value = 1 for first, 2 for repeat */

+            if (raw.code > minButton) {

+                if (raw.value) PRESS((raw.code & 0x0f) + 1);

+                else           RELEASE((raw.code & 0x0f) + 1);

+            } else {

+                enqueue(pDev, raw.value ? KeyPress : KeyRelease,

+                        0, 0, NULL, block);

+            }

+            break;

+        case EV_REL:

+            switch (raw.code) {

+            case REL_X:

+                v[0] = -raw.value;

+                v[1] = 0;

+                motion(pDev, v, 0, 2, DMX_RELATIVE, block);

+                break;

+            case REL_Y:

+                v[0] = 0;

+                v[1] = -raw.value;

+                motion(pDev, v, 0, 2, DMX_RELATIVE, block);

+                break;

+            case REL_WHEEL:

+                if ((int)raw.value > 0) {

+                    PRESS(4);

+                    RELEASE(4);

+                } else if ((int)raw.value < 0) {

+                    PRESS(5);

+                    RELEASE(5);

+                }

+                break;

+            default:

+                memset(v, 0, sizeof(v));

+                axis = priv->relmap[raw.code];

+                v[axis] = raw.value;

+                motion(pDev, v, axis, 1, DMX_RELATIVE, block);

+            }

+            break;

+        case EV_ABS:

+            memset(v, 0, sizeof(v));

+            axis = priv->absmap[raw.code];

+            v[axis] = raw.value;

+            motion(pDev, v, axis, 1, DMX_ABSOLUTE, block);

+            break;

+        }

+    }

+}

+

+#define test_bit(bit)  (priv->mask[(bit)/8] & (1 << ((bit)%8)))

+#define test_bits(bit) (bits[(bit)/8] & (1 << ((bit)%8)))

+

+static void usbPrint(myPrivate *priv,

+                     const char *filename, const char *devname, int fd)

+{

+    int           j, k;

+    DeviceIntPtr  pDevice = priv->pDevice;

+    unsigned char bits[KEY_MAX/8 + 1]; /* RATS: Use ok assuming that

+                                        * KEY_MAX is greater than

+                                        * REL_MAX, ABS_MAX, SND_MAX, and

+                                        * LED_MAX. */

+

+    LOG3INPUT(priv, "%s (%s) using %s\n", pDevice->name, GETNAME, filename);

+    LOG1INPUT(priv, "    %s\n", devname);

+    for (j = 0; j < EV_MAX; j++) {

+        if (test_bit(j)) {

+            const char *type  = "unknown";

+            char       extra[256]; /* FIXME: may cause buffer overflow */

+            extra[0] = '\0';

+            switch(j) {

+            case EV_KEY: type = "keys/buttons"; break;

+            case EV_REL: type = "relative";

+                memset(bits, 0, sizeof(bits));

+                ioctl(priv->fd, EVIOCGBIT(EV_REL, sizeof(bits)), bits);

+                for (k = 0; k < REL_MAX; k++) {

+                    if (test_bits(k)) switch (k) {

+                    case REL_X:      strcat(extra, " X");      break;

+                    case REL_Y:      strcat(extra, " Y");      break;

+                    case REL_Z:      strcat(extra, " Z");      break;

+                    case REL_HWHEEL: strcat(extra, " HWheel"); break;

+                    case REL_DIAL:   strcat(extra, " Dial");   break;

+                    case REL_WHEEL:  strcat(extra, " Wheel");  break;

+                    case REL_MISC:   strcat(extra, " Misc");   break;

+                    }

+                }

+                break;

+            case EV_ABS: type = "absolute";

+                memset(bits, 0, sizeof(bits));

+                ioctl(priv->fd, EVIOCGBIT(EV_ABS, sizeof(bits)), bits);

+                for (k = 0; k < ABS_MAX; k++) {

+                    if (test_bits(k)) switch (k) {

+                    case ABS_X:        strcat(extra," X");       break;

+                    case ABS_Y:        strcat(extra," Y");       break;

+                    case ABS_Z:        strcat(extra," Z");       break;

+                    case ABS_RX:       strcat(extra," RX");      break;

+                    case ABS_RY:       strcat(extra," RY");      break;

+                    case ABS_RZ:       strcat(extra," RZ");      break;

+                    case ABS_THROTTLE: strcat(extra," Throttle");break;

+                    case ABS_RUDDER:   strcat(extra," Rudder");  break;

+                    case ABS_WHEEL:    strcat(extra," Wheel");   break;

+                    case ABS_GAS:      strcat(extra," Gas");     break;

+                    case ABS_BRAKE:    strcat(extra," Break");   break;

+                    case ABS_HAT0X:    strcat(extra," Hat0X");   break;

+                    case ABS_HAT0Y:    strcat(extra," Hat0Y");   break;

+                    case ABS_HAT1X:    strcat(extra," Hat1X");   break;

+                    case ABS_HAT1Y:    strcat(extra," Hat1Y");   break;

+                    case ABS_HAT2X:    strcat(extra," Hat2X");   break;

+                    case ABS_HAT2Y:    strcat(extra," Hat2Y");   break;

+                    case ABS_HAT3X:    strcat(extra," Hat3X");   break;

+                    case ABS_HAT3Y:    strcat(extra," Hat3Y");   break;

+                    case ABS_PRESSURE: strcat(extra," Pressure");break;

+                    case ABS_DISTANCE: strcat(extra," Distance");break;

+                    case ABS_TILT_X:   strcat(extra," TiltX");   break;

+                    case ABS_TILT_Y:   strcat(extra," TiltY");   break;

+                    case ABS_MISC:     strcat(extra," Misc");    break;

+                    }

+                }

+                break;

+            case EV_MSC: type = "reserved";     break;

+            case EV_LED: type = "leds";

+                memset(bits, 0, sizeof(bits));

+                ioctl(priv->fd, EVIOCGBIT(EV_LED, sizeof(bits)), bits);

+                for (k = 0; k < LED_MAX; k++) {

+                    if (test_bits(k)) switch (k) {

+                    case LED_NUML:    strcat(extra," NumLock");  break;

+                    case LED_CAPSL:   strcat(extra," CapsLock"); break;

+                    case LED_SCROLLL: strcat(extra," ScrlLock"); break;

+                    case LED_COMPOSE: strcat(extra," Compose");  break;

+                    case LED_KANA:    strcat(extra," Kana");     break;

+                    case LED_SLEEP:   strcat(extra," Sleep");    break;

+                    case LED_SUSPEND: strcat(extra," Suspend");  break;

+                    case LED_MUTE:    strcat(extra," Mute");     break;

+                    case LED_MISC:    strcat(extra," Misc");     break;

+                    }

+                }

+                break;

+            case EV_SND: type = "sound";

+                memset(bits, 0, sizeof(bits));

+                ioctl(priv->fd, EVIOCGBIT(EV_SND, sizeof(bits)), bits);

+                for (k = 0; k < SND_MAX; k++) {

+                    if (test_bits(k)) switch (k) {

+                    case SND_CLICK:   strcat(extra," Click");    break;

+                    case SND_BELL:    strcat(extra," Bell");     break;

+                    }

+                }

+                break;

+            case EV_REP: type = "repeat";       break;

+            case EV_FF:  type = "feedback";     break;

+            }

+            LOG5INPUT(priv, "    Feature 0x%02x = %s%s%s%s\n", j, type,

+                      extra[0] ? " [" : "",

+                      extra[0] ? extra+1 : "",

+                      extra[0] ? "]" : "");

+        }

+    }

+}

+

+/** Initialized \a pDev as a \a usbMouse, \a usbKeyboard, or \a usbOther

+device. */ 

+void usbInit(DevicePtr pDev, usbType type)

+{

+    GETPRIV;

+    char          name[64];            /* RATS: Only used in XmuSnprintf */

+    int           i, j, k;

+    char          buf[256] = { 0, };   /* RATS: Use ok */

+    int           version;

+    unsigned char bits[KEY_MAX/8 + 1]; /* RATS: Use ok assuming that

+                                        * KEY_MAX is greater than

+                                        * REL_MAX, ABS_MAX, SND_MAX, and

+                                        * LED_MAX. */

+

+    if (priv->fd >=0) return;

+

+    for (i = 0; i < 32; i++) {

+        XmuSnprintf(name, sizeof(name), "/dev/input/event%d", i);

+        if ((priv->fd = open(name, O_RDWR | O_NONBLOCK, 0)) >= 0) {

+            ioctl(priv->fd, EVIOCGVERSION, &version);

+            ioctl(priv->fd, EVIOCGNAME(sizeof(buf)), buf);

+            memset(priv->mask, 0, sizeof(priv->mask));

+            ioctl(priv->fd, EVIOCGBIT(0, sizeof(priv->mask)), priv->mask);

+

+            for (j = 0; j < EV_MAX; j++) {

+                if (test_bit(j)) {

+                    switch(j) {

+                    case EV_REL:

+                        memset(bits, 0, sizeof(bits));

+                        ioctl(priv->fd, EVIOCGBIT(EV_REL, sizeof(bits)), bits);

+                        for (k = 0; k < REL_MAX; k++) {

+                            if (test_bits(k)) {

+                                if (k == REL_X)      priv->relmap[k] = 0;

+                                else if (k == REL_Y) priv->relmap[k] = 1;

+                                else priv->relmap[k] = 2 + priv->numAbs;

+                                ++priv->numRel;

+                            }

+                        }

+                        break;

+                    case EV_ABS:

+                        memset(bits, 0, sizeof(bits));

+                        ioctl(priv->fd, EVIOCGBIT(EV_ABS, sizeof(bits)), bits);

+                        for (k = 0; k < ABS_MAX; k++) {

+                            if (test_bits(k)) {

+                                priv->absmap[k] = priv->numAbs;

+                                ++priv->numAbs;

+                            }

+                        }

+                        break;

+                    case EV_LED:

+                        memset(bits, 0, sizeof(bits));

+                        ioctl(priv->fd, EVIOCGBIT(EV_LED, sizeof(bits)), bits);

+                        for (k = 0; k < LED_MAX; k++) {

+                            if (test_bits(k)) ++priv->numLeds;

+                        }

+                        break;

+                    }

+                }

+            }

+            switch (type) {

+            case usbMouse:

+                if (test_bit(EV_REL) && test_bit(EV_KEY))

+                    goto found;

+                break;

+            case usbKeyboard:

+                if (test_bit(EV_KEY) && test_bit(EV_LED) && !test_bit(EV_ABS))

+                    goto found;

+                break;

+            case usbOther:

+                if (!(test_bit(EV_REL) && test_bit(EV_KEY))

+                    && !(test_bit(EV_KEY) && test_bit(EV_LED)

+                         && !test_bit(EV_ABS)))

+                    goto found;

+                break;

+            }

+            close(priv->fd);

+            priv->fd = -1;

+        }

+    }

+    if (priv->fd < 0)

+        FATAL1("usbInit: Cannot open /dev/input/event* port (%s)\n"

+               "         If you have not done so, you may need to:\n"

+               "           rmmod mousedev; rmmod keybdev\n"

+               "           modprobe evdev\n",

+               strerror(errno));

+  found:

+    usbPrint(priv, name, buf, priv->fd);

+}

+

+/** Turn \a pDev off (i.e., stop taking input from \a pDev). */

+void usbOff(DevicePtr pDev)

+{

+    GETPRIV;

+

+    if (priv->fd >= 0) close(priv->fd);

+    priv->fd = -1;

+}

+

+/** Create a private structure for use within this file. */

+pointer usbCreatePrivate(DeviceIntPtr pDevice)

+{

+    myPrivate *priv = calloc(1, sizeof(*priv));

+    priv->fd        = -1;

+    priv->pDevice   = pDevice;

+    return priv;

+}

+

+/** Destroy a private structure. */

+void usbDestroyPrivate(pointer priv)

+{

+    free(priv);

+}

diff --git a/xorg-server/hw/kdrive/ephyr/ephyr.c b/xorg-server/hw/kdrive/ephyr/ephyr.c
index 21c696c20..404f4ca60 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyr.c
+++ b/xorg-server/hw/kdrive/ephyr/ephyr.c
@@ -346,13 +346,13 @@ ephyrInternalDamageRedisplay (ScreenPtr pScreen)
 

   pRegion = DamageRegion (scrpriv->pDamage);

 

-  if (REGION_NOTEMPTY (pScreen, pRegion))

+  if (RegionNotEmpty(pRegion))

     {

       int           nbox;

       BoxPtr        pbox;

 

-      nbox = REGION_NUM_RECTS (pRegion);

-      pbox = REGION_RECTS (pRegion);

+      nbox = RegionNumRects (pRegion);

+      pbox = RegionRects (pRegion);

 

       while (nbox--)

         {

@@ -908,10 +908,10 @@ ephyrExposePairedWindow (int a_remote)
 	return;

     }

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

-    REGION_NULL (screen, &reg);

-    REGION_COPY (screen, &reg, &pair->local->clipList);

+    RegionNull(&reg);

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

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

-    REGION_UNINIT (screen, &reg);

+    RegionUninit(&reg);

 }

 #endif /* XF86DRI */

 

diff --git a/xorg-server/hw/kdrive/ephyr/ephyrdriext.c b/xorg-server/hw/kdrive/ephyr/ephyrdriext.c
index 3d3d18a39..af411848f 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyrdriext.c
+++ b/xorg-server/hw/kdrive/ephyr/ephyrdriext.c
@@ -109,10 +109,10 @@ static Bool findWindowPairFromLocal (WindowPtr a_local,
 

 static unsigned char DRIReqCode = 0;

 

-static int ephyrDRIWindowKeyIndex;

-static DevPrivateKey ephyrDRIWindowKey = &ephyrDRIWindowKeyIndex;

-static int ephyrDRIScreenKeyIndex;

-static DevPrivateKey ephyrDRIScreenKey = &ephyrDRIScreenKeyIndex;

+static DevPrivateKeyRec ephyrDRIWindowKeyRec;

+#define ephyrDRIWindowKey (&ephyrDRIWindowKeyRec)

+static DevPrivateKeyRec ephyrDRIScreenKeyRec;

+#define ephyrDRIScreenKey (&ephyrDRIScreenKeyRec)

 

 #define GET_EPHYR_DRI_WINDOW_PRIV(win) ((EphyrDRIWindowPrivPtr) \

     dixLookupPrivate(&(win)->devPrivates, ephyrDRIWindowKey))

@@ -418,11 +418,11 @@ ephyrDRIClipNotify (WindowPtr a_win,
         EPHYR_LOG_ERROR ("failed to get window pair\n") ;

         goto out ;

     }

-    rects = calloc(REGION_NUM_RECTS (&a_win->clipList),

+    rects = calloc(RegionNumRects (&a_win->clipList),

                      sizeof (EphyrRect)) ;

-    for (i=0; i < REGION_NUM_RECTS (&a_win->clipList); i++) {

+    for (i=0; i < RegionNumRects (&a_win->clipList); i++) {

         memmove (&rects[i],

-                 &REGION_RECTS (&a_win->clipList)[i],

+                 &RegionRects (&a_win->clipList)[i],

                  sizeof (EphyrRect)) ;

         rects[i].x1 -= a_win->drawable.x;

         rects[i].x2 -= a_win->drawable.x;

@@ -436,7 +436,7 @@ ephyrDRIClipNotify (WindowPtr a_win,
     is_ok = hostx_set_window_bounding_rectangles

                                 (pair->remote,

                                  rects,

-                                 REGION_NUM_RECTS (&a_win->clipList)) ;

+                                 RegionNumRects (&a_win->clipList)) ;

     is_ok = TRUE ;

 

 out:

@@ -1168,12 +1168,12 @@ ProcXF86DRIGetDrawableInfo (register ClientPtr client)
         return BadMatch ;

     }

     EPHYR_LOG ("clip list of xephyr gl drawable:\n") ;

-    for (i=0; i < REGION_NUM_RECTS (&window->clipList); i++) {

+    for (i=0; i < RegionNumRects (&window->clipList); i++) {

         EPHYR_LOG ("x1:%d, y1:%d, x2:%d, y2:%d\n",

-                   REGION_RECTS (&window->clipList)[i].x1,

-                   REGION_RECTS (&window->clipList)[i].y1,

-                   REGION_RECTS (&window->clipList)[i].x2,

-                   REGION_RECTS (&window->clipList)[i].y2) ;

+                   RegionRects (&window->clipList)[i].x1,

+                   RegionRects (&window->clipList)[i].y1,

+                   RegionRects (&window->clipList)[i].x2,

+                   RegionRects (&window->clipList)[i].y2) ;

     }

 

     if (!ephyrDRIGetDrawableInfo (stuff->screen,

diff --git a/xorg-server/hw/kdrive/ephyr/ephyrvideo.c b/xorg-server/hw/kdrive/ephyr/ephyrvideo.c
index 14213c966..0fd1a63d4 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyrvideo.c
+++ b/xorg-server/hw/kdrive/ephyr/ephyrvideo.c
@@ -946,8 +946,8 @@ ephyrPutImage (KdScreenInfo *a_info,
                               a_drw_x, a_drw_y, a_drw_w, a_drw_h,

                               a_src_x, a_src_y, a_src_w, a_src_h,

                               a_width, a_height, a_buf,

-                              (EphyrHostBox*)REGION_RECTS (a_clipping_region),

-                              REGION_NUM_RECTS (a_clipping_region))) {

+                              (EphyrHostBox*)RegionRects (a_clipping_region),

+                              RegionNumRects (a_clipping_region))) {

         EPHYR_LOG_ERROR ("EphyrHostXVPutImage() failed\n") ;

         goto out ;

     }

@@ -1025,8 +1025,8 @@ ephyrReputImage (KdScreenInfo *a_info,
                               port_priv->src_w, port_priv->src_h,

                               port_priv->image_width, port_priv->image_height,

                               port_priv->image_buf,

-                              (EphyrHostBox*)REGION_RECTS (a_clipping_region),

-                              REGION_NUM_RECTS (a_clipping_region))) {

+                              (EphyrHostBox*)RegionRects (a_clipping_region),

+                              RegionNumRects (a_clipping_region))) {

         EPHYR_LOG_ERROR ("ephyrHostXVPutImage() failed\n") ;

         goto out ;

     }

@@ -1064,7 +1064,7 @@ ephyrPutVideo (KdScreenInfo *a_info,
     dst_box.y2 = a_drw_y + a_drw_h;

 

     if (!DoSimpleClip (&dst_box,

-                       REGION_EXTENTS (pScreen->pScreen, a_clipping_region),

+                       RegionExtents(a_clipping_region),

                        &clipped_area)) {

         EPHYR_LOG_ERROR ("failed to simple clip\n") ;

         goto out ;

@@ -1115,7 +1115,7 @@ ephyrGetVideo (KdScreenInfo *a_info,
     dst_box.y2 = a_drw_y + a_drw_h;

 

     if (!DoSimpleClip (&dst_box,

-                       REGION_EXTENTS (pScreen->pScreen, a_clipping_region),

+                       RegionExtents(a_clipping_region),

                        &clipped_area)) {

         EPHYR_LOG_ERROR ("failed to simple clip\n") ;

         goto out ;

@@ -1166,7 +1166,7 @@ ephyrPutStill (KdScreenInfo *a_info,
     dst_box.y2 = a_drw_y + a_drw_h;

 

     if (!DoSimpleClip (&dst_box,

-                       REGION_EXTENTS (pScreen->pScreen, a_clipping_region),

+                       RegionExtents(a_clipping_region),

                        &clipped_area)) {

         EPHYR_LOG_ERROR ("failed to simple clip\n") ;

         goto out ;

@@ -1217,7 +1217,7 @@ ephyrGetStill (KdScreenInfo *a_info,
     dst_box.y2 = a_drw_y + a_drw_h;

 

     if (!DoSimpleClip (&dst_box,

-                       REGION_EXTENTS (pScreen->pScreen, a_clipping_region),

+                       RegionExtents(a_clipping_region),

                        &clipped_area)) {

         EPHYR_LOG_ERROR ("failed to simple clip\n") ;

         goto out ;

diff --git a/xorg-server/hw/kdrive/ephyr/hostx.c b/xorg-server/hw/kdrive/ephyr/hostx.c
index 7a828eb31..4eb9cc1c0 100644
--- a/xorg-server/hw/kdrive/ephyr/hostx.c
+++ b/xorg-server/hw/kdrive/ephyr/hostx.c
@@ -1,1494 +1,1494 @@
-/*
- * 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
-
-/*
- * including some server headers (like kdrive-config.h)
- * might define the macro _XSERVER64
- * on 64 bits machines. That macro must _NOT_ be defined for Xlib
- * client code, otherwise bad things happen.
- * So let's undef that macro if necessary.
- */
-#ifdef _XSERVER64
-#undef _XSERVER64
-#endif
-
-
-#include "hostx.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h> 		/* for memset */
-#include <time.h>
-
-#ifndef _MSC_VER
-#include <sys/ipc.h>
-#include <sys/shm.h>
-#include <sys/time.h>
-#endif
-
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xatom.h>
-#include <X11/keysym.h>
-#include <X11/extensions/XShm.h>
-#include <X11/extensions/shape.h>
-#ifdef XF86DRI
-#include <GL/glx.h>
-#endif /* XF86DRI */
-#include "ephyrlog.h"
-
-#ifdef XF86DRI
-extern Bool XF86DRIQueryExtension (Display *dpy,
-                                   int *event_basep,
-                                   int *error_basep);
-#endif
-
-/*  
- * All xlib calls go here, which gets built as its own .a .
- * Mixing kdrive and xlib headers causes all sorts of types
- * to get clobbered. 
- */
-
-struct EphyrHostScreen
-{
-  Window          win;
-  Window          win_pre_existing; 	/* Set via -parent option like xnest */
-  Window          peer_win;          /* Used for GL; should be at most one */
-  XImage         *ximg;
-  int             win_width, win_height;
-  int             server_depth;
-  unsigned char  *fb_data;   	/* only used when host bpp != server bpp */
-  XShmSegmentInfo shminfo;
-
-  void           *info;   /* Pointer to the screen this is associated with */
-  int             mynum;  /* Screen number */
-};
-
-struct EphyrHostXVars
-{
-  char           *server_dpy_name;
-  Display        *dpy;
-  int             screen;
-  Visual         *visual;
-  Window          winroot;
-  GC              gc;
-  int             depth;
-  Bool            use_host_cursor;
-  Bool            use_fullscreen;
-  Bool            have_shm;
-
-  int             n_screens;
-  struct EphyrHostScreen *screens;
-
-  long            damage_debug_msec;
-
-  unsigned long   cmap[256];
-};
-
-/* memset ( missing> ) instead of below  */
-/*static EphyrHostXVars HostX = { "?", 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};*/
-static EphyrHostXVars HostX;
-
-static int            HostXWantDamageDebug = 0;
-
-extern EphyrKeySyms   ephyrKeySyms;
-
-extern int            monitorResolution;
-
-char           *ephyrResName = NULL;
-int             ephyrResNameFromCmd = 0;
-char	       *ephyrTitle = NULL;
-
-static void
-hostx_set_fullscreen_hint(void);
-
-/* X Error traps */
-
-static int trapped_error_code = 0;
-static int (*old_error_handler) (Display *d, XErrorEvent *e);
-
-#define host_depth_matches_server(_vars) (HostX.depth == (_vars)->server_depth)
-
-static struct EphyrHostScreen *
-host_screen_from_screen_info (EphyrScreenInfo *screen)
-{
-  int i;
-
-  for (i = 0 ; i < HostX.n_screens ; i++)
-    {
-      if ( HostX.screens[i].info == screen)
-        {
-          return &HostX.screens[i];
-        }
-    }
-  return NULL;
-}
-
-static int
-error_handler(Display     *display,
-              XErrorEvent *error)
-{
-  trapped_error_code = error->error_code;
-  return 0;
-}
-
-static void
-hostx_errors_trap(void)
-{
-  trapped_error_code = 0;
-  old_error_handler = XSetErrorHandler(error_handler);
-}
-
-static int
-hostx_errors_untrap(void)
-{
-  XSetErrorHandler(old_error_handler);
-  return trapped_error_code;
-}
-
-int
-hostx_want_screen_size (EphyrScreenInfo screen, int *width, int *height )
-{
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-
-  if (host_screen &&
-       (host_screen->win_pre_existing != None ||
-         HostX.use_fullscreen == True))
-    {
-      *width  = host_screen->win_width;
-      *height = host_screen->win_height;
-      return 1;
-    }
-
- return 0;
-}
-
-void
-hostx_add_screen (EphyrScreenInfo screen,
-                  unsigned long win_id,
-                  int screen_num)
-{
-  int index = HostX.n_screens;
-
-  HostX.n_screens += 1;
-  HostX.screens = realloc (HostX.screens,
-                           HostX.n_screens * sizeof(struct EphyrHostScreen));
-  memset (&HostX.screens[index], 0, sizeof (struct EphyrHostScreen));
-
-  HostX.screens[index].info       = screen;
-  HostX.screens[index].win_pre_existing = win_id;
-}
-
-
-void
-hostx_set_display_name (char *name)
-{
-#ifdef _MSC_VER
-  __asm int 3;
-#else
-  HostX.server_dpy_name = strdup (name);
-#endif
-}
-
-void
-hostx_set_screen_number(EphyrScreenInfo screen, int number)
-{
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-  if (host_screen) {
-    host_screen->mynum = number;
-    hostx_set_win_title (host_screen->info, "") ;
-  }}
-
-void
-hostx_set_win_title (EphyrScreenInfo screen, char *extra_text)
-{
-    struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-
-    if (!host_screen)
-    return;
-
-    if (ephyrTitle) {
-      XStoreName(HostX.dpy, host_screen->win, ephyrTitle);
-    } else {
-#define BUF_LEN 256
-      char buf[BUF_LEN+1];
-
-      memset (buf, 0, BUF_LEN+1) ;
-      snprintf (buf, BUF_LEN, "Xephyr on %s.%d %s", 
-		HostX.server_dpy_name, 
-		host_screen->mynum,
-		(extra_text != NULL) ? extra_text : "");
-
-      XStoreName (HostX.dpy, host_screen->win, buf);
-    }
-}
-
-int
-hostx_want_host_cursor (void)
-{
-  return HostX.use_host_cursor;
-}
-
-void
-hostx_use_host_cursor (void)
-{
-  HostX.use_host_cursor = True;
-}
-
-int
-hostx_want_preexisting_window (EphyrScreenInfo screen)
-{
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-
-  if (host_screen && host_screen->win_pre_existing)
-    {
-      return 1;
-    }
-  else
-    {
-    return 0;
-    }
-}
-
-void
-hostx_use_fullscreen (void)
-{
-  HostX.use_fullscreen = True;
-}
-
-int
-hostx_want_fullscreen (void)
-{
-  return HostX.use_fullscreen;
-}
-
-static void
-hostx_set_fullscreen_hint (void)
-{
-  Atom atom_WINDOW_STATE, atom_WINDOW_STATE_FULLSCREEN;
-  int index;
-
-  atom_WINDOW_STATE 
-    = XInternAtom(HostX.dpy, "_NET_WM_STATE", False);
-  atom_WINDOW_STATE_FULLSCREEN 
-    = XInternAtom(HostX.dpy, "_NET_WM_STATE_FULLSCREEN",False);
-
-  for (index = 0 ; index < HostX.n_screens ; index++)
-    {
-      XChangeProperty (HostX.dpy, HostX.screens[index].win,
-                       atom_WINDOW_STATE, XA_ATOM, 32,
-                       PropModeReplace,
-                       (unsigned char *)&atom_WINDOW_STATE_FULLSCREEN, 1);
-    }
-}
-
-
-static void
-hostx_toggle_damage_debug (void)
-{
-  HostXWantDamageDebug ^= 1;
-}
-
-void
-hostx_handle_signal (int signum)
-{
-  hostx_toggle_damage_debug();
-  EPHYR_DBG ("Signal caught. Damage Debug:%i\n",
-              HostXWantDamageDebug);
-}
-
-void
-hostx_use_resname (char *name, int fromcmd)
-{
-  ephyrResName = name;
-  ephyrResNameFromCmd = fromcmd;
-}
-
-void
-hostx_set_title (char *title)
-{
-  ephyrTitle = title;
-}
-
-int
-hostx_init (void)
-{
-  XSetWindowAttributes  attr;
-  Cursor                empty_cursor;
-  Pixmap                cursor_pxm;
-  XColor                col;
-  int                   index;
-  char                  *tmpstr;
-  XClassHint            *class_hint;
-
-  attr.event_mask =
-    ButtonPressMask
-    |ButtonReleaseMask
-    |PointerMotionMask
-    |KeyPressMask
-    |KeyReleaseMask
-    |ExposureMask;
-
-  EPHYR_DBG("mark");
-
-  if ((HostX.dpy = XOpenDisplay(getenv("DISPLAY"))) == NULL)
-    {
-      fprintf(stderr, "\nXephyr cannot open host display. Is DISPLAY set?\n");
-      exit(1);
-    }
-
-  HostX.screen  = DefaultScreen(HostX.dpy);
-  HostX.winroot = RootWindow(HostX.dpy, HostX.screen);
-  HostX.gc      = XCreateGC(HostX.dpy, HostX.winroot, 0, NULL);
-  HostX.depth   = DefaultDepth(HostX.dpy, HostX.screen);
-  HostX.visual  = DefaultVisual(HostX.dpy, HostX.screen);
-
-  class_hint = XAllocClassHint();
-
-  for (index = 0 ; index < HostX.n_screens ; index++)
-    {
-      struct EphyrHostScreen *host_screen = &HostX.screens[index];
-
-      host_screen->server_depth = HostX.depth;
-      if (host_screen->win_pre_existing != None)
-        {
-          Status            result;
-          XWindowAttributes prewin_attr;
-
-          /* Get screen size from existing window */
-
-          hostx_errors_trap();
-
-          result = XGetWindowAttributes (HostX.dpy,
-                                         host_screen->win_pre_existing,
-                                         &prewin_attr);
-
-
-          if (hostx_errors_untrap() || !result)
-          {
-              fprintf (stderr, "\nXephyr -parent window' does not exist!\n");
-              exit (1);
-          }
-
-          host_screen->win_width  = prewin_attr.width;
-          host_screen->win_height = prewin_attr.height;
-
-          host_screen->win = XCreateWindow (HostX.dpy,
-                                            host_screen->win_pre_existing,
-                                            0,0,
-                                            host_screen->win_width,
-                                            host_screen->win_height,
-                                            0,
-                                            CopyFromParent,
-                                            CopyFromParent,
-                                            CopyFromParent,
-                                            CWEventMask,
-                                            &attr);
-        }
-      else
-        {
-          host_screen->win = XCreateWindow (HostX.dpy,
-                                            HostX.winroot,
-                                            0,0,100,100, /* will resize */
-                                            0,
-                                            CopyFromParent,
-                                            CopyFromParent,
-                                            CopyFromParent,
-                                            CWEventMask,
-                                            &attr);
-
-          hostx_set_win_title (host_screen->info,
-                               "(ctrl+shift grabs mouse and keyboard)");
-
-          if (HostX.use_fullscreen)
-            {
-              host_screen->win_width  = DisplayWidth(HostX.dpy, HostX.screen);
-              host_screen->win_height = DisplayHeight(HostX.dpy, HostX.screen);
-
-              hostx_set_fullscreen_hint();
-            }
-
-          if (class_hint) 
-            {
-              tmpstr = getenv("RESOURCE_NAME");
-              if (tmpstr && (!ephyrResNameFromCmd))
-                ephyrResName = tmpstr;
-              class_hint->res_name = ephyrResName;
-              class_hint->res_class = "Xephyr";
-              XSetClassHint(hostx_get_display(), host_screen->win, class_hint);
-
-            }
-
-        }
-    }
-
-  if (class_hint)
-      XFree(class_hint);
-
-  XParseColor (HostX.dpy, DefaultColormap (HostX.dpy,HostX.screen),
-               "red", &col);
-  XAllocColor (HostX.dpy, DefaultColormap (HostX.dpy, HostX.screen),
-               &col);
-  XSetForeground (HostX.dpy, HostX.gc, col.pixel);
-
-  if (!hostx_want_host_cursor ())
-    {
-      /* Ditch the cursor, we provide our 'own' */
-      cursor_pxm = XCreatePixmap (HostX.dpy, HostX.winroot, 1, 1, 1);
-      memset (&col, 0, sizeof (col));
-      empty_cursor = XCreatePixmapCursor (HostX.dpy,
-                                          cursor_pxm, cursor_pxm, 
-                                          &col, &col, 1, 1);
-      for ( index = 0 ; index < HostX.n_screens ; index++ )
-        {
-          XDefineCursor (HostX.dpy,
-                         HostX.screens[index].win,
-                         empty_cursor);
-        }
-      XFreePixmap (HostX.dpy, cursor_pxm);
-    }
-
-  for (index = 0 ; index < HostX.n_screens ; index++)
-    {
-      HostX.screens[index].ximg   = NULL;
-    }
-  /* Try to get share memory ximages for a little bit more speed */
-
-#ifdef _MSC_VER
-  __asm int 3;
-#else
-  if (!XShmQueryExtension(HostX.dpy) || getenv("XEPHYR_NO_SHM"))
-    {
-      fprintf(stderr, "\nXephyr unable to use SHM XImages\n");
-      HostX.have_shm = False;
-    }
-  else
-    {
-      /* Really really check we have shm - better way ?*/
-      XShmSegmentInfo shminfo;
-
-        HostX.have_shm = True;
-
-        shminfo.shmid=shmget(IPC_PRIVATE, 1, IPC_CREAT|0777);
-        shminfo.shmaddr=shmat(shminfo.shmid,0,0);
-        shminfo.readOnly=True;
-
-        hostx_errors_trap();
-
-        XShmAttach(HostX.dpy, &shminfo);
-        XSync(HostX.dpy, False);
-
-        if (hostx_errors_untrap())
-          {
-            fprintf(stderr, "\nXephyr unable to use SHM XImages\n");
-            HostX.have_shm = False;
-          }
-
-        shmdt(shminfo.shmaddr);
-        shmctl(shminfo.shmid, IPC_RMID, 0);
-}
-#endif
-
-  XFlush(HostX.dpy);
-
-  /* Setup the pause time between paints when debugging updates */
-
-  HostX.damage_debug_msec = 20000; /* 1/50 th of a second */
-
-  if (getenv ("XEPHYR_PAUSE"))
-    {
-      HostX.damage_debug_msec = strtol (getenv ("XEPHYR_PAUSE"), NULL, 0);
-      EPHYR_DBG ("pause is %li\n", HostX.damage_debug_msec);
-    }
-
-  return 1;
-}
-
-int
-hostx_get_depth (void)
-{
-  return HostX.depth;
-}
-
-int
-hostx_get_server_depth (EphyrScreenInfo screen)
-{
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-
-  return (host_screen ? host_screen->server_depth : 0);
-}
-
-void
-hostx_set_server_depth (EphyrScreenInfo screen, int depth)
-{
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-
-  if (host_screen)
-    host_screen->server_depth = depth;
-}
-
-int
-hostx_get_bpp (EphyrScreenInfo screen)
-{
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-
-  if (!host_screen)
-    return 0;
-
-  if (host_depth_matches_server (host_screen))
-    return HostX.visual->bits_per_rgb;
-  else
-    return host_screen->server_depth; /*XXX correct ?*/
-}
-
-void
-hostx_get_visual_masks (EphyrScreenInfo screen,
-			CARD32 *rmsk,
-			CARD32 *gmsk,
-			CARD32 *bmsk)
-{
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-
-  if (!host_screen)
-    return;
-
-  if (host_depth_matches_server(host_screen))
-    {
-      *rmsk = HostX.visual->red_mask;
-      *gmsk = HostX.visual->green_mask;
-      *bmsk = HostX.visual->blue_mask;
-    }
-  else if (host_screen->server_depth == 16)
-    {
-      /* Assume 16bpp 565 */
-      *rmsk = 0xf800;
-      *gmsk = 0x07e0;
-      *bmsk = 0x001f;
-    }
-  else
-    {
-      *rmsk = 0x0;
-      *gmsk = 0x0;
-      *bmsk = 0x0;
-    }
-}
-
-static int 
-hostx_calculate_color_shift(unsigned long mask)
-{
-    int shift = 1;
-    /* count # of bits in mask */
-    while ((mask = (mask >> 1))) shift++;
-    /* cmap entry is an unsigned char so adjust it by size of that */
-    shift = shift - sizeof(unsigned char) * 8;
-    if (shift < 0) shift = 0;
-    return shift;
-}
-
-void
-hostx_set_cmap_entry(unsigned char idx,
-		     unsigned char r,
-		     unsigned char g,
-		     unsigned char b)
-{
-/* need to calculate the shifts for RGB because server could be BGR. */
-/* XXX Not sure if this is correct for 8 on 16, but this works for 8 on 24.*/
-    static int rshift, bshift, gshift = 0;
-    static int first_time = 1;
-    if (first_time) {
-	first_time = 0;
-	rshift = hostx_calculate_color_shift(HostX.visual->red_mask);
-	gshift = hostx_calculate_color_shift(HostX.visual->green_mask);
-	bshift = hostx_calculate_color_shift(HostX.visual->blue_mask);
-    }
-    HostX.cmap[idx] = ((r << rshift) & HostX.visual->red_mask) |
-		      ((g << gshift) & HostX.visual->green_mask) |
-		      ((b << bshift) & HostX.visual->blue_mask);
-}
-
-/**
- * hostx_screen_init creates the XImage that will contain the front buffer of
- * the ephyr screen, and possibly offscreen memory.
- *
- * @param width width of the screen
- * @param height height of the screen
- * @param buffer_height  height of the rectangle to be allocated.
- *
- * hostx_screen_init() creates an XImage, using MIT-SHM if it's available.
- * buffer_height can be used to create a larger offscreen buffer, which is used
- * by fakexa for storing offscreen pixmap data.
- */
-void*
-hostx_screen_init (EphyrScreenInfo screen,
-                   int width, int height,
-                   int buffer_height)
-{
-  int         bitmap_pad;
-  Bool        shm_success = False;
-  XSizeHints *size_hints;
-
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-  if (!host_screen)
-    {
-      fprintf (stderr, "%s: Error in accessing hostx data\n", __FUNCTION__ );
-      exit(1);
-    }
-
-  EPHYR_DBG ("host_screen=%p wxh=%dx%d, buffer_height=%d",
-             host_screen, width, height, buffer_height);
-
-  if (host_screen->ximg != NULL)
-    {
-      /* Free up the image data if previously used
-       * i.ie called by server reset
-       */
-
-      if (HostX.have_shm)
-	{
-#ifdef _MSC_VER
-	  __asm int 3;
-#else
-	  XShmDetach(HostX.dpy, &host_screen->shminfo);
-	  XDestroyImage (host_screen->ximg);
-	  shmdt(host_screen->shminfo.shmaddr);
-	  shmctl(host_screen->shminfo.shmid, IPC_RMID, 0);
-#endif
-	}
-      else
-	{
-	  if (host_screen->ximg->data) 
-	    {
-	      free(host_screen->ximg->data);
-	      host_screen->ximg->data = NULL;
-	    } 
-
-	  XDestroyImage(host_screen->ximg);
-	}
-    }
-
-  if (HostX.have_shm)
-    {
-#ifdef _MSC_VER
-__asm int 3;
-#else
-      host_screen->ximg = XShmCreateImage (HostX.dpy, HostX.visual, HostX.depth,
-                                           ZPixmap, NULL, &host_screen->shminfo,
-                                           width, buffer_height );
-
-      host_screen->shminfo.shmid =
-                      shmget(IPC_PRIVATE,
-                             host_screen->ximg->bytes_per_line * buffer_height,
-                             IPC_CREAT|0777);
-      host_screen->ximg->data = shmat(host_screen->shminfo.shmid, 0, 0);
-      host_screen->shminfo.shmaddr = host_screen->ximg->data;
-
-      if (host_screen->ximg->data == (char *)-1)
-	{
-	  EPHYR_DBG("Can't attach SHM Segment, falling back to plain XImages");
-	  HostX.have_shm = False;
-	  XDestroyImage(host_screen->ximg);
-	  shmctl(host_screen->shminfo.shmid, IPC_RMID, 0);
-	}
-      else
-	{
-	  EPHYR_DBG("SHM segment attached %p", host_screen->shminfo.shmaddr);
-	  host_screen->shminfo.readOnly = False;
-	  XShmAttach(HostX.dpy, &host_screen->shminfo);
-	  shm_success = True;
-	}
-#endif
-    }
-
-  if (!shm_success)
-    {
-      bitmap_pad = ( HostX.depth > 16 )? 32 : (( HostX.depth > 8 )? 16 : 8 );
-
-      EPHYR_DBG("Creating image %dx%d for screen host_screen=%p\n",
-                width, buffer_height, host_screen );
-      host_screen->ximg = XCreateImage (HostX.dpy,
-                                        HostX.visual,
-                                        HostX.depth,
-                                        ZPixmap, 0, 0,
-                                        width,
-                                        buffer_height,
-                                        bitmap_pad,
-                                        0);
-
-      host_screen->ximg->data =
-              malloc (host_screen->ximg->bytes_per_line * buffer_height);
-    }
-
-  XResizeWindow (HostX.dpy, host_screen->win, width, height);
-
-  /* Ask the WM to keep our size static */
-  size_hints = XAllocSizeHints();
-  size_hints->max_width = size_hints->min_width = width;
-  size_hints->max_height = size_hints->min_height = height;
-  size_hints->flags = PMinSize|PMaxSize;
-  XSetWMNormalHints(HostX.dpy, host_screen->win, size_hints);
-  XFree(size_hints);
-
-  XMapWindow(HostX.dpy, host_screen->win);
-
-  XSync(HostX.dpy, False);
-
-  host_screen->win_width  = width;
-  host_screen->win_height = height;
-
-  if (host_depth_matches_server(host_screen))
-    {
-      EPHYR_DBG("Host matches server");
-      return host_screen->ximg->data;
-    }
-  else
-    {
-      EPHYR_DBG("server bpp %i", host_screen->server_depth>>3);
-      host_screen->fb_data = malloc(width*buffer_height*(host_screen->server_depth>>3));
-      return host_screen->fb_data;
-    }
-}
-
-static void hostx_paint_debug_rect (struct EphyrHostScreen *host_screen,
-                                    int x,     int y,
-                                    int width, int height);
-
-void
-hostx_paint_rect (EphyrScreenInfo screen,
-                  int sx,    int sy,
-                  int dx,    int dy,
-                  int width, int height)
-{
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-
-  EPHYR_DBG ("painting in screen %d\n", host_screen->mynum) ;
-
-  /*
-   *  Copy the image data updated by the shadow layer
-   *  on to the window
-   */
-
-  if (HostXWantDamageDebug)
-    {
-      hostx_paint_debug_rect(host_screen, dx, dy, width, height);
-    }
-
-  /* 
-   * If the depth of the ephyr server is less than that of the host,
-   * the kdrive fb does not point to the ximage data but to a buffer
-   * ( fb_data ), we shift the various bits from this onto the XImage
-   * so they match the host.
-   *
-   * Note, This code is pretty new ( and simple ) so may break on 
-   *       endian issues, 32 bpp host etc. 
-   *       Not sure if 8bpp case is right either. 
-   *       ... and it will be slower than the matching depth case.
-   */
-
-  if (!host_depth_matches_server(host_screen))
-    {
-      int            x,y,idx, bytes_per_pixel = (host_screen->server_depth>>3);
-      unsigned char  r,g,b;
-      unsigned long  host_pixel;
-
-      EPHYR_DBG("Unmatched host depth host_screen=%p\n", host_screen);
-      for (y=sy; y<sy+height; y++)
-	for (x=sx; x<sx+width; x++)
-	  {
-	    idx = (host_screen->win_width*y*bytes_per_pixel)+(x*bytes_per_pixel);
-
-	    switch (host_screen->server_depth)
-	      {
-	      case 16:
-		{
-		  unsigned short pixel = *(unsigned short*)(host_screen->fb_data+idx);
-
-		  r = ((pixel & 0xf800) >> 8);
-		  g = ((pixel & 0x07e0) >> 3);
-		  b = ((pixel & 0x001f) << 3);
-
-		  host_pixel = (r << 16) | (g << 8) | (b);
-		  
-		  XPutPixel(host_screen->ximg, x, y, host_pixel);
-		  break;
-		}
-	      case 8:
-		{
-		  unsigned char pixel = *(unsigned char*)(host_screen->fb_data+idx);
-		  XPutPixel(host_screen->ximg, x, y, HostX.cmap[pixel]);
-		  break;
-		}
-	      default:
-		break;
-	      }
-	  }
-    }
-
-  if (HostX.have_shm)
-    {
-#ifdef _MSC_VER
-      __asm int 3;
-#else
-      XShmPutImage (HostX.dpy, host_screen->win,
-                    HostX.gc, host_screen->ximg,
-                    sx, sy, dx, dy, width, height, False);
-#endif
-    }
-  else
-    {
-      XPutImage (HostX.dpy, host_screen->win, HostX.gc, host_screen->ximg, 
-                 sx, sy, dx, dy, width, height);
-    }
-
-  XSync (HostX.dpy, False);
-}
-
-static void
-hostx_paint_debug_rect (struct EphyrHostScreen *host_screen,
-                        int x,     int y,
-                        int width, int height)
-{
-#ifdef _MSC_VER
-  __asm int 3;
-#else
-  struct timespec tspec;
-
-  tspec.tv_sec  = HostX.damage_debug_msec / (1000000);
-  tspec.tv_nsec = (HostX.damage_debug_msec % 1000000) * 1000;
-
-  EPHYR_DBG("msec: %li tv_sec %li, tv_msec %li", 
-	    HostX.damage_debug_msec, tspec.tv_sec, tspec.tv_nsec);
-
-  /* fprintf(stderr, "Xephyr updating: %i+%i %ix%i\n", x, y, width, height); */
-
-  XFillRectangle (HostX.dpy, host_screen->win, HostX.gc, x, y, width,height);
-  XSync (HostX.dpy, False);
-
-  /* nanosleep seems to work better than usleep for me... */
-  nanosleep(&tspec, NULL);
-#endif
-}
-
-void
-hostx_load_keymap(void)
-{
-  XID             *keymap;
-  int              host_width, min_keycode, max_keycode, width;
-  int              i,j;
-
-  XDisplayKeycodes (HostX.dpy, &min_keycode, &max_keycode);
-
-  EPHYR_DBG ("min: %d, max: %d", min_keycode, max_keycode);
-
-  keymap = XGetKeyboardMapping (HostX.dpy,
-			        min_keycode,
-			        max_keycode - min_keycode + 1,
-			        &host_width);
-
-  /* Try and copy the hosts keymap into our keymap to avoid loads
-   * of messing around.
-   *
-   * kdrive cannot can have more than 4 keysyms per keycode
-   * so we only copy at most the first 4 ( xorg has 6 per keycode, XVNC 2 )
-   */
-  width = (host_width > 4) ? 4 : host_width;
-
-  ephyrKeySyms.map = (CARD32 *)calloc(sizeof(CARD32),
-                                      (max_keycode - min_keycode + 1) *
-                                      width);
-  if (!ephyrKeySyms.map)
-        return;
-
-  for (i=0; i<(max_keycode - min_keycode+1); i++)
-    for (j=0; j<width; j++)
-      ephyrKeySyms.map[(i*width)+j] = (CARD32) keymap[(i*host_width) + j];
-
-  EPHYR_DBG("keymap width, host:%d kdrive:%d", host_width, width);
-
-  ephyrKeySyms.minKeyCode  = min_keycode;
-  ephyrKeySyms.maxKeyCode  = max_keycode;
-  ephyrKeySyms.mapWidth    = width;
-
-  XFree(keymap);
-}
-
-static struct EphyrHostScreen *
-host_screen_from_window (Window w)
-{
-  int index = 0;
-  struct EphyrHostScreen *result  = NULL;
-
-  for (index = 0 ; index < HostX.n_screens ; index++)
-    {
-      if (HostX.screens[index].win == w || HostX.screens[index].peer_win == w)
-        {
-          result = &HostX.screens[index];
-          goto out;
-        }
-    }
-
-out:
-  return result;
-}
-
-int
-hostx_get_event(EphyrHostXEvent *ev)
-{
-  XEvent      xev;
-  static int  grabbed_screen = -1;
-
-  if (XPending(HostX.dpy))
-    {
-      XNextEvent(HostX.dpy, &xev);
-
-      switch (xev.type) 
-	{
-	case Expose:
-	  /* Not so great event compression, but works ok */
-	  while (XCheckTypedWindowEvent(HostX.dpy, xev.xexpose.window,
-					Expose, &xev));
-	  {
-	    struct EphyrHostScreen *host_screen =
-                host_screen_from_window (xev.xexpose.window);
-            if (host_screen)
-              {
-                hostx_paint_rect (host_screen->info, 0, 0, 0, 0,
-                                  host_screen->win_width,
-                                  host_screen->win_height);
-              }
-            else
-              {
-                EPHYR_LOG_ERROR ("failed to get host screen\n");
-                ev->type = EPHYR_EV_EXPOSE;
-                ev->data.expose.window = xev.xexpose.window;
-                return 1;
-              }
-	  }
-	  return 0;
-
-	case MotionNotify:
-	  {
-	    struct EphyrHostScreen *host_screen =
-                host_screen_from_window (xev.xmotion.window);
-
-	    ev->type = EPHYR_EV_MOUSE_MOTION;
-	    ev->data.mouse_motion.x = xev.xmotion.x;
-	    ev->data.mouse_motion.y = xev.xmotion.y;
-	    ev->data.mouse_motion.window = xev.xmotion.window;
-	    ev->data.mouse_motion.screen = (host_screen ? host_screen->mynum : -1);
-	  }
-	  return 1;
-
-	case ButtonPress:
-	  ev->type = EPHYR_EV_MOUSE_PRESS;
-	  ev->key_state = xev.xkey.state;
-	  /* 
-	   * This is a bit hacky. will break for button 5 ( defined as 0x10 )
-           * Check KD_BUTTON defines in kdrive.h 
-	   */
-	  ev->data.mouse_down.button_num = 1<<(xev.xbutton.button-1);
-	  return 1;
-
-	case ButtonRelease:
-	  ev->type = EPHYR_EV_MOUSE_RELEASE;
-	  ev->key_state = xev.xkey.state;
-	  ev->data.mouse_up.button_num = 1<<(xev.xbutton.button-1);
-	  return 1;
-
-	case KeyPress:
-	  {
-	    ev->type = EPHYR_EV_KEY_PRESS;
-	    ev->key_state = xev.xkey.state;
-	    ev->data.key_down.scancode = xev.xkey.keycode;  
-	    return 1;
-	  }
-	case KeyRelease:
-
-	  if ((XKeycodeToKeysym(HostX.dpy,xev.xkey.keycode,0) == XK_Shift_L
-	       || XKeycodeToKeysym(HostX.dpy,xev.xkey.keycode,0) == XK_Shift_R)
-	      && (xev.xkey.state & ControlMask))
-	    {
-	      struct EphyrHostScreen *host_screen =
-                  host_screen_from_window (xev.xexpose.window);
-
-	      if (grabbed_screen != -1)
-		{
-		  XUngrabKeyboard (HostX.dpy, CurrentTime);
-		  XUngrabPointer (HostX.dpy, CurrentTime);
-		  grabbed_screen = -1;
-		  hostx_set_win_title (host_screen->info,
-                                       "(ctrl+shift grabs mouse and keyboard)");
-		}
-	      else
-		{
-		  /* Attempt grab */
-		  if (XGrabKeyboard (HostX.dpy, host_screen->win, True, 
-				     GrabModeAsync, 
-				     GrabModeAsync, 
-				     CurrentTime) == 0)
-		    {
-		      if (XGrabPointer (HostX.dpy, host_screen->win, True, 
-					NoEventMask, 
-					GrabModeAsync, 
-					GrabModeAsync, 
-					host_screen->win, None, CurrentTime) == 0)
-			{
-			  grabbed_screen = host_screen->mynum;
-			  hostx_set_win_title
-                                  (host_screen->info,
-                                   "(ctrl+shift releases mouse and keyboard)");
-			}
-		      else 	/* Failed pointer grabm  ungrab keyboard */
-			XUngrabKeyboard (HostX.dpy, CurrentTime);
-		    }
-		}
-	    }
-
-	  /* Still send the release event even if above has happened
-           * server will get confused with just an up event. 
-           * Maybe it would be better to just block shift+ctrls getting to
-           * kdrive all togeather. 
- 	   */
-	  ev->type = EPHYR_EV_KEY_RELEASE;
-	  ev->key_state = xev.xkey.state;
-	  ev->data.key_up.scancode = xev.xkey.keycode;
-	  return 1;
-
-	default:
-	  break;
-
-	}
-    }
-  return 0;
-}
-
-void*
-hostx_get_display(void)
-{
-    return HostX.dpy ;
-}
-
-int
-hostx_get_window (int a_screen_number)
-{
-    if (a_screen_number < 0 || a_screen_number >= HostX.n_screens) {
-        EPHYR_LOG_ERROR ("bad screen number:%d\n", a_screen_number) ;
-        return 0;
-    }
-    return HostX.screens[a_screen_number].win ;
-}
-
-int
-hostx_get_window_attributes (int a_window, EphyrHostWindowAttributes *a_attrs)
-{
-    XWindowAttributes attrs ;
-
-    memset (&attrs, 0, sizeof (attrs)) ;
-
-    if (!XGetWindowAttributes (hostx_get_display (),
-                               a_window,
-                               &attrs)) {
-        return FALSE ;
-    }
-    a_attrs->x = attrs.x ;
-    a_attrs->y = attrs.y ;
-    a_attrs->width = attrs.width ;
-    a_attrs->height = attrs.height ;
-    if (attrs.visual)
-        a_attrs->visualid = attrs.visual->visualid ;
-    return TRUE ;
-}
-
-int
-hostx_get_extension_info (const char *a_ext_name,
-                          int *a_major_opcode,
-                          int *a_first_event,
-                          int *a_first_error)
-{
-    if (!a_ext_name || !a_major_opcode || !a_first_event || !a_first_error)
-      return 0 ;
-   if (!XQueryExtension (HostX.dpy,
-                         a_ext_name,
-                         a_major_opcode,
-                         a_first_event,
-                         a_first_error))
-     {
-       return 0 ;
-     }
-   return 1 ;
-}
-
-int
-hostx_get_visuals_info (EphyrHostVisualInfo **a_visuals,
-                        int *a_num_entries)
-{
-    Display *dpy=hostx_get_display () ;
-    Bool is_ok=False ;
-    XVisualInfo templ, *visuals=NULL;
-    EphyrHostVisualInfo *host_visuals=NULL ;
-    int nb_items=0, i=0;
-
-    EPHYR_RETURN_VAL_IF_FAIL (a_visuals && a_num_entries && dpy,
-                              False) ;
-    EPHYR_LOG ("enter\n") ;
-    memset (&templ, 0, sizeof (templ)) ;
-    visuals = XGetVisualInfo (dpy, VisualNoMask, &templ, &nb_items) ;
-    if (!visuals) {
-        EPHYR_LOG_ERROR ("host does not advertise any visual\n") ;
-        goto out ;
-    }
-    EPHYR_LOG ("host advertises %d visuals\n", nb_items) ;
-    host_visuals = calloc (nb_items, sizeof (EphyrHostVisualInfo)) ;
-    for (i=0; i<nb_items; i++) {
-        host_visuals[i].visualid = visuals[i].visualid ;
-        host_visuals[i].screen = visuals[i].screen ;
-        host_visuals[i].depth = visuals[i].depth ;
-        host_visuals[i].class = visuals[i].class ;
-        host_visuals[i].red_mask = visuals[i].red_mask ;
-        host_visuals[i].green_mask = visuals[i].green_mask ;
-        host_visuals[i].blue_mask = visuals[i].blue_mask ;
-        host_visuals[i].colormap_size = visuals[i].colormap_size ;
-        host_visuals[i].bits_per_rgb = visuals[i].bits_per_rgb ;
-    }
-    *a_visuals = host_visuals ;
-    *a_num_entries = nb_items;
-    host_visuals=NULL;
-
-    is_ok = TRUE;
-out:
-    if (visuals) {
-        XFree (visuals) ;
-        visuals = NULL;
-    }
-    if (host_visuals) {
-        free (host_visuals) ;
-        host_visuals = NULL;
-    }
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
-
-}
-
-int
-hostx_create_window (int a_screen_number,
-                     EphyrBox *a_geometry,
-                     int a_visual_id,
-                     int *a_host_peer /*out parameter*/)
-{
-    Bool is_ok=FALSE ;
-    Display *dpy=hostx_get_display () ;
-    XVisualInfo *visual_info=NULL, visual_info_templ;
-    int visual_mask=VisualIDMask ;
-    Window win=None ;
-    int nb_visuals=0, winmask=0;
-    XSetWindowAttributes attrs;
-
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geometry, FALSE) ;
-
-    EPHYR_LOG ("enter\n") ;
-
-     /*get visual*/
-    memset (&visual_info, 0, sizeof (visual_info)) ;
-    visual_info_templ.visualid = a_visual_id ;
-    visual_info = XGetVisualInfo (dpy, visual_mask,
-                                  &visual_info_templ,
-                                  &nb_visuals) ;
-    if (!visual_info) {
-        EPHYR_LOG_ERROR ("argh, could not find a remote visual with id:%d\n",
-                         a_visual_id) ;
-        goto out ;
-    }
-    memset (&attrs, 0, sizeof (attrs)) ;
-    attrs.colormap = XCreateColormap (dpy,
-                                      RootWindow (dpy,
-                                                  visual_info->screen),
-                                      visual_info->visual,
-                                      AllocNone) ;
-    attrs.event_mask = ButtonPressMask
-                       |ButtonReleaseMask
-                       |PointerMotionMask
-                       |KeyPressMask
-                       |KeyReleaseMask
-                       |ExposureMask;
-    winmask = CWColormap|CWEventMask;
-
-    win = XCreateWindow (dpy, hostx_get_window (a_screen_number),
-                         a_geometry->x, a_geometry->y,
-                         a_geometry->width, a_geometry->height, 0,
-                         visual_info->depth, CopyFromParent,
-                         visual_info->visual, winmask, &attrs) ;
-    if (win == None) {
-        EPHYR_LOG_ERROR ("failed to create peer window\n") ;
-        goto out ;
-    }
-    if (HostX.screens[a_screen_number].peer_win == None) {
-	HostX.screens[a_screen_number].peer_win = win;
-    } else {
-        EPHYR_LOG_ERROR ("multiple peer windows created for same screen\n") ;
-    }
-    XFlush (dpy) ;
-    XMapWindow (dpy, win) ;
-    *a_host_peer = win ;
-    is_ok = TRUE ;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
-}
-
-int
-hostx_destroy_window (int a_win)
-{
-    Display *dpy=hostx_get_display () ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
-    XDestroyWindow (dpy, a_win) ;
-    XFlush (dpy) ;
-    return TRUE ;
-}
-
-int
-hostx_set_window_geometry (int a_win, EphyrBox *a_geo)
-{
-    Display *dpy=hostx_get_display ();
-
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geo, FALSE) ;
-
-    EPHYR_LOG ("enter. x,y,w,h:(%d,%d,%d,%d)\n",
-               a_geo->x, a_geo->y,
-               a_geo->width, a_geo->height) ;
-
-    XMoveWindow (dpy, a_win, a_geo->x, a_geo->y) ;
-    XResizeWindow (dpy, a_win, a_geo->width, a_geo->height) ;
-    EPHYR_LOG ("leave\n") ;
-    return TRUE;
-}
-
-int
-hostx_set_window_bounding_rectangles (int a_window,
-                                      EphyrRect *a_rects,
-                                      int a_num_rects)
-{
-    Bool is_ok=FALSE;
-    Display *dpy=hostx_get_display () ;
-    int i=0 ;
-    XRectangle *rects=NULL ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ;
-
-    EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ;
-
-    rects = calloc (a_num_rects, sizeof (XRectangle)) ;
-    for (i=0; i<a_num_rects; i++) {
-        rects[i].x = a_rects[i].x1 ;
-        rects[i].y = a_rects[i].y1 ;
-        rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1);
-        rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ;
-        EPHYR_LOG ("borders clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",
-                   rects[i].x, rects[i].y,
-                   rects[i].width, rects[i].height) ;
-    }
-    /*this aways returns 1*/
-#ifdef _MSC_VER
-    __asm int 3;
-#else
-    XShapeCombineRectangles (dpy, a_window, ShapeBounding, 0, 0,
-                             rects, a_num_rects, ShapeSet, YXBanded) ;
-#endif
-    is_ok = TRUE ;
-
-    if (rects) {
-        free (rects) ;
-        rects = NULL ;
-    }
-    EPHYR_LOG ("leave\n") ;
-    return is_ok;
-}
-
-int
-hostx_set_window_clipping_rectangles (int a_window,
-                                      EphyrRect *a_rects,
-                                      int a_num_rects)
-{
-    Bool is_ok=FALSE;
-    Display *dpy=hostx_get_display () ;
-    int i=0 ;
-    XRectangle *rects=NULL ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ;
-
-    EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ;
-
-    rects = calloc (a_num_rects, sizeof (XRectangle)) ;
-    for (i=0; i<a_num_rects; i++) {
-        rects[i].x = a_rects[i].x1 ;
-        rects[i].y = a_rects[i].y1 ;
-        rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1);
-        rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ;
-        EPHYR_LOG ("clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",
-                   rects[i].x, rects[i].y,
-                   rects[i].width, rects[i].height) ;
-    }
-    /*this aways returns 1*/
-#ifdef _MSC_VER
-    __asm int 3;
-#else
-    XShapeCombineRectangles (dpy, a_window, ShapeClip, 0, 0,
-                             rects, a_num_rects, ShapeSet, YXBanded) ;
-#endif
-    is_ok = TRUE ;
-
-    if (rects) {
-        free (rects) ;
-        rects = NULL ;
-    }
-    EPHYR_LOG ("leave\n") ;
-    return is_ok;
-}
-
-int
-hostx_has_xshape (void)
-{
-    int event_base=0, error_base=0 ;
-#ifdef _MSC_VER
-    __asm int 3;
-#else
-    Display *dpy=hostx_get_display () ;
-    if (!XShapeQueryExtension (dpy,
-                               &event_base,
-                               &error_base)) {
-        return FALSE ;
-    }
-#endif
-    return TRUE;
-}
-
-#ifdef XF86DRI
-typedef struct {
-    int is_valid ;
-    int local_id ;
-    int remote_id ;
-} ResourcePair ;
-
-#define RESOURCE_PEERS_SIZE 1024*10
-static ResourcePair resource_peers[RESOURCE_PEERS_SIZE] ;
-
-
-int
-hostx_allocate_resource_id_peer (int a_local_resource_id,
-                                 int *a_remote_resource_id)
-{
-    int i=0 ;
-    ResourcePair *peer=NULL ;
-    Display *dpy=hostx_get_display ();
-
-    /*
-     * first make sure a resource peer
-     * does not exist already for
-     * a_local_resource_id
-     */
-    for (i=0; i<RESOURCE_PEERS_SIZE; i++) {
-        if (resource_peers[i].is_valid
-            && resource_peers[i].local_id == a_local_resource_id) {
-            peer = &resource_peers[i] ;
-            break ;
-        }
-    }
-    /*
-     * find one free peer entry, an feed it with
-     */
-    if (!peer) {
-        for (i=0; i<RESOURCE_PEERS_SIZE; i++) {
-            if (!resource_peers[i].is_valid) {
-                peer = &resource_peers[i] ;
-                break ;
-            }
-        }
-        if (peer) {
-            peer->remote_id = XAllocID (dpy);
-            peer->local_id = a_local_resource_id ;
-            peer->is_valid = TRUE ;
-        }
-    }
-    if (peer) {
-        *a_remote_resource_id = peer->remote_id ;
-        return TRUE ;
-    }
-    return FALSE ;
-}
-
-int
-hostx_get_resource_id_peer (int a_local_resource_id,
-                            int *a_remote_resource_id)
-{
-    int i=0 ;
-    ResourcePair *peer=NULL ;
-    for (i=0; i<RESOURCE_PEERS_SIZE; i++) {
-        if (resource_peers[i].is_valid
-            && resource_peers[i].local_id == a_local_resource_id) {
-            peer = &resource_peers[i] ;
-            break ;
-        }
-    }
-    if (peer) {
-        *a_remote_resource_id = peer->remote_id ;
-        return TRUE ;
-    }
-    return FALSE ;
-}
-
-int
-hostx_has_dri (void)
-{
-    int event_base=0, error_base=0 ;
-    Display *dpy=hostx_get_display () ;
-
-    if (!dpy)
-        return FALSE ;
-
-    if (!XF86DRIQueryExtension (dpy,
-                                &event_base,
-                                &error_base)) {
-        return FALSE ;
-    }
-    return TRUE ;
-}
-
-int
-hostx_has_glx (void)
-{
-    Display *dpy=hostx_get_display () ;
-    int event_base=0, error_base=0 ;
-
-    if (!glXQueryExtension (dpy, &event_base, &error_base)) {
-        return FALSE ;
-    }
-    return TRUE ;
-}
-
-#endif /* XF86DRI */
+/*

+ * 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

+

+/*

+ * including some server headers (like kdrive-config.h)

+ * might define the macro _XSERVER64

+ * on 64 bits machines. That macro must _NOT_ be defined for Xlib

+ * client code, otherwise bad things happen.

+ * So let's undef that macro if necessary.

+ */

+#ifdef _XSERVER64

+#undef _XSERVER64

+#endif

+

+

+#include "hostx.h"

+

+#include <stdlib.h>

+#include <stdio.h>

+#include <unistd.h>

+#include <string.h> 		/* for memset */

+#include <time.h>

+

+#ifndef _MSC_VER

+#include <sys/ipc.h>

+#include <sys/shm.h>

+#include <sys/time.h>

+#endif

+

+#include <X11/Xlib.h>

+#include <X11/Xutil.h>

+#include <X11/Xatom.h>

+#include <X11/keysym.h>

+#include <X11/extensions/XShm.h>

+#include <X11/extensions/shape.h>

+#ifdef XF86DRI

+#include <GL/glx.h>

+#endif /* XF86DRI */

+#include "ephyrlog.h"

+

+#ifdef XF86DRI

+extern Bool XF86DRIQueryExtension (Display *dpy,

+                                   int *event_basep,

+                                   int *error_basep);

+#endif

+

+/*  

+ * All xlib calls go here, which gets built as its own .a .

+ * Mixing kdrive and xlib headers causes all sorts of types

+ * to get clobbered. 

+ */

+

+struct EphyrHostScreen

+{

+  Window          win;

+  Window          win_pre_existing; 	/* Set via -parent option like xnest */

+  Window          peer_win;          /* Used for GL; should be at most one */

+  XImage         *ximg;

+  int             win_width, win_height;

+  int             server_depth;

+  unsigned char  *fb_data;   	/* only used when host bpp != server bpp */

+  XShmSegmentInfo shminfo;

+

+  void           *info;   /* Pointer to the screen this is associated with */

+  int             mynum;  /* Screen number */

+};

+

+struct EphyrHostXVars

+{

+  char           *server_dpy_name;

+  Display        *dpy;

+  int             screen;

+  Visual         *visual;

+  Window          winroot;

+  GC              gc;

+  int             depth;

+  Bool            use_host_cursor;

+  Bool            use_fullscreen;

+  Bool            have_shm;

+

+  int             n_screens;

+  struct EphyrHostScreen *screens;

+

+  long            damage_debug_msec;

+

+  unsigned long   cmap[256];

+};

+

+/* memset ( missing> ) instead of below  */

+/*static EphyrHostXVars HostX = { "?", 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};*/

+static EphyrHostXVars HostX;

+

+static int            HostXWantDamageDebug = 0;

+

+extern EphyrKeySyms   ephyrKeySyms;

+

+extern int            monitorResolution;

+

+char           *ephyrResName = NULL;

+int             ephyrResNameFromCmd = 0;

+char	       *ephyrTitle = NULL;

+

+static void

+hostx_set_fullscreen_hint(void);

+

+/* X Error traps */

+

+static int trapped_error_code = 0;

+static int (*old_error_handler) (Display *d, XErrorEvent *e);

+

+#define host_depth_matches_server(_vars) (HostX.depth == (_vars)->server_depth)

+

+static struct EphyrHostScreen *

+host_screen_from_screen_info (EphyrScreenInfo *screen)

+{

+  int i;

+

+  for (i = 0 ; i < HostX.n_screens ; i++)

+    {

+      if ( HostX.screens[i].info == screen)

+        {

+          return &HostX.screens[i];

+        }

+    }

+  return NULL;

+}

+

+static int

+error_handler(Display     *display,

+              XErrorEvent *error)

+{

+  trapped_error_code = error->error_code;

+  return 0;

+}

+

+static void

+hostx_errors_trap(void)

+{

+  trapped_error_code = 0;

+  old_error_handler = XSetErrorHandler(error_handler);

+}

+

+static int

+hostx_errors_untrap(void)

+{

+  XSetErrorHandler(old_error_handler);

+  return trapped_error_code;

+}

+

+int

+hostx_want_screen_size (EphyrScreenInfo screen, int *width, int *height )

+{

+  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+

+  if (host_screen &&

+       (host_screen->win_pre_existing != None ||

+         HostX.use_fullscreen == True))

+    {

+      *width  = host_screen->win_width;

+      *height = host_screen->win_height;

+      return 1;

+    }

+

+ return 0;

+}

+

+void

+hostx_add_screen (EphyrScreenInfo screen,

+                  unsigned long win_id,

+                  int screen_num)

+{

+  int index = HostX.n_screens;

+

+  HostX.n_screens += 1;

+  HostX.screens = realloc (HostX.screens,

+                           HostX.n_screens * sizeof(struct EphyrHostScreen));

+  memset (&HostX.screens[index], 0, sizeof (struct EphyrHostScreen));

+

+  HostX.screens[index].info       = screen;

+  HostX.screens[index].win_pre_existing = win_id;

+}

+

+

+void

+hostx_set_display_name (char *name)

+{

+#ifdef _MSC_VER

+  __asm int 3;

+#else

+  HostX.server_dpy_name = strdup (name);

+#endif

+}

+

+void

+hostx_set_screen_number(EphyrScreenInfo screen, int number)

+{

+  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+  if (host_screen) {

+    host_screen->mynum = number;

+    hostx_set_win_title (host_screen->info, "") ;

+  }}

+

+void

+hostx_set_win_title (EphyrScreenInfo screen, char *extra_text)

+{

+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+

+    if (!host_screen)

+    return;

+

+    if (ephyrTitle) {

+      XStoreName(HostX.dpy, host_screen->win, ephyrTitle);

+    } else {

+#define BUF_LEN 256

+      char buf[BUF_LEN+1];

+

+      memset (buf, 0, BUF_LEN+1) ;

+      snprintf (buf, BUF_LEN, "Xephyr on %s.%d %s", 

+		HostX.server_dpy_name, 

+		host_screen->mynum,

+		(extra_text != NULL) ? extra_text : "");

+

+      XStoreName (HostX.dpy, host_screen->win, buf);

+    }

+}

+

+int

+hostx_want_host_cursor (void)

+{

+  return HostX.use_host_cursor;

+}

+

+void

+hostx_use_host_cursor (void)

+{

+  HostX.use_host_cursor = True;

+}

+

+int

+hostx_want_preexisting_window (EphyrScreenInfo screen)

+{

+  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+

+  if (host_screen && host_screen->win_pre_existing)

+    {

+      return 1;

+    }

+  else

+    {

+    return 0;

+    }

+}

+

+void

+hostx_use_fullscreen (void)

+{

+  HostX.use_fullscreen = True;

+}

+

+int

+hostx_want_fullscreen (void)

+{

+  return HostX.use_fullscreen;

+}

+

+static void

+hostx_set_fullscreen_hint (void)

+{

+  Atom atom_WINDOW_STATE, atom_WINDOW_STATE_FULLSCREEN;

+  int index;

+

+  atom_WINDOW_STATE 

+    = XInternAtom(HostX.dpy, "_NET_WM_STATE", False);

+  atom_WINDOW_STATE_FULLSCREEN 

+    = XInternAtom(HostX.dpy, "_NET_WM_STATE_FULLSCREEN",False);

+

+  for (index = 0 ; index < HostX.n_screens ; index++)

+    {

+      XChangeProperty (HostX.dpy, HostX.screens[index].win,

+                       atom_WINDOW_STATE, XA_ATOM, 32,

+                       PropModeReplace,

+                       (unsigned char *)&atom_WINDOW_STATE_FULLSCREEN, 1);

+    }

+}

+

+

+static void

+hostx_toggle_damage_debug (void)

+{

+  HostXWantDamageDebug ^= 1;

+}

+

+void

+hostx_handle_signal (int signum)

+{

+  hostx_toggle_damage_debug();

+  EPHYR_DBG ("Signal caught. Damage Debug:%i\n",

+              HostXWantDamageDebug);

+}

+

+void

+hostx_use_resname (char *name, int fromcmd)

+{

+  ephyrResName = name;

+  ephyrResNameFromCmd = fromcmd;

+}

+

+void

+hostx_set_title (char *title)

+{

+  ephyrTitle = title;

+}

+

+int

+hostx_init (void)

+{

+  XSetWindowAttributes  attr;

+  Cursor                empty_cursor;

+  Pixmap                cursor_pxm;

+  XColor                col;

+  int                   index;

+  char                  *tmpstr;

+  XClassHint            *class_hint;

+

+  attr.event_mask =

+    ButtonPressMask

+    |ButtonReleaseMask

+    |PointerMotionMask

+    |KeyPressMask

+    |KeyReleaseMask

+    |ExposureMask;

+

+  EPHYR_DBG("mark");

+

+  if ((HostX.dpy = XOpenDisplay(getenv("DISPLAY"))) == NULL)

+    {

+      fprintf(stderr, "\nXephyr cannot open host display. Is DISPLAY set?\n");

+      exit(1);

+    }

+

+  HostX.screen  = DefaultScreen(HostX.dpy);

+  HostX.winroot = RootWindow(HostX.dpy, HostX.screen);

+  HostX.gc      = XCreateGC(HostX.dpy, HostX.winroot, 0, NULL);

+  HostX.depth   = DefaultDepth(HostX.dpy, HostX.screen);

+  HostX.visual  = DefaultVisual(HostX.dpy, HostX.screen);

+

+  class_hint = XAllocClassHint();

+

+  for (index = 0 ; index < HostX.n_screens ; index++)

+    {

+      struct EphyrHostScreen *host_screen = &HostX.screens[index];

+

+      host_screen->server_depth = HostX.depth;

+      if (host_screen->win_pre_existing != None)

+        {

+          Status            result;

+          XWindowAttributes prewin_attr;

+

+          /* Get screen size from existing window */

+

+          hostx_errors_trap();

+

+          result = XGetWindowAttributes (HostX.dpy,

+                                         host_screen->win_pre_existing,

+                                         &prewin_attr);

+

+

+          if (hostx_errors_untrap() || !result)

+          {

+              fprintf (stderr, "\nXephyr -parent window' does not exist!\n");

+              exit (1);

+          }

+

+          host_screen->win_width  = prewin_attr.width;

+          host_screen->win_height = prewin_attr.height;

+

+          host_screen->win = XCreateWindow (HostX.dpy,

+                                            host_screen->win_pre_existing,

+                                            0,0,

+                                            host_screen->win_width,

+                                            host_screen->win_height,

+                                            0,

+                                            CopyFromParent,

+                                            CopyFromParent,

+                                            CopyFromParent,

+                                            CWEventMask,

+                                            &attr);

+        }

+      else

+        {

+          host_screen->win = XCreateWindow (HostX.dpy,

+                                            HostX.winroot,

+                                            0,0,100,100, /* will resize */

+                                            0,

+                                            CopyFromParent,

+                                            CopyFromParent,

+                                            CopyFromParent,

+                                            CWEventMask,

+                                            &attr);

+

+          hostx_set_win_title (host_screen->info,

+                               "(ctrl+shift grabs mouse and keyboard)");

+

+          if (HostX.use_fullscreen)

+            {

+              host_screen->win_width  = DisplayWidth(HostX.dpy, HostX.screen);

+              host_screen->win_height = DisplayHeight(HostX.dpy, HostX.screen);

+

+              hostx_set_fullscreen_hint();

+            }

+

+          if (class_hint) 

+            {

+              tmpstr = getenv("RESOURCE_NAME");

+              if (tmpstr && (!ephyrResNameFromCmd))

+                ephyrResName = tmpstr;

+              class_hint->res_name = ephyrResName;

+              class_hint->res_class = "Xephyr";

+              XSetClassHint(hostx_get_display(), host_screen->win, class_hint);

+

+            }

+

+        }

+    }

+

+  if (class_hint)

+      XFree(class_hint);

+

+  XParseColor (HostX.dpy, DefaultColormap (HostX.dpy,HostX.screen),

+               "red", &col);

+  XAllocColor (HostX.dpy, DefaultColormap (HostX.dpy, HostX.screen),

+               &col);

+  XSetForeground (HostX.dpy, HostX.gc, col.pixel);

+

+  if (!hostx_want_host_cursor ())

+    {

+      /* Ditch the cursor, we provide our 'own' */

+      cursor_pxm = XCreatePixmap (HostX.dpy, HostX.winroot, 1, 1, 1);

+      memset (&col, 0, sizeof (col));

+      empty_cursor = XCreatePixmapCursor (HostX.dpy,

+                                          cursor_pxm, cursor_pxm, 

+                                          &col, &col, 1, 1);

+      for ( index = 0 ; index < HostX.n_screens ; index++ )

+        {

+          XDefineCursor (HostX.dpy,

+                         HostX.screens[index].win,

+                         empty_cursor);

+        }

+      XFreePixmap (HostX.dpy, cursor_pxm);

+    }

+

+  for (index = 0 ; index < HostX.n_screens ; index++)

+    {

+      HostX.screens[index].ximg   = NULL;

+    }

+  /* Try to get share memory ximages for a little bit more speed */

+

+#ifdef _MSC_VER

+  __asm int 3;

+#else

+  if (!XShmQueryExtension(HostX.dpy) || getenv("XEPHYR_NO_SHM"))

+    {

+      fprintf(stderr, "\nXephyr unable to use SHM XImages\n");

+      HostX.have_shm = False;

+    }

+  else

+    {

+      /* Really really check we have shm - better way ?*/

+      XShmSegmentInfo shminfo;

+

+        HostX.have_shm = True;

+

+        shminfo.shmid=shmget(IPC_PRIVATE, 1, IPC_CREAT|0777);

+        shminfo.shmaddr=shmat(shminfo.shmid,0,0);

+        shminfo.readOnly=True;

+

+        hostx_errors_trap();

+

+        XShmAttach(HostX.dpy, &shminfo);

+        XSync(HostX.dpy, False);

+

+        if (hostx_errors_untrap())

+          {

+            fprintf(stderr, "\nXephyr unable to use SHM XImages\n");

+            HostX.have_shm = False;

+          }

+

+        shmdt(shminfo.shmaddr);

+        shmctl(shminfo.shmid, IPC_RMID, 0);

+}

+#endif

+

+  XFlush(HostX.dpy);

+

+  /* Setup the pause time between paints when debugging updates */

+

+  HostX.damage_debug_msec = 20000; /* 1/50 th of a second */

+

+  if (getenv ("XEPHYR_PAUSE"))

+    {

+      HostX.damage_debug_msec = strtol (getenv ("XEPHYR_PAUSE"), NULL, 0);

+      EPHYR_DBG ("pause is %li\n", HostX.damage_debug_msec);

+    }

+

+  return 1;

+}

+

+int

+hostx_get_depth (void)

+{

+  return HostX.depth;

+}

+

+int

+hostx_get_server_depth (EphyrScreenInfo screen)

+{

+  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+

+  return host_screen ? host_screen->server_depth : 0;

+}

+

+void

+hostx_set_server_depth (EphyrScreenInfo screen, int depth)

+{

+  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+

+  if (host_screen)

+    host_screen->server_depth = depth;

+}

+

+int

+hostx_get_bpp (EphyrScreenInfo screen)

+{

+  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+

+  if (!host_screen)

+    return 0;

+

+  if (host_depth_matches_server (host_screen))

+    return HostX.visual->bits_per_rgb;

+  else

+    return host_screen->server_depth; /*XXX correct ?*/

+}

+

+void

+hostx_get_visual_masks (EphyrScreenInfo screen,

+			CARD32 *rmsk,

+			CARD32 *gmsk,

+			CARD32 *bmsk)

+{

+  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+

+  if (!host_screen)

+    return;

+

+  if (host_depth_matches_server(host_screen))

+    {

+      *rmsk = HostX.visual->red_mask;

+      *gmsk = HostX.visual->green_mask;

+      *bmsk = HostX.visual->blue_mask;

+    }

+  else if (host_screen->server_depth == 16)

+    {

+      /* Assume 16bpp 565 */

+      *rmsk = 0xf800;

+      *gmsk = 0x07e0;

+      *bmsk = 0x001f;

+    }

+  else

+    {

+      *rmsk = 0x0;

+      *gmsk = 0x0;

+      *bmsk = 0x0;

+    }

+}

+

+static int 

+hostx_calculate_color_shift(unsigned long mask)

+{

+    int shift = 1;

+    /* count # of bits in mask */

+    while ((mask = (mask >> 1))) shift++;

+    /* cmap entry is an unsigned char so adjust it by size of that */

+    shift = shift - sizeof(unsigned char) * 8;

+    if (shift < 0) shift = 0;

+    return shift;

+}

+

+void

+hostx_set_cmap_entry(unsigned char idx,

+		     unsigned char r,

+		     unsigned char g,

+		     unsigned char b)

+{

+/* need to calculate the shifts for RGB because server could be BGR. */

+/* XXX Not sure if this is correct for 8 on 16, but this works for 8 on 24.*/

+    static int rshift, bshift, gshift = 0;

+    static int first_time = 1;

+    if (first_time) {

+	first_time = 0;

+	rshift = hostx_calculate_color_shift(HostX.visual->red_mask);

+	gshift = hostx_calculate_color_shift(HostX.visual->green_mask);

+	bshift = hostx_calculate_color_shift(HostX.visual->blue_mask);

+    }

+    HostX.cmap[idx] = ((r << rshift) & HostX.visual->red_mask) |

+		      ((g << gshift) & HostX.visual->green_mask) |

+		      ((b << bshift) & HostX.visual->blue_mask);

+}

+

+/**

+ * hostx_screen_init creates the XImage that will contain the front buffer of

+ * the ephyr screen, and possibly offscreen memory.

+ *

+ * @param width width of the screen

+ * @param height height of the screen

+ * @param buffer_height  height of the rectangle to be allocated.

+ *

+ * hostx_screen_init() creates an XImage, using MIT-SHM if it's available.

+ * buffer_height can be used to create a larger offscreen buffer, which is used

+ * by fakexa for storing offscreen pixmap data.

+ */

+void*

+hostx_screen_init (EphyrScreenInfo screen,

+                   int width, int height,

+                   int buffer_height)

+{

+  int         bitmap_pad;

+  Bool        shm_success = False;

+  XSizeHints *size_hints;

+

+  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+  if (!host_screen)

+    {

+      fprintf (stderr, "%s: Error in accessing hostx data\n", __FUNCTION__ );

+      exit(1);

+    }

+

+  EPHYR_DBG ("host_screen=%p wxh=%dx%d, buffer_height=%d",

+             host_screen, width, height, buffer_height);

+

+  if (host_screen->ximg != NULL)

+    {

+      /* Free up the image data if previously used

+       * i.ie called by server reset

+       */

+

+      if (HostX.have_shm)

+	{

+#ifdef _MSC_VER

+	  __asm int 3;

+#else

+	  XShmDetach(HostX.dpy, &host_screen->shminfo);

+	  XDestroyImage (host_screen->ximg);

+	  shmdt(host_screen->shminfo.shmaddr);

+	  shmctl(host_screen->shminfo.shmid, IPC_RMID, 0);

+#endif

+	}

+      else

+	{

+	  if (host_screen->ximg->data) 

+	    {

+	      free(host_screen->ximg->data);

+	      host_screen->ximg->data = NULL;

+	    } 

+

+	  XDestroyImage(host_screen->ximg);

+	}

+    }

+

+  if (HostX.have_shm)

+    {

+#ifdef _MSC_VER

+__asm int 3;

+#else

+      host_screen->ximg = XShmCreateImage (HostX.dpy, HostX.visual, HostX.depth,

+                                           ZPixmap, NULL, &host_screen->shminfo,

+                                           width, buffer_height );

+

+      host_screen->shminfo.shmid =

+                      shmget(IPC_PRIVATE,

+                             host_screen->ximg->bytes_per_line * buffer_height,

+                             IPC_CREAT|0777);

+      host_screen->ximg->data = shmat(host_screen->shminfo.shmid, 0, 0);

+      host_screen->shminfo.shmaddr = host_screen->ximg->data;

+

+      if (host_screen->ximg->data == (char *)-1)

+	{

+	  EPHYR_DBG("Can't attach SHM Segment, falling back to plain XImages");

+	  HostX.have_shm = False;

+	  XDestroyImage(host_screen->ximg);

+	  shmctl(host_screen->shminfo.shmid, IPC_RMID, 0);

+	}

+      else

+	{

+	  EPHYR_DBG("SHM segment attached %p", host_screen->shminfo.shmaddr);

+	  host_screen->shminfo.readOnly = False;

+	  XShmAttach(HostX.dpy, &host_screen->shminfo);

+	  shm_success = True;

+	}

+#endif

+    }

+

+  if (!shm_success)

+    {

+      bitmap_pad = ( HostX.depth > 16 )? 32 : (( HostX.depth > 8 )? 16 : 8 );

+

+      EPHYR_DBG("Creating image %dx%d for screen host_screen=%p\n",

+                width, buffer_height, host_screen );

+      host_screen->ximg = XCreateImage (HostX.dpy,

+                                        HostX.visual,

+                                        HostX.depth,

+                                        ZPixmap, 0, 0,

+                                        width,

+                                        buffer_height,

+                                        bitmap_pad,

+                                        0);

+

+      host_screen->ximg->data =

+              malloc (host_screen->ximg->bytes_per_line * buffer_height);

+    }

+

+  XResizeWindow (HostX.dpy, host_screen->win, width, height);

+

+  /* Ask the WM to keep our size static */

+  size_hints = XAllocSizeHints();

+  size_hints->max_width = size_hints->min_width = width;

+  size_hints->max_height = size_hints->min_height = height;

+  size_hints->flags = PMinSize|PMaxSize;

+  XSetWMNormalHints(HostX.dpy, host_screen->win, size_hints);

+  XFree(size_hints);

+

+  XMapWindow(HostX.dpy, host_screen->win);

+

+  XSync(HostX.dpy, False);

+

+  host_screen->win_width  = width;

+  host_screen->win_height = height;

+

+  if (host_depth_matches_server(host_screen))

+    {

+      EPHYR_DBG("Host matches server");

+      return host_screen->ximg->data;

+    }

+  else

+    {

+      EPHYR_DBG("server bpp %i", host_screen->server_depth>>3);

+      host_screen->fb_data = malloc(width*buffer_height*(host_screen->server_depth>>3));

+      return host_screen->fb_data;

+    }

+}

+

+static void hostx_paint_debug_rect (struct EphyrHostScreen *host_screen,

+                                    int x,     int y,

+                                    int width, int height);

+

+void

+hostx_paint_rect (EphyrScreenInfo screen,

+                  int sx,    int sy,

+                  int dx,    int dy,

+                  int width, int height)

+{

+  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);

+

+  EPHYR_DBG ("painting in screen %d\n", host_screen->mynum) ;

+

+  /*

+   *  Copy the image data updated by the shadow layer

+   *  on to the window

+   */

+

+  if (HostXWantDamageDebug)

+    {

+      hostx_paint_debug_rect(host_screen, dx, dy, width, height);

+    }

+

+  /* 

+   * If the depth of the ephyr server is less than that of the host,

+   * the kdrive fb does not point to the ximage data but to a buffer

+   * ( fb_data ), we shift the various bits from this onto the XImage

+   * so they match the host.

+   *

+   * Note, This code is pretty new ( and simple ) so may break on 

+   *       endian issues, 32 bpp host etc. 

+   *       Not sure if 8bpp case is right either. 

+   *       ... and it will be slower than the matching depth case.

+   */

+

+  if (!host_depth_matches_server(host_screen))

+    {

+      int            x,y,idx, bytes_per_pixel = (host_screen->server_depth>>3);

+      unsigned char  r,g,b;

+      unsigned long  host_pixel;

+

+      EPHYR_DBG("Unmatched host depth host_screen=%p\n", host_screen);

+      for (y=sy; y<sy+height; y++)

+	for (x=sx; x<sx+width; x++)

+	  {

+	    idx = (host_screen->win_width*y*bytes_per_pixel)+(x*bytes_per_pixel);

+

+	    switch (host_screen->server_depth)

+	      {

+	      case 16:

+		{

+		  unsigned short pixel = *(unsigned short*)(host_screen->fb_data+idx);

+

+		  r = ((pixel & 0xf800) >> 8);

+		  g = ((pixel & 0x07e0) >> 3);

+		  b = ((pixel & 0x001f) << 3);

+

+		  host_pixel = (r << 16) | (g << 8) | (b);

+		  

+		  XPutPixel(host_screen->ximg, x, y, host_pixel);

+		  break;

+		}

+	      case 8:

+		{

+		  unsigned char pixel = *(unsigned char*)(host_screen->fb_data+idx);

+		  XPutPixel(host_screen->ximg, x, y, HostX.cmap[pixel]);

+		  break;

+		}

+	      default:

+		break;

+	      }

+	  }

+    }

+

+  if (HostX.have_shm)

+    {

+#ifdef _MSC_VER

+      __asm int 3;

+#else

+      XShmPutImage (HostX.dpy, host_screen->win,

+                    HostX.gc, host_screen->ximg,

+                    sx, sy, dx, dy, width, height, False);

+#endif

+    }

+  else

+    {

+      XPutImage (HostX.dpy, host_screen->win, HostX.gc, host_screen->ximg, 

+                 sx, sy, dx, dy, width, height);

+    }

+

+  XSync (HostX.dpy, False);

+}

+

+static void

+hostx_paint_debug_rect (struct EphyrHostScreen *host_screen,

+                        int x,     int y,

+                        int width, int height)

+{

+#ifdef _MSC_VER

+  __asm int 3;

+#else

+  struct timespec tspec;

+

+  tspec.tv_sec  = HostX.damage_debug_msec / (1000000);

+  tspec.tv_nsec = (HostX.damage_debug_msec % 1000000) * 1000;

+

+  EPHYR_DBG("msec: %li tv_sec %li, tv_msec %li", 

+	    HostX.damage_debug_msec, tspec.tv_sec, tspec.tv_nsec);

+

+  /* fprintf(stderr, "Xephyr updating: %i+%i %ix%i\n", x, y, width, height); */

+

+  XFillRectangle (HostX.dpy, host_screen->win, HostX.gc, x, y, width,height);

+  XSync (HostX.dpy, False);

+

+  /* nanosleep seems to work better than usleep for me... */

+  nanosleep(&tspec, NULL);

+#endif

+}

+

+void

+hostx_load_keymap(void)

+{

+  XID             *keymap;

+  int              host_width, min_keycode, max_keycode, width;

+  int              i,j;

+

+  XDisplayKeycodes (HostX.dpy, &min_keycode, &max_keycode);

+

+  EPHYR_DBG ("min: %d, max: %d", min_keycode, max_keycode);

+

+  keymap = XGetKeyboardMapping (HostX.dpy,

+			        min_keycode,

+			        max_keycode - min_keycode + 1,

+			        &host_width);

+

+  /* Try and copy the hosts keymap into our keymap to avoid loads

+   * of messing around.

+   *

+   * kdrive cannot can have more than 4 keysyms per keycode

+   * so we only copy at most the first 4 ( xorg has 6 per keycode, XVNC 2 )

+   */

+  width = (host_width > 4) ? 4 : host_width;

+

+  ephyrKeySyms.map = (CARD32 *)calloc(sizeof(CARD32),

+                                      (max_keycode - min_keycode + 1) *

+                                      width);

+  if (!ephyrKeySyms.map)

+        return;

+

+  for (i=0; i<(max_keycode - min_keycode+1); i++)

+    for (j=0; j<width; j++)

+      ephyrKeySyms.map[(i*width)+j] = (CARD32) keymap[(i*host_width) + j];

+

+  EPHYR_DBG("keymap width, host:%d kdrive:%d", host_width, width);

+

+  ephyrKeySyms.minKeyCode  = min_keycode;

+  ephyrKeySyms.maxKeyCode  = max_keycode;

+  ephyrKeySyms.mapWidth    = width;

+

+  XFree(keymap);

+}

+

+static struct EphyrHostScreen *

+host_screen_from_window (Window w)

+{

+  int index = 0;

+  struct EphyrHostScreen *result  = NULL;

+

+  for (index = 0 ; index < HostX.n_screens ; index++)

+    {

+      if (HostX.screens[index].win == w || HostX.screens[index].peer_win == w)

+        {

+          result = &HostX.screens[index];

+          goto out;

+        }

+    }

+

+out:

+  return result;

+}

+

+int

+hostx_get_event(EphyrHostXEvent *ev)

+{

+  XEvent      xev;

+  static int  grabbed_screen = -1;

+

+  if (XPending(HostX.dpy))

+    {

+      XNextEvent(HostX.dpy, &xev);

+

+      switch (xev.type) 

+	{

+	case Expose:

+	  /* Not so great event compression, but works ok */

+	  while (XCheckTypedWindowEvent(HostX.dpy, xev.xexpose.window,

+					Expose, &xev));

+	  {

+	    struct EphyrHostScreen *host_screen =

+                host_screen_from_window (xev.xexpose.window);

+            if (host_screen)

+              {

+                hostx_paint_rect (host_screen->info, 0, 0, 0, 0,

+                                  host_screen->win_width,

+                                  host_screen->win_height);

+              }

+            else

+              {

+                EPHYR_LOG_ERROR ("failed to get host screen\n");

+                ev->type = EPHYR_EV_EXPOSE;

+                ev->data.expose.window = xev.xexpose.window;

+                return 1;

+              }

+	  }

+	  return 0;

+

+	case MotionNotify:

+	  {

+	    struct EphyrHostScreen *host_screen =

+                host_screen_from_window (xev.xmotion.window);

+

+	    ev->type = EPHYR_EV_MOUSE_MOTION;

+	    ev->data.mouse_motion.x = xev.xmotion.x;

+	    ev->data.mouse_motion.y = xev.xmotion.y;

+	    ev->data.mouse_motion.window = xev.xmotion.window;

+	    ev->data.mouse_motion.screen = (host_screen ? host_screen->mynum : -1);

+	  }

+	  return 1;

+

+	case ButtonPress:

+	  ev->type = EPHYR_EV_MOUSE_PRESS;

+	  ev->key_state = xev.xkey.state;

+	  /* 

+	   * This is a bit hacky. will break for button 5 ( defined as 0x10 )

+           * Check KD_BUTTON defines in kdrive.h 

+	   */

+	  ev->data.mouse_down.button_num = 1<<(xev.xbutton.button-1);

+	  return 1;

+

+	case ButtonRelease:

+	  ev->type = EPHYR_EV_MOUSE_RELEASE;

+	  ev->key_state = xev.xkey.state;

+	  ev->data.mouse_up.button_num = 1<<(xev.xbutton.button-1);

+	  return 1;

+

+	case KeyPress:

+	  {

+	    ev->type = EPHYR_EV_KEY_PRESS;

+	    ev->key_state = xev.xkey.state;

+	    ev->data.key_down.scancode = xev.xkey.keycode;  

+	    return 1;

+	  }

+	case KeyRelease:

+

+	  if ((XKeycodeToKeysym(HostX.dpy,xev.xkey.keycode,0) == XK_Shift_L

+	       || XKeycodeToKeysym(HostX.dpy,xev.xkey.keycode,0) == XK_Shift_R)

+	      && (xev.xkey.state & ControlMask))

+	    {

+	      struct EphyrHostScreen *host_screen =

+                  host_screen_from_window (xev.xexpose.window);

+

+	      if (grabbed_screen != -1)

+		{

+		  XUngrabKeyboard (HostX.dpy, CurrentTime);

+		  XUngrabPointer (HostX.dpy, CurrentTime);

+		  grabbed_screen = -1;

+		  hostx_set_win_title (host_screen->info,

+                                       "(ctrl+shift grabs mouse and keyboard)");

+		}

+	      else

+		{

+		  /* Attempt grab */

+		  if (XGrabKeyboard (HostX.dpy, host_screen->win, True, 

+				     GrabModeAsync, 

+				     GrabModeAsync, 

+				     CurrentTime) == 0)

+		    {

+		      if (XGrabPointer (HostX.dpy, host_screen->win, True, 

+					NoEventMask, 

+					GrabModeAsync, 

+					GrabModeAsync, 

+					host_screen->win, None, CurrentTime) == 0)

+			{

+			  grabbed_screen = host_screen->mynum;

+			  hostx_set_win_title

+                                  (host_screen->info,

+                                   "(ctrl+shift releases mouse and keyboard)");

+			}

+		      else 	/* Failed pointer grabm  ungrab keyboard */

+			XUngrabKeyboard (HostX.dpy, CurrentTime);

+		    }

+		}

+	    }

+

+	  /* Still send the release event even if above has happened

+           * server will get confused with just an up event. 

+           * Maybe it would be better to just block shift+ctrls getting to

+           * kdrive all togeather. 

+ 	   */

+	  ev->type = EPHYR_EV_KEY_RELEASE;

+	  ev->key_state = xev.xkey.state;

+	  ev->data.key_up.scancode = xev.xkey.keycode;

+	  return 1;

+

+	default:

+	  break;

+

+	}

+    }

+  return 0;

+}

+

+void*

+hostx_get_display(void)

+{

+    return HostX.dpy ;

+}

+

+int

+hostx_get_window (int a_screen_number)

+{

+    if (a_screen_number < 0 || a_screen_number >= HostX.n_screens) {

+        EPHYR_LOG_ERROR ("bad screen number:%d\n", a_screen_number) ;

+        return 0;

+    }

+    return HostX.screens[a_screen_number].win ;

+}

+

+int

+hostx_get_window_attributes (int a_window, EphyrHostWindowAttributes *a_attrs)

+{

+    XWindowAttributes attrs ;

+

+    memset (&attrs, 0, sizeof (attrs)) ;

+

+    if (!XGetWindowAttributes (hostx_get_display (),

+                               a_window,

+                               &attrs)) {

+        return FALSE ;

+    }

+    a_attrs->x = attrs.x ;

+    a_attrs->y = attrs.y ;

+    a_attrs->width = attrs.width ;

+    a_attrs->height = attrs.height ;

+    if (attrs.visual)

+        a_attrs->visualid = attrs.visual->visualid ;

+    return TRUE ;

+}

+

+int

+hostx_get_extension_info (const char *a_ext_name,

+                          int *a_major_opcode,

+                          int *a_first_event,

+                          int *a_first_error)

+{

+    if (!a_ext_name || !a_major_opcode || !a_first_event || !a_first_error)

+      return 0 ;

+   if (!XQueryExtension (HostX.dpy,

+                         a_ext_name,

+                         a_major_opcode,

+                         a_first_event,

+                         a_first_error))

+     {

+       return 0 ;

+     }

+   return 1 ;

+}

+

+int

+hostx_get_visuals_info (EphyrHostVisualInfo **a_visuals,

+                        int *a_num_entries)

+{

+    Display *dpy=hostx_get_display () ;

+    Bool is_ok=False ;

+    XVisualInfo templ, *visuals=NULL;

+    EphyrHostVisualInfo *host_visuals=NULL ;

+    int nb_items=0, i=0;

+

+    EPHYR_RETURN_VAL_IF_FAIL (a_visuals && a_num_entries && dpy,

+                              False) ;

+    EPHYR_LOG ("enter\n") ;

+    memset (&templ, 0, sizeof (templ)) ;

+    visuals = XGetVisualInfo (dpy, VisualNoMask, &templ, &nb_items) ;

+    if (!visuals) {

+        EPHYR_LOG_ERROR ("host does not advertise any visual\n") ;

+        goto out ;

+    }

+    EPHYR_LOG ("host advertises %d visuals\n", nb_items) ;

+    host_visuals = calloc (nb_items, sizeof (EphyrHostVisualInfo)) ;

+    for (i=0; i<nb_items; i++) {

+        host_visuals[i].visualid = visuals[i].visualid ;

+        host_visuals[i].screen = visuals[i].screen ;

+        host_visuals[i].depth = visuals[i].depth ;

+        host_visuals[i].class = visuals[i].class ;

+        host_visuals[i].red_mask = visuals[i].red_mask ;

+        host_visuals[i].green_mask = visuals[i].green_mask ;

+        host_visuals[i].blue_mask = visuals[i].blue_mask ;

+        host_visuals[i].colormap_size = visuals[i].colormap_size ;

+        host_visuals[i].bits_per_rgb = visuals[i].bits_per_rgb ;

+    }

+    *a_visuals = host_visuals ;

+    *a_num_entries = nb_items;

+    host_visuals=NULL;

+

+    is_ok = TRUE;

+out:

+    if (visuals) {

+        XFree (visuals) ;

+        visuals = NULL;

+    }

+    if (host_visuals) {

+        free (host_visuals) ;

+        host_visuals = NULL;

+    }

+    EPHYR_LOG ("leave\n") ;

+    return is_ok ;

+

+}

+

+int

+hostx_create_window (int a_screen_number,

+                     EphyrBox *a_geometry,

+                     int a_visual_id,

+                     int *a_host_peer /*out parameter*/)

+{

+    Bool is_ok=FALSE ;

+    Display *dpy=hostx_get_display () ;

+    XVisualInfo *visual_info=NULL, visual_info_templ;

+    int visual_mask=VisualIDMask ;

+    Window win=None ;

+    int nb_visuals=0, winmask=0;

+    XSetWindowAttributes attrs;

+

+    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geometry, FALSE) ;

+

+    EPHYR_LOG ("enter\n") ;

+

+     /*get visual*/

+    memset (&visual_info, 0, sizeof (visual_info)) ;

+    visual_info_templ.visualid = a_visual_id ;

+    visual_info = XGetVisualInfo (dpy, visual_mask,

+                                  &visual_info_templ,

+                                  &nb_visuals) ;

+    if (!visual_info) {

+        EPHYR_LOG_ERROR ("argh, could not find a remote visual with id:%d\n",

+                         a_visual_id) ;

+        goto out ;

+    }

+    memset (&attrs, 0, sizeof (attrs)) ;

+    attrs.colormap = XCreateColormap (dpy,

+                                      RootWindow (dpy,

+                                                  visual_info->screen),

+                                      visual_info->visual,

+                                      AllocNone) ;

+    attrs.event_mask = ButtonPressMask

+                       |ButtonReleaseMask

+                       |PointerMotionMask

+                       |KeyPressMask

+                       |KeyReleaseMask

+                       |ExposureMask;

+    winmask = CWColormap|CWEventMask;

+

+    win = XCreateWindow (dpy, hostx_get_window (a_screen_number),

+                         a_geometry->x, a_geometry->y,

+                         a_geometry->width, a_geometry->height, 0,

+                         visual_info->depth, CopyFromParent,

+                         visual_info->visual, winmask, &attrs) ;

+    if (win == None) {

+        EPHYR_LOG_ERROR ("failed to create peer window\n") ;

+        goto out ;

+    }

+    if (HostX.screens[a_screen_number].peer_win == None) {

+	HostX.screens[a_screen_number].peer_win = win;

+    } else {

+        EPHYR_LOG_ERROR ("multiple peer windows created for same screen\n") ;

+    }

+    XFlush (dpy) ;

+    XMapWindow (dpy, win) ;

+    *a_host_peer = win ;

+    is_ok = TRUE ;

+out:

+    EPHYR_LOG ("leave\n") ;

+    return is_ok ;

+}

+

+int

+hostx_destroy_window (int a_win)

+{

+    Display *dpy=hostx_get_display () ;

+

+    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;

+    XDestroyWindow (dpy, a_win) ;

+    XFlush (dpy) ;

+    return TRUE ;

+}

+

+int

+hostx_set_window_geometry (int a_win, EphyrBox *a_geo)

+{

+    Display *dpy=hostx_get_display ();

+

+    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geo, FALSE) ;

+

+    EPHYR_LOG ("enter. x,y,w,h:(%d,%d,%d,%d)\n",

+               a_geo->x, a_geo->y,

+               a_geo->width, a_geo->height) ;

+

+    XMoveWindow (dpy, a_win, a_geo->x, a_geo->y) ;

+    XResizeWindow (dpy, a_win, a_geo->width, a_geo->height) ;

+    EPHYR_LOG ("leave\n") ;

+    return TRUE;

+}

+

+int

+hostx_set_window_bounding_rectangles (int a_window,

+                                      EphyrRect *a_rects,

+                                      int a_num_rects)

+{

+    Bool is_ok=FALSE;

+    Display *dpy=hostx_get_display () ;

+    int i=0 ;

+    XRectangle *rects=NULL ;

+

+    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ;

+

+    EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ;

+

+    rects = calloc (a_num_rects, sizeof (XRectangle)) ;

+    for (i=0; i<a_num_rects; i++) {

+        rects[i].x = a_rects[i].x1 ;

+        rects[i].y = a_rects[i].y1 ;

+        rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1);

+        rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ;

+        EPHYR_LOG ("borders clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",

+                   rects[i].x, rects[i].y,

+                   rects[i].width, rects[i].height) ;

+    }

+    /*this aways returns 1*/

+#ifdef _MSC_VER

+    __asm int 3;

+#else

+    XShapeCombineRectangles (dpy, a_window, ShapeBounding, 0, 0,

+                             rects, a_num_rects, ShapeSet, YXBanded) ;

+#endif

+    is_ok = TRUE ;

+

+    if (rects) {

+        free (rects) ;

+        rects = NULL ;

+    }

+    EPHYR_LOG ("leave\n") ;

+    return is_ok;

+}

+

+int

+hostx_set_window_clipping_rectangles (int a_window,

+                                      EphyrRect *a_rects,

+                                      int a_num_rects)

+{

+    Bool is_ok=FALSE;

+    Display *dpy=hostx_get_display () ;

+    int i=0 ;

+    XRectangle *rects=NULL ;

+

+    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ;

+

+    EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ;

+

+    rects = calloc (a_num_rects, sizeof (XRectangle)) ;

+    for (i=0; i<a_num_rects; i++) {

+        rects[i].x = a_rects[i].x1 ;

+        rects[i].y = a_rects[i].y1 ;

+        rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1);

+        rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ;

+        EPHYR_LOG ("clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",

+                   rects[i].x, rects[i].y,

+                   rects[i].width, rects[i].height) ;

+    }

+    /*this aways returns 1*/

+#ifdef _MSC_VER

+    __asm int 3;

+#else

+    XShapeCombineRectangles (dpy, a_window, ShapeClip, 0, 0,

+                             rects, a_num_rects, ShapeSet, YXBanded) ;

+#endif

+    is_ok = TRUE ;

+

+    if (rects) {

+        free (rects) ;

+        rects = NULL ;

+    }

+    EPHYR_LOG ("leave\n") ;

+    return is_ok;

+}

+

+int

+hostx_has_xshape (void)

+{

+    int event_base=0, error_base=0 ;

+#ifdef _MSC_VER

+    __asm int 3;

+#else

+    Display *dpy=hostx_get_display () ;

+    if (!XShapeQueryExtension (dpy,

+                               &event_base,

+                               &error_base)) {

+        return FALSE ;

+    }

+#endif

+    return TRUE;

+}

+

+#ifdef XF86DRI

+typedef struct {

+    int is_valid ;

+    int local_id ;

+    int remote_id ;

+} ResourcePair ;

+

+#define RESOURCE_PEERS_SIZE 1024*10

+static ResourcePair resource_peers[RESOURCE_PEERS_SIZE] ;

+

+

+int

+hostx_allocate_resource_id_peer (int a_local_resource_id,

+                                 int *a_remote_resource_id)

+{

+    int i=0 ;

+    ResourcePair *peer=NULL ;

+    Display *dpy=hostx_get_display ();

+

+    /*

+     * first make sure a resource peer

+     * does not exist already for

+     * a_local_resource_id

+     */

+    for (i=0; i<RESOURCE_PEERS_SIZE; i++) {

+        if (resource_peers[i].is_valid

+            && resource_peers[i].local_id == a_local_resource_id) {

+            peer = &resource_peers[i] ;

+            break ;

+        }

+    }

+    /*

+     * find one free peer entry, an feed it with

+     */

+    if (!peer) {

+        for (i=0; i<RESOURCE_PEERS_SIZE; i++) {

+            if (!resource_peers[i].is_valid) {

+                peer = &resource_peers[i] ;

+                break ;

+            }

+        }

+        if (peer) {

+            peer->remote_id = XAllocID (dpy);

+            peer->local_id = a_local_resource_id ;

+            peer->is_valid = TRUE ;

+        }

+    }

+    if (peer) {

+        *a_remote_resource_id = peer->remote_id ;

+        return TRUE ;

+    }

+    return FALSE ;

+}

+

+int

+hostx_get_resource_id_peer (int a_local_resource_id,

+                            int *a_remote_resource_id)

+{

+    int i=0 ;

+    ResourcePair *peer=NULL ;

+    for (i=0; i<RESOURCE_PEERS_SIZE; i++) {

+        if (resource_peers[i].is_valid

+            && resource_peers[i].local_id == a_local_resource_id) {

+            peer = &resource_peers[i] ;

+            break ;

+        }

+    }

+    if (peer) {

+        *a_remote_resource_id = peer->remote_id ;

+        return TRUE ;

+    }

+    return FALSE ;

+}

+

+int

+hostx_has_dri (void)

+{

+    int event_base=0, error_base=0 ;

+    Display *dpy=hostx_get_display () ;

+

+    if (!dpy)

+        return FALSE ;

+

+    if (!XF86DRIQueryExtension (dpy,

+                                &event_base,

+                                &error_base)) {

+        return FALSE ;

+    }

+    return TRUE ;

+}

+

+int

+hostx_has_glx (void)

+{

+    Display *dpy=hostx_get_display () ;

+    int event_base=0, error_base=0 ;

+

+    if (!glXQueryExtension (dpy, &event_base, &error_base)) {

+        return FALSE ;

+    }

+    return TRUE ;

+}

+

+#endif /* XF86DRI */

diff --git a/xorg-server/hw/kdrive/fake/fake.c b/xorg-server/hw/kdrive/fake/fake.c
index 9f2327d94..626b2d25a 100644
--- a/xorg-server/hw/kdrive/fake/fake.c
+++ b/xorg-server/hw/kdrive/fake/fake.c
@@ -168,8 +168,7 @@ fakeMapFramebuffer (KdScreenInfo *screen)
     KdSetPointerMatrix (&m);

     

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

-    if (priv->base)

-	free (priv->base);

+    free(priv->base);

     priv->base = malloc (priv->bytes_per_line * screen->height);

     

     if (scrpriv->shadow)

diff --git a/xorg-server/hw/kdrive/src/kdrive.c b/xorg-server/hw/kdrive/src/kdrive.c
index a7db41379..79b13520d 100644
--- a/xorg-server/hw/kdrive/src/kdrive.c
+++ b/xorg-server/hw/kdrive/src/kdrive.c
@@ -64,8 +64,7 @@ KdDepths    kdDepths[] = {
 

 #define KD_DEFAULT_BUTTONS 5

 

-static int          kdScreenPrivateKeyIndex;

-DevPrivateKey       kdScreenPrivateKey = &kdScreenPrivateKeyIndex;

+DevPrivateKeyRec    kdScreenPrivateKeyRec;

 unsigned long	    kdGeneration;

 

 Bool                kdVideoTest;

@@ -95,7 +94,7 @@ KdOsFuncs	*kdOsFuncs;
 void

 KdSetRootClip (ScreenPtr pScreen, BOOL enable)

 {

-    WindowPtr	pWin = WindowTable[pScreen->myNum];

+    WindowPtr	pWin = pScreen->root;

     WindowPtr	pChild;

     Bool	WasViewable;

     Bool	anyMarked = FALSE;

@@ -121,8 +120,8 @@ KdSetRootClip (ScreenPtr pScreen, BOOL enable)
 	    {

 		RegionPtr	borderVisible;

 

-		borderVisible = REGION_CREATE(pScreen, NullBox, 1);

-		REGION_SUBTRACT(pScreen, borderVisible,

+		borderVisible = RegionCreate(NullBox, 1);

+		RegionSubtract(borderVisible,

 				&pWin->borderClip, &pWin->winSize);

 		pWin->valdata->before.borderVisible = borderVisible;

 	    }

@@ -138,15 +137,15 @@ KdSetRootClip (ScreenPtr pScreen, BOOL enable)
 	box.y2 = pScreen->height;

 	pWin->drawable.width = pScreen->width;

 	pWin->drawable.height = pScreen->height;

-	REGION_INIT (pScreen, &pWin->winSize, &box, 1);

-	REGION_INIT (pScreen, &pWin->borderSize, &box, 1);

-	REGION_RESET(pScreen, &pWin->borderClip, &box);

-	REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList);

+	RegionInit(&pWin->winSize, &box, 1);

+	RegionInit(&pWin->borderSize, &box, 1);

+	RegionReset(&pWin->borderClip, &box);

+	RegionBreak(&pWin->clipList);

     }

     else

     {

-	REGION_EMPTY(pScreen, &pWin->borderClip);

-	REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList);

+	RegionEmpty(&pWin->borderClip);

+	RegionBreak(&pWin->clipList);

     }

 

     ResizeChildrenWinSize (pWin, 0, 0, 0, 0);

@@ -701,6 +700,9 @@ KdAllocatePrivates (ScreenPtr pScreen)
     if (kdGeneration != serverGeneration)

 	kdGeneration = serverGeneration;

 

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

+	return FALSE;

+

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

     if (!pScreenPriv)

 	return FALSE;

@@ -838,8 +840,8 @@ KdCreateWindow (WindowPtr pWin)
 

 	if (!pScreenPriv->enabled)

 	{

-	    REGION_EMPTY (pWin->drawable.pScreen, &pWin->borderClip);

-	    REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList);

+	    RegionEmpty(&pWin->borderClip);

+	    RegionBreak(&pWin->clipList);

 	}

     }

 #endif

@@ -943,9 +945,8 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
     pScreenPriv->card = card;

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

     pScreenPriv->dpmsState = KD_DPMS_NORMAL;

-#ifdef PANORAMIX

-    dixScreenOrigins[pScreen->myNum] = screen->origin;

-#endif

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

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

 

     if (!monitorResolution)

 	monitorResolution = 75;

diff --git a/xorg-server/hw/kdrive/src/kdrive.h b/xorg-server/hw/kdrive/src/kdrive.h
index 35ce03660..8873662ee 100644
--- a/xorg-server/hw/kdrive/src/kdrive.h
+++ b/xorg-server/hw/kdrive/src/kdrive.h
@@ -1,626 +1,628 @@
-/*
- * 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
-
-#define Status int
-
-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 DevPrivateKey	kdScreenPrivateKey;
-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
-KdSetRootClip (ScreenPtr pScreen, BOOL enable);
-
-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
-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

+

+#define Status int

+

+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

+KdSetRootClip (ScreenPtr pScreen, BOOL enable);

+

+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

+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/kxv.c b/xorg-server/hw/kdrive/src/kxv.c
index 9fef34d1f..cf960e62b 100644
--- a/xorg-server/hw/kdrive/src/kxv.c
+++ b/xorg-server/hw/kdrive/src/kxv.c
@@ -103,10 +103,9 @@ static void KdXVClipNotify(WindowPtr pWin, int dx, int dy);
 /* misc */

 static Bool KdXVInitAdaptors(ScreenPtr, KdVideoAdaptorPtr*, int);

 

-static int KdXVWindowKeyIndex;

-DevPrivateKey KdXVWindowKey = &KdXVWindowKeyIndex;

-static int KdXvScreenKeyIndex;

-DevPrivateKey KdXvScreenKey = &KdXvScreenKeyIndex;

+static DevPrivateKeyRec KdXVWindowKeyRec;

+#define KdXVWindowKey (&KdXVWindowKeyRec)

+static DevPrivateKey KdXvScreenKey;

 static unsigned long KdXVGeneration = 0;

 static unsigned long PortResource = 0;

 

@@ -199,6 +198,9 @@ KdXVScreenInit(
   if(!XvGetScreenKeyProc || !XvGetRTPortProc || !XvScreenInitProc)

 	return FALSE;

 

+  if (!dixRegisterPrivateKey(&KdXVWindowKeyRec, PRIVATE_WINDOW, 0))

+      return FALSE;

+

   if(Success != (*XvScreenInitProc)(pScreen)) return FALSE;

 

   KdXvScreenKey = (*XvGetScreenKeyProc)();

@@ -268,9 +270,9 @@ KdXVFreeAdaptor(XvAdaptorPtr pAdaptor)
           pPriv = (XvPortRecPrivatePtr)pPort->devPriv.ptr;

 	  if(pPriv) {

 	     if(pPriv->clientClip)

-		REGION_DESTROY(pAdaptor->pScreen, pPriv->clientClip);

+		RegionDestroy(pPriv->clientClip);

              if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-		REGION_DESTROY(pAdaptor->pScreen, pPriv->pCompositeClip);

+		RegionDestroy(pPriv->pCompositeClip);

 	     free(pPriv);

 	  }

       }

@@ -607,18 +609,18 @@ KdXVUpdateCompositeClip(XvPortRecPrivatePtr portPriv)
 	return;

    }

 

-   pCompositeClip = REGION_CREATE(pWin->pScreen, NullBox, 1);

-   REGION_COPY(pWin->pScreen, pCompositeClip, portPriv->clientClip);

-   REGION_TRANSLATE(pWin->pScreen, pCompositeClip,

+   pCompositeClip = RegionCreate(NullBox, 1);

+   RegionCopy(pCompositeClip, portPriv->clientClip);

+   RegionTranslate(pCompositeClip,

 			portPriv->pDraw->x + portPriv->clipOrg.x,

 			portPriv->pDraw->y + portPriv->clipOrg.y);

-   REGION_INTERSECT(pWin->pScreen, pCompositeClip, pregWin, pCompositeClip);

+   RegionIntersect(pCompositeClip, pregWin, pCompositeClip);

 

    portPriv->pCompositeClip = pCompositeClip;

    portPriv->FreeCompositeClip = TRUE;

 

    if(freeCompClip) {

-   	REGION_DESTROY(pWin->pScreen, pregWin);

+	RegionDestroy(pregWin);

    }

 }

 

@@ -633,17 +635,17 @@ KdXVCopyClip(
     /* copy the new clip if it exists */

     if((pGC->clientClipType == CT_REGION) && pGC->clientClip) {

 	if(!portPriv->clientClip)

-	    portPriv->clientClip = REGION_CREATE(pGC->pScreen, NullBox, 1);

+	    portPriv->clientClip = RegionCreate(NullBox, 1);

 	/* Note: this is in window coordinates */

-	REGION_COPY(pGC->pScreen, portPriv->clientClip, pGC->clientClip);

+	RegionCopy(portPriv->clientClip, pGC->clientClip);

     } else if(portPriv->clientClip) { /* free the old clientClip */

-	REGION_DESTROY(pGC->pScreen, portPriv->clientClip);

+	RegionDestroy(portPriv->clientClip);

 	portPriv->clientClip = NULL;

     }

 

     /* get rid of the old clip list */

     if(portPriv->pCompositeClip && portPriv->FreeCompositeClip) {

-	REGION_DESTROY(pWin->pScreen, portPriv->pCompositeClip);

+	RegionDestroy(portPriv->pCompositeClip);

     }

 

     portPriv->clipOrg = pGC->clipOrg;

@@ -670,18 +672,18 @@ KdXVRegetVideo(XvPortRecPrivatePtr portPriv)
   WinBox.y2 = WinBox.y1 + portPriv->drw_h;

 

   /* clip to the window composite clip */

-  REGION_INIT(portPriv->pDraw->pScreen, &WinRegion, &WinBox, 1);

-  REGION_INIT(portPriv->pDraw->pScreen, &ClipRegion, NullBox, 1);

-  REGION_INTERSECT(portPriv->pDraw->pScreen, &ClipRegion, &WinRegion, portPriv->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionInit(&ClipRegion, NullBox, 1);

+  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);

 

   /* that's all if it's totally obscured */

-  if(!REGION_NOTEMPTY(portPriv->pDraw->pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

 	clippedAway = TRUE;

 	goto CLIP_VIDEO_BAILOUT;

   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(portPriv->pDraw->pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->GetVideo)(portPriv->screen, portPriv->pDraw,

@@ -706,8 +708,8 @@ CLIP_VIDEO_BAILOUT:
   if(!portPriv->FreeCompositeClip)

      portPriv->pCompositeClip = NULL;

 

-  REGION_UNINIT(portPriv->pDraw->pScreen, &WinRegion);

-  REGION_UNINIT(portPriv->pDraw->pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -734,9 +736,9 @@ KdXVReputVideo(XvPortRecPrivatePtr portPriv)
   WinBox.y2 = WinBox.y1 + portPriv->drw_h;

 

   /* clip to the window composite clip */

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_INIT(pScreen, &ClipRegion, NullBox, 1);

-  REGION_INTERSECT(Screen, &ClipRegion, &WinRegion, portPriv->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionInit(&ClipRegion, NullBox, 1);

+  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);

 

   /* clip and translate to the viewport */

   if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

@@ -748,21 +750,21 @@ KdXVReputVideo(XvPortRecPrivatePtr portPriv)
      VPBox.x2 = screen->width;

      VPBox.y2 = screen->height;

 

-     REGION_INIT(pScreen, &VPReg, &VPBox, 1);

-     REGION_INTERSECT(Screen, &ClipRegion, &ClipRegion, &VPReg);

-     REGION_UNINIT(pScreen, &VPReg);

+     RegionInit(&VPReg, &VPBox, 1);

+     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

+     RegionUninit(&VPReg);

   }

 

   /* that's all if it's totally obscured */

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

 	clippedAway = TRUE;

 	goto CLIP_VIDEO_BAILOUT;

   }

 

   /* bailout if we have to clip but the hardware doesn't support it */

   if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = REGION_RECTS(&ClipRegion);

-     if(  (REGION_NUM_RECTS(&ClipRegion) != 1) ||

+     BoxPtr clipBox = RegionRects(&ClipRegion);

+     if(  (RegionNumRects(&ClipRegion) != 1) ||

 	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

 	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

      {

@@ -772,7 +774,7 @@ KdXVReputVideo(XvPortRecPrivatePtr portPriv)
   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->PutVideo)(portPriv->screen, portPriv->pDraw,

@@ -796,8 +798,8 @@ CLIP_VIDEO_BAILOUT:
   if(!portPriv->FreeCompositeClip)

      portPriv->pCompositeClip = NULL;

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -823,9 +825,9 @@ KdXVReputImage(XvPortRecPrivatePtr portPriv)
   WinBox.y2 = WinBox.y1 + portPriv->drw_h;

 

   /* clip to the window composite clip */

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_INIT(pScreen, &ClipRegion, NullBox, 1);

-  REGION_INTERSECT(Screen, &ClipRegion, &WinRegion, portPriv->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionInit(&ClipRegion, NullBox, 1);

+  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);

 

   /* clip and translate to the viewport */

   if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

@@ -837,21 +839,21 @@ KdXVReputImage(XvPortRecPrivatePtr portPriv)
      VPBox.x2 = screen->width;

      VPBox.y2 = screen->height;

 

-     REGION_INIT(pScreen, &VPReg, &VPBox, 1);

-     REGION_INTERSECT(Screen, &ClipRegion, &ClipRegion, &VPReg);

-     REGION_UNINIT(pScreen, &VPReg);

+     RegionInit(&VPReg, &VPBox, 1);

+     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

+     RegionUninit(&VPReg);

   }

 

   /* that's all if it's totally obscured */

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

 	clippedAway = TRUE;

 	goto CLIP_VIDEO_BAILOUT;

   }

 

   /* bailout if we have to clip but the hardware doesn't support it */

   if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = REGION_RECTS(&ClipRegion);

-     if(  (REGION_NUM_RECTS(&ClipRegion) != 1) ||

+     BoxPtr clipBox = RegionRects(&ClipRegion);

+     if(  (RegionNumRects(&ClipRegion) != 1) ||

 	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

 	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

      {

@@ -861,7 +863,7 @@ KdXVReputImage(XvPortRecPrivatePtr portPriv)
   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->ReputImage)(portPriv->screen, portPriv->pDraw,

@@ -882,8 +884,8 @@ CLIP_VIDEO_BAILOUT:
   if(!portPriv->FreeCompositeClip)

      portPriv->pCompositeClip = NULL;

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -1021,7 +1023,7 @@ KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
   XvPortRecPrivatePtr pPriv;

   Bool AreasExposed;

 

-  AreasExposed = (WinPriv && reg1 && REGION_NOTEMPTY(pScreen, reg1));

+  AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));

 

   pScreen->WindowExposures = ScreenPriv->WindowExposures;

   (*pScreen->WindowExposures)(pWin, reg1, reg2);

@@ -1089,7 +1091,7 @@ KdXVClipNotify(WindowPtr pWin, int dx, int dy)
      pPriv = WinPriv->PortRec;

 

      if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-	REGION_DESTROY(pScreen, pPriv->pCompositeClip);

+	RegionDestroy(pPriv->pCompositeClip);

 

      pPriv->pCompositeClip = NULL;

 

@@ -1171,7 +1173,7 @@ KdXVQueryAdaptors(
   *p_nAdaptors = pxvs->nAdaptors;

   *p_pAdaptors = pxvs->pAdaptors;

 

-  return (Success);

+  return Success;

 }

 

 static Bool

@@ -1220,7 +1222,7 @@ KdXVDisable(ScreenPtr pScreen)
 		pPriv->isOn = XV_OFF;

 

 		if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-		    REGION_DESTROY(pScreen, pPriv->pCompositeClip);

+		    RegionDestroy(pPriv->pCompositeClip);

 

 		pPriv->pCompositeClip = NULL;

 

@@ -1330,9 +1332,9 @@ KdXVPutStill(
   WinBox.x2 = WinBox.x1 + drw_w;

   WinBox.y2 = WinBox.y1 + drw_h;

 

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_INIT(pScreen, &ClipRegion, NullBox, 1);

-  REGION_INTERSECT(pScreen, &ClipRegion, &WinRegion, pGC->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionInit(&ClipRegion, NullBox, 1);

+  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);

 

   if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

      RegionRec VPReg;

@@ -1343,23 +1345,23 @@ KdXVPutStill(
      VPBox.x2 = screen->width;

      VPBox.y2 = screen->height;

 

-     REGION_INIT(pScreen, &VPReg, &VPBox, 1);

-     REGION_INTERSECT(Screen, &ClipRegion, &ClipRegion, &VPReg);

-     REGION_UNINIT(pScreen, &VPReg);

+     RegionInit(&VPReg, &VPBox, 1);

+     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

+     RegionUninit(&VPReg);

   }

 

   if(portPriv->pDraw) {

      KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

   }

 

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

      clippedAway = TRUE;

      goto PUT_STILL_BAILOUT;

   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = REGION_RECTS(&ClipRegion);

-     if(  (REGION_NUM_RECTS(&ClipRegion) != 1) ||

+     BoxPtr clipBox = RegionRects(&ClipRegion);

+     if(  (RegionNumRects(&ClipRegion) != 1) ||

 	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

 	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

      {

@@ -1369,7 +1371,7 @@ KdXVPutStill(
   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->PutStill)(portPriv->screen, pDraw,

@@ -1398,8 +1400,8 @@ PUT_STILL_BAILOUT:
         portPriv->isOn = XV_PENDING;

   }

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -1483,21 +1485,21 @@ KdXVGetStill(
   WinBox.x2 = WinBox.x1 + drw_w;

   WinBox.y2 = WinBox.y1 + drw_h;

 

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_INIT(pScreen, &ClipRegion, NullBox, 1);

-  REGION_INTERSECT(pScreen, &ClipRegion, &WinRegion, pGC->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionInit(&ClipRegion, NullBox, 1);

+  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);

 

   if(portPriv->pDraw) {

      KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

   }

 

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

      clippedAway = TRUE;

      goto GET_STILL_BAILOUT;

   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->GetStill)(portPriv->screen, pDraw,

@@ -1513,8 +1515,8 @@ GET_STILL_BAILOUT:
         portPriv->isOn = XV_PENDING;

   }

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -1630,9 +1632,9 @@ KdXVPutImage(
   WinBox.x2 = WinBox.x1 + drw_w;

   WinBox.y2 = WinBox.y1 + drw_h;

 

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_INIT(pScreen, &ClipRegion, NullBox, 1);

-  REGION_INTERSECT(pScreen, &ClipRegion, &WinRegion, pGC->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionInit(&ClipRegion, NullBox, 1);

+  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);

 

   if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

      RegionRec VPReg;

@@ -1643,23 +1645,23 @@ KdXVPutImage(
      VPBox.x2 = pScreen->width;

      VPBox.y2 = pScreen->height;

 

-     REGION_INIT(pScreen, &VPReg, &VPBox, 1);

-     REGION_INTERSECT(Screen, &ClipRegion, &ClipRegion, &VPReg);

-     REGION_UNINIT(pScreen, &VPReg);

+     RegionInit(&VPReg, &VPBox, 1);

+     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

+     RegionUninit(&VPReg);

   }

 

   if(portPriv->pDraw) {

      KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

   }

 

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

      clippedAway = TRUE;

      goto PUT_IMAGE_BAILOUT;

   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = REGION_RECTS(&ClipRegion);

-     if(  (REGION_NUM_RECTS(&ClipRegion) != 1) ||

+     BoxPtr clipBox = RegionRects(&ClipRegion);

+     if(  (RegionNumRects(&ClipRegion) != 1) ||

 	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

 	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

      {

@@ -1669,7 +1671,7 @@ KdXVPutImage(
   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->PutImage)(portPriv->screen, pDraw,

@@ -1698,8 +1700,8 @@ PUT_IMAGE_BAILOUT:
         portPriv->isOn = XV_PENDING;

   }

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -1869,8 +1871,8 @@ KXVPaintRegion (DrawablePtr pDraw, RegionPtr pRgn, Pixel fg)
     GCPtr	pGC;

     ChangeGCVal	val[2];

     xRectangle	*rects, *r;

-    BoxPtr	pBox = REGION_RECTS (pRgn);

-    int		nBox = REGION_NUM_RECTS (pRgn);

+    BoxPtr	pBox = RegionRects (pRgn);

+    int		nBox = RegionNumRects (pRgn);

 

     rects = malloc(nBox * sizeof (xRectangle));

     if (!rects)

@@ -1897,7 +1899,7 @@ KXVPaintRegion (DrawablePtr pDraw, RegionPtr pRgn, Pixel fg)
     ValidateGC (pDraw, pGC);

 

     (*pGC->ops->PolyFillRect) (pDraw, pGC,

-			       REGION_NUM_RECTS (pRgn), rects);

+			       RegionNumRects (pRgn), rects);

 

     FreeScratchGC (pGC);

 bail1:

diff --git a/xorg-server/hw/vfb/InitOutput.c b/xorg-server/hw/vfb/InitOutput.c
index 30e68e5d3..0172f4fbf 100644
--- a/xorg-server/hw/vfb/InitOutput.c
+++ b/xorg-server/hw/vfb/InitOutput.c
@@ -389,8 +389,8 @@ ddxProcessArgument(int argc, char *argv[], int i)
     return 0;

 }

 

-static int cmapScrPrivateKeyIndex;

-static DevPrivateKey cmapScrPrivateKey = &cmapScrPrivateKeyIndex;

+static DevPrivateKeyRec cmapScrPrivateKeyRec;

+#define cmapScrPrivateKey (&cmapScrPrivateKeyRec)

 

 #define GetInstalledColormap(s) ((ColormapPtr) dixLookupPrivate(&(s)->devPrivates, cmapScrPrivateKey))

 #define SetInstalledColormap(s,c) (dixSetPrivate(&(s)->devPrivates, cmapScrPrivateKey, c))

@@ -401,7 +401,7 @@ vfbListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps)
     /* By the time we are processing requests, we can guarantee that there

      * is always a colormap installed */

     *pmaps = GetInstalledColormap(pScreen)->mid;

-    return (1);

+    return 1;

 }

 

 

@@ -570,7 +570,7 @@ vfbAllocateMmappedFramebuffer(vfbScreenInfoPtr pvfb)
 

     /* Extend the file to be the proper size */

 

-    bzero(dummyBuffer, DUMMY_BUFFER_SIZE);

+    memset(dummyBuffer, 0, DUMMY_BUFFER_SIZE);

     for (currentFileSize = 0;

 	 currentFileSize < pvfb->sizeInBytes;

 	 currentFileSize += writeThisTime)

@@ -811,6 +811,9 @@ vfbScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
     int ret;

     char *pbits;

     

+    if (!dixRegisterPrivateKey(&cmapScrPrivateKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+

     if (dpix == 0)

       dpix = 100;

 

diff --git a/xorg-server/hw/xfree86/common/xf86.h b/xorg-server/hw/xfree86/common/xf86.h
index b7a884b2a..b21bcdf47 100644
--- a/xorg-server/hw/xfree86/common/xf86.h
+++ b/xorg-server/hw/xfree86/common/xf86.h
@@ -55,9 +55,16 @@
 extern _X_EXPORT int xf86DoConfigure;

 extern _X_EXPORT int xf86DoShowOptions;

 extern _X_EXPORT Bool xf86DoConfigurePass1;

-extern _X_EXPORT DevPrivateKey xf86ScreenKey;

-extern _X_EXPORT DevPrivateKey xf86CreateRootWindowKey;

-extern _X_EXPORT DevPrivateKey xf86PixmapKey;

+

+extern _X_EXPORT DevPrivateKeyRec xf86ScreenKeyRec;

+#define xf86ScreenKey (&xf86ScreenKeyRec)

+

+extern _X_EXPORT DevPrivateKeyRec xf86CreateRootWindowKeyRec;

+#define xf86CreateRootWindowKey (&xf86CreateRootWindowKeyRec)

+

+extern _X_EXPORT DevPrivateKeyRec xf86PixmapKeyRec;

+#define xf86PixmapKey (&xf86PixmapKeyRec)

+

 extern _X_EXPORT ScrnInfoPtr *xf86Screens;	/* List of pointers to ScrnInfoRecs */

 extern _X_EXPORT const unsigned char byte_reversed[256];

 extern _X_EXPORT Bool fbSlotClaimed;

diff --git a/xorg-server/hw/xfree86/common/xf86AutoConfig.c b/xorg-server/hw/xfree86/common/xf86AutoConfig.c
index 9f6348681..a00340191 100644
--- a/xorg-server/hw/xfree86/common/xf86AutoConfig.c
+++ b/xorg-server/hw/xfree86/common/xf86AutoConfig.c
@@ -120,8 +120,7 @@ FreeList(const char ***list, int *lines)
     int i;

 

     for (i = 0; i < *lines; i++) {

-	if ((*list)[i])

-	    free((*list)[i]);

+	free((*list)[i]);

     }

     free(*list);

     *list = NULL;

@@ -186,7 +185,7 @@ xf86AutoConfig(void)
     if (ret != CONFIG_OK)

 	xf86Msg(X_ERROR, "Error parsing the built-in default configuration.\n");

 

-    return (ret == CONFIG_OK);

+    return ret == CONFIG_OK;

 }

 

 static void

@@ -257,7 +256,7 @@ listPossibleVideoDrivers(char *matches[], int nmatches)
     }

 #endif

 

-    xf86PciMatchDriver(matches, nmatches);

+    i = xf86PciMatchDriver(matches, nmatches);

 

     /* Fallback to platform default hardware */

     if (i < (nmatches - 1)) {

diff --git a/xorg-server/hw/xfree86/common/xf86Bus.c b/xorg-server/hw/xfree86/common/xf86Bus.c
index 77693d742..bec2343b2 100644
--- a/xorg-server/hw/xfree86/common/xf86Bus.c
+++ b/xorg-server/hw/xfree86/common/xf86Bus.c
@@ -245,7 +245,7 @@ xf86AllocateEntity(void)
     xf86Entities[xf86NumEntities - 1] = xnfcalloc(1,sizeof(EntityRec));

     xf86Entities[xf86NumEntities - 1]->entityPrivates =

                xnfcalloc(sizeof(DevUnion) * xf86EntityPrivateCount, 1);

-    return (xf86NumEntities - 1);

+    return xf86NumEntities - 1;

 }

 

 Bool

@@ -257,9 +257,9 @@ xf86IsEntityPrimary(int entityIndex)
 

     switch (pEnt->bus.type) {

     case BUS_PCI:

-	return (pEnt->bus.id.pci == primaryBus.id.pci);

+	return pEnt->bus.id.pci == primaryBus.id.pci;

     case BUS_SBUS:

-	return (pEnt->bus.id.sbus.fbNum == primaryBus.id.sbus.fbNum);

+	return pEnt->bus.id.sbus.fbNum == primaryBus.id.sbus.fbNum;

     default:

 	return FALSE;

     }

@@ -342,7 +342,7 @@ xf86FindScreenForEntity(int entityIndex)
 	for (i = 0; i < xf86NumScreens; i++) {

 	    for (j = 0; j < xf86Screens[i]->numEntities; j++) {

 		if ( xf86Screens[i]->entityList[j] == entityIndex )

-		    return (xf86Screens[i]);

+		    return xf86Screens[i];

 	    }

 	}

     }

@@ -557,7 +557,7 @@ int
 xf86GetLastScrnFlag(int entityIndex)

 {

     if(entityIndex < xf86NumEntities) {

-        return(xf86Entities[entityIndex]->lastScrnFlag);

+        return xf86Entities[entityIndex]->lastScrnFlag;

     } else {

         return -1;

     }

@@ -654,7 +654,7 @@ xf86AllocateEntityPrivateIndex(void)
 	nprivs = xnfrealloc(pEnt->entityPrivates,

 			    xf86EntityPrivateCount * sizeof(DevUnion));

 	/* Zero the new private */

-	bzero(&nprivs[idx], sizeof(DevUnion));

+	memset(&nprivs[idx], 0, sizeof(DevUnion));

 	pEnt->entityPrivates = nprivs;

     }

     return idx;

diff --git a/xorg-server/hw/xfree86/common/xf86Config.c b/xorg-server/hw/xfree86/common/xf86Config.c
index 33b38930f..0b1c767fb 100644
--- a/xorg-server/hw/xfree86/common/xf86Config.c
+++ b/xorg-server/hw/xfree86/common/xf86Config.c
@@ -163,7 +163,7 @@ xf86GetPathElem(char **pnt)
     **pnt = '\0';

     *pnt += 1;

   }

-  return(p1);

+  return p1;

 }

 

 /*

@@ -239,7 +239,7 @@ xf86ValidateFontPath(char *path)
     strcat(out_pnt, path_elem);

     out_pnt += strlen(path_elem);

   }

-  return(tmp_path);

+  return tmp_path;

 }

 

 

@@ -1252,7 +1252,7 @@ checkCoreInputDevices(serverLayoutPtr servlayoutp, Bool implicitLayout)
 

     /* 5. Built-in default. */

     if (!foundPointer && !xf86Info.allowEmptyInput) {

-	bzero(&defPtr, sizeof(defPtr));

+	memset(&defPtr, 0, sizeof(defPtr));

 	defPtr.inp_identifier = strdup("<default pointer>");

 	defPtr.inp_driver = strdup("mouse");

 	confInput = &defPtr;

@@ -1303,7 +1303,7 @@ checkCoreInputDevices(serverLayoutPtr servlayoutp, Bool implicitLayout)
     }

     if (!found && !xf86Info.allowEmptyInput) {

 	xf86Msg(X_INFO, "No default mouse found, adding one\n");

-	bzero(&defPtr, sizeof(defPtr));

+	memset(&defPtr, 0, sizeof(defPtr));

 	defPtr.inp_identifier = strdup("<default pointer>");

 	defPtr.inp_driver = strdup("mouse");

 	confInput = &defPtr;

@@ -1392,7 +1392,7 @@ checkCoreInputDevices(serverLayoutPtr servlayoutp, Bool implicitLayout)
 

     /* 5. Built-in default. */

     if (!foundKeyboard && !xf86Info.allowEmptyInput) {

-	bzero(&defKbd, sizeof(defKbd));

+	memset(&defKbd, 0, sizeof(defKbd));

 	defKbd.inp_identifier = strdup("<default keyboard>");

 	defKbd.inp_driver = strdup("kbd");

 	confInput = &defKbd;

@@ -1851,7 +1851,7 @@ configScreen(confScreenPtr screenp, XF86ConfScreenPtr conf_screen, int scrnum,
     if (!conf_screen->scrn_monitor) {

 	XF86ConfMonitorRec defMon;

 

-	bzero(&defMon, sizeof(defMon));

+	memset(&defMon, 0, sizeof(defMon));

 	defMon.mon_identifier = "<default monitor>";

 	if (!configMonitor(screenp->monitor, &defMon))

 	    return FALSE;

@@ -2330,6 +2330,7 @@ configInput(IDevPtr inputp, XF86ConfInputPtr conf_input, MessageType from)
     inputp->driver = conf_input->inp_driver;

     inputp->commonOptions = conf_input->inp_option_lst;

     inputp->extraOptions = NULL;

+    inputp->attrs = NULL;

 

     return TRUE;

 }

diff --git a/xorg-server/hw/xfree86/common/xf86Cursor.c b/xorg-server/hw/xfree86/common/xf86Cursor.c
index 76490e52d..acfa79f10 100644
--- a/xorg-server/hw/xfree86/common/xf86Cursor.c
+++ b/xorg-server/hw/xfree86/common/xf86Cursor.c
@@ -581,7 +581,7 @@ xf86InitOrigins(void)
 {

     unsigned long screensLeft, prevScreensLeft, mask;

     screenLayoutPtr screen;

-    ScreenPtr pScreen;

+    ScreenPtr pScreen, refScreen;

     int x1, x2, y1, y2, left, right, top, bottom;

     int i, j, ref, minX, minY, min, max;

     xf86ScreenLayoutPtr pLayout;

@@ -590,7 +590,7 @@ xf86InitOrigins(void)
     /* need to have this set up with a config file option */

     HardEdges = FALSE;

 

-    bzero(xf86ScreenLayout, MAXSCREENS * sizeof(xf86ScreenLayoutRec));

+    memset(xf86ScreenLayout, 0, MAXSCREENS * sizeof(xf86ScreenLayoutRec));

 	

     screensLeft = prevScreensLeft = (1 << xf86NumScreens) - 1;

 

@@ -608,6 +608,7 @@ xf86InitOrigins(void)
 	        continue;

 	    }

 

+	    pScreen = xf86Screens[i]->pScreen;

 	    switch(screen->where) {

 	    case PosObsolete:

 		OldStyleConfig = TRUE;

@@ -620,7 +621,7 @@ xf86InitOrigins(void)
 			break;

 		    }

 		    pLayout->left = AddEdge(pLayout->left, 

-			0, xf86Screens[i]->pScreen->height,

+			0, pScreen->height,

 			xf86Screens[ref]->pScreen->width, 0, ref);

 		}

 		if(screen->right) {

@@ -629,7 +630,6 @@ xf86InitOrigins(void)
 			ErrorF("Referenced uninitialized screen in Layout!\n");

 			break;

 		    }

-		    pScreen = xf86Screens[i]->pScreen;

 		    pLayout->right = AddEdge(pLayout->right, 

 			0, pScreen->height, -pScreen->width, 0, ref);

 		}

@@ -640,7 +640,7 @@ xf86InitOrigins(void)
 			break;

 		    }

 		    pLayout->up = AddEdge(pLayout->up, 

-			0, xf86Screens[i]->pScreen->width,

+			0, pScreen->width,

 			0, xf86Screens[ref]->pScreen->height, ref);

 		}

 		if(screen->bottom) {

@@ -649,7 +649,6 @@ xf86InitOrigins(void)
 			ErrorF("Referenced uninitialized screen in Layout!\n");

 			break;

 		    }

-		    pScreen = xf86Screens[i]->pScreen;

 		    pLayout->down = AddEdge(pLayout->down, 

 			0, pScreen->width, 0, -pScreen->height, ref);

 		}

@@ -658,8 +657,8 @@ xf86InitOrigins(void)
 		screen->x = screen->y = 0;

 		/* FALLTHROUGH */

 	    case PosAbsolute:

-		dixScreenOrigins[i].x = screen->x;

-		dixScreenOrigins[i].y = screen->y;

+		pScreen->x = screen->x;

+		pScreen->y = screen->y;

 		screensLeft &= ~(1 << i);

 		break;

 	    case PosRelative:

@@ -669,8 +668,9 @@ xf86InitOrigins(void)
 		    break;

 		}

 		if(screensLeft & (1 << ref)) break;

-		dixScreenOrigins[i].x = dixScreenOrigins[ref].x + screen->x;

-		dixScreenOrigins[i].y = dixScreenOrigins[ref].y + screen->y;

+		refScreen = xf86Screens[ref]->pScreen;

+		pScreen->x = refScreen->x + screen->x;

+		pScreen->y = refScreen->y + screen->y;

 		screensLeft &= ~(1 << i);

 		break;

 	    case PosRightOf:

@@ -680,10 +680,9 @@ xf86InitOrigins(void)
 		    break;

 		}

 		if(screensLeft & (1 << ref)) break;

-		pScreen = xf86Screens[ref]->pScreen;

-		dixScreenOrigins[i].x = 

-			dixScreenOrigins[ref].x + pScreen->width;

-		dixScreenOrigins[i].y = dixScreenOrigins[ref].y;

+		refScreen = xf86Screens[ref]->pScreen;

+		pScreen->x = refScreen->x + refScreen->width;

+		pScreen->y = refScreen->y;

 		screensLeft &= ~(1 << i);

 		break;

 	    case PosLeftOf:

@@ -693,10 +692,9 @@ xf86InitOrigins(void)
 		    break;

 		}

 		if(screensLeft & (1 << ref)) break;

-		pScreen = xf86Screens[i]->pScreen;

-		dixScreenOrigins[i].x = 

-			dixScreenOrigins[ref].x - pScreen->width;

-		dixScreenOrigins[i].y = dixScreenOrigins[ref].y;

+		refScreen = xf86Screens[ref]->pScreen;

+		pScreen->x = refScreen->x - pScreen->width;

+		pScreen->y = refScreen->y;

 		screensLeft &= ~(1 << i);

 		break;

 	    case PosBelow:

@@ -706,10 +704,9 @@ xf86InitOrigins(void)
 		    break;

 		}

 		if(screensLeft & (1 << ref)) break;

-		pScreen = xf86Screens[ref]->pScreen;

-		dixScreenOrigins[i].x = dixScreenOrigins[ref].x;

-		dixScreenOrigins[i].y = 

-			dixScreenOrigins[ref].y + pScreen->height;

+		refScreen = xf86Screens[ref]->pScreen;

+		pScreen->x = refScreen->x;

+		pScreen->y = refScreen->y + refScreen->height;

 		screensLeft &= ~(1 << i);

 		break;

 	    case PosAbove:

@@ -719,10 +716,9 @@ xf86InitOrigins(void)
 		    break;

 		}

 		if(screensLeft & (1 << ref)) break;

-		pScreen = xf86Screens[i]->pScreen;

-		dixScreenOrigins[i].x = dixScreenOrigins[ref].x;

-		dixScreenOrigins[i].y = 

-			dixScreenOrigins[ref].y - pScreen->height;

+		refScreen = xf86Screens[ref]->pScreen;

+		pScreen->x = refScreen->x;

+		pScreen->y = refScreen->y - pScreen->height;

 		screensLeft &= ~(1 << i);

 		break;

 	    default:

@@ -741,7 +737,7 @@ xf86InitOrigins(void)
 	    while(!((1 << i) & screensLeft)){ i++; }

 

 	    ref = xf86ConfigLayout.screens[i].refscreen->screennum;

-	    dixScreenOrigins[ref].x = dixScreenOrigins[ref].y = 0;

+	    xf86Screens[ref]->pScreen->x = xf86Screens[ref]->pScreen->y = 0;

 	    screensLeft &= ~(1 << ref);

 	}

 

@@ -749,20 +745,20 @@ xf86InitOrigins(void)
     }

 

     /* justify the topmost and leftmost to (0,0) */

-    minX = dixScreenOrigins[0].x;

-    minY = dixScreenOrigins[0].y;

+    minX = xf86Screens[0]->pScreen->x;

+    minY = xf86Screens[0]->pScreen->y;

 

     for(i = 1; i < xf86NumScreens; i++) {

-	if(dixScreenOrigins[i].x < minX)

-	  minX = dixScreenOrigins[i].x;

-	if(dixScreenOrigins[i].y < minY)

-	  minY = dixScreenOrigins[i].y;

+	if(xf86Screens[i]->pScreen->x < minX)

+	  minX = xf86Screens[i]->pScreen->x;

+	if(xf86Screens[i]->pScreen->y < minY)

+	  minY = xf86Screens[i]->pScreen->y;

     }

 

     if (minX || minY) {

 	for(i = 0; i < xf86NumScreens; i++) {

-	   dixScreenOrigins[i].x -= minX;

-	   dixScreenOrigins[i].y -= minY;

+	   xf86Screens[i]->pScreen->x -= minX;

+	   xf86Screens[i]->pScreen->y -= minY;

 	}

     }

 

@@ -775,18 +771,20 @@ xf86InitOrigins(void)
 

 	pScreen = xf86Screens[i]->pScreen;

 

-	left = dixScreenOrigins[i].x;

+	left = pScreen->x;

 	right = left + pScreen->width;

-	top = dixScreenOrigins[i].y;

+	top = pScreen->y;

 	bottom = top + pScreen->height;

 

 	for(j = 0; j < xf86NumScreens; j++) {

 	    if(i == j) continue;

 

-	    x1 = dixScreenOrigins[j].x;

-	    x2 = x1 + xf86Screens[j]->pScreen->width;

-	    y1 = dixScreenOrigins[j].y;

-	    y2 = y1 + xf86Screens[j]->pScreen->height;

+	    refScreen = xf86Screens[j]->pScreen;

+

+	    x1 = refScreen->x;

+	    x2 = x1 + refScreen->width;

+	    y1 = refScreen->y;

+	    y2 = y1 + refScreen->height;

 

 	    if((bottom > y1) && (top < y2)) {

 		min = y1 - top;

@@ -796,13 +794,13 @@ xf86InitOrigins(void)
 

 		if(((left - 1) >= x1) && ((left - 1) < x2))

 		    pLayout->left = AddEdge(pLayout->left, min, max,

-			dixScreenOrigins[i].x - dixScreenOrigins[j].x,

-			dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);

+			pScreen->x - refScreen->x,

+			pScreen->y - refScreen->y, j);

 

 		if((right >= x1) && (right < x2))	

 		    pLayout->right = AddEdge(pLayout->right, min, max,

-			dixScreenOrigins[i].x - dixScreenOrigins[j].x,

-			dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);

+			pScreen->x - refScreen->x,

+			pScreen->y - refScreen->y, j);

 	    }

 

 

@@ -814,13 +812,13 @@ xf86InitOrigins(void)
 

 		if(((top - 1) >= y1) && ((top - 1) < y2))

 		    pLayout->up = AddEdge(pLayout->up, min, max,

-			dixScreenOrigins[i].x - dixScreenOrigins[j].x,

-			dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);

+			pScreen->x - refScreen->x,

+			pScreen->y - refScreen->y, j);

 

 		if((bottom >= y1) && (bottom < y2))

 		    pLayout->down = AddEdge(pLayout->down, min, max,

-			dixScreenOrigins[i].x - dixScreenOrigins[j].x,

-			dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);

+			pScreen->x - refScreen->x,

+			pScreen->y - refScreen->y, j);

 	    }

 	}

       }

@@ -850,10 +848,10 @@ xf86ReconfigureLayout(void)
     for (i = 0; i < MAXSCREENS; i++) {

 	xf86ScreenLayoutPtr sl = &xf86ScreenLayout[i];

 	/* we don't have to zero these, xf86InitOrigins() takes care of that */

-	if (sl->left) free(sl->left);

-	if (sl->right) free(sl->right);

-	if (sl->up) free(sl->up);

-	if (sl->down) free(sl->down);

+	free(sl->left);

+	free(sl->right);

+	free(sl->up);

+	free(sl->down);

     }

 

     xf86InitOrigins();

diff --git a/xorg-server/hw/xfree86/common/xf86DGA.c b/xorg-server/hw/xfree86/common/xf86DGA.c
index ac8302169..bc2aa3ba6 100644
--- a/xorg-server/hw/xfree86/common/xf86DGA.c
+++ b/xorg-server/hw/xfree86/common/xf86DGA.c
@@ -51,8 +51,8 @@
 

 #include "mi.h"

 

-static int DGAScreenKeyIndex;

-static DevPrivateKey DGAScreenKey;

+static DevPrivateKeyRec DGAScreenKeyRec;

+#define DGAScreenKeyRegistered dixPrivateKeyRegistered(&DGAScreenKeyRec)

 static int mieq_installed = 0;

 

 static Bool DGACloseScreen(int i, ScreenPtr pScreen);

@@ -71,7 +71,7 @@ DGACopyModeInfo(
 int *XDGAEventBase = NULL;

 

 #define DGA_GET_SCREEN_PRIV(pScreen) ((DGAScreenPtr) \

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

+    dixLookupPrivate(&(pScreen)->devPrivates, &DGAScreenKeyRec))

 

 

 typedef struct _FakedVisualList{

@@ -118,7 +118,8 @@ DGAInit(
     if(!modes || num <= 0)

 	return FALSE;

 

-    DGAScreenKey = &DGAScreenKeyIndex;

+    if (!dixRegisterPrivateKey(&DGAScreenKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

 

     pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);

 

@@ -126,7 +127,7 @@ DGAInit(
     {

 	if(!(pScreenPriv = (DGAScreenPtr)malloc(sizeof(DGAScreenRec))))

 	    return FALSE;

-	dixSetPrivate(&pScreen->devPrivates, DGAScreenKey, pScreenPriv);

+	dixSetPrivate(&pScreen->devPrivates, &DGAScreenKeyRec, pScreenPriv);

 	pScreenPriv->CloseScreen = pScreen->CloseScreen;

 	pScreen->CloseScreen = DGACloseScreen;

 	pScreenPriv->DestroyColormap = pScreen->DestroyColormap;

@@ -177,7 +178,7 @@ DGAReInitModes(
     int i;

 

     /* No DGA? Ignore call (but don't make it look like it failed) */

-    if(DGAScreenKey == NULL)

+    if(!DGAScreenKeyRegistered)

 	return TRUE;

 	

     pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);

@@ -347,7 +348,7 @@ xf86SetDGAMode(
    DGAModePtr pMode = NULL;

 

    /* First check if DGAInit was successful on this screen */

-   if (DGAScreenKey == NULL)

+   if (!DGAScreenKeyRegistered)

 	return BadValue;

    pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);

    if (!pScreenPriv)

@@ -478,7 +479,7 @@ DGAChangePixmapMode(int index, int *x, int *y, int mode)
    DGAModePtr   pMode;

    PixmapPtr    pPix;

 

-   if(DGAScreenKey == NULL)

+   if(!DGAScreenKeyRegistered)

 	return FALSE;

 

    pScreenPriv = DGA_GET_SCREEN_PRIV(screenInfo.screens[index]);

@@ -528,7 +529,7 @@ DGAChangePixmapMode(int index, int *x, int *y, int mode)
 Bool

 DGAAvailable(int index) 

 {

-   if(DGAScreenKey == NULL)

+   if(!DGAScreenKeyRegistered)

 	return FALSE;

    

    if(DGA_GET_SCREEN_PRIV(screenInfo.screens[index]))

@@ -542,7 +543,7 @@ DGAActive(int index)
 {

    DGAScreenPtr pScreenPriv;

 

-   if(DGAScreenKey == NULL)

+   if(!DGAScreenKeyRegistered)

 	return FALSE;

 

    pScreenPriv = DGA_GET_SCREEN_PRIV(screenInfo.screens[index]);

@@ -563,7 +564,7 @@ DGAShutdown(void)
     ScrnInfoPtr pScrn;

     int i;

 

-    if(DGAScreenKey == NULL)

+    if(!DGAScreenKeyRegistered)

 	return;

 

     for(i = 0; i < screenInfo.numScreens; i++) {

@@ -893,7 +894,7 @@ DGAVTSwitch(void)
 

        /* Alternatively, this could send events to DGA clients */

 

-       if(DGAScreenKey) {

+       if(DGAScreenKeyRegistered) {

 	   DGAScreenPtr pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);

 

 	   if(pScreenPriv && pScreenPriv->current)

@@ -910,7 +911,7 @@ DGAStealKeyEvent(DeviceIntPtr dev, int index, int key_code, int is_down)
    DGAScreenPtr pScreenPriv;

    DGAEvent     event;

 

-   if(DGAScreenKey == NULL) /* no DGA */

+   if(!DGAScreenKeyRegistered) /* no DGA */

         return FALSE;

 

    if (key_code < 8 || key_code > 255)

@@ -943,7 +944,7 @@ DGAStealMotionEvent(DeviceIntPtr dev, int index, int dx, int dy)
    DGAScreenPtr pScreenPriv;

    DGAEvent event;

 

-   if(DGAScreenKey == NULL) /* no DGA */

+   if(!DGAScreenKeyRegistered) /* no DGA */

         return FALSE;

     

    pScreenPriv = DGA_GET_SCREEN_PRIV(screenInfo.screens[index]);

@@ -981,7 +982,7 @@ DGAStealButtonEvent(DeviceIntPtr dev, int index, int button, int is_down)
     DGAScreenPtr pScreenPriv;

     DGAEvent event;

 

-    if (DGAScreenKey == NULL)

+    if(!DGAScreenKeyRegistered) /* no DGA */

         return FALSE;

     

     pScreenPriv = DGA_GET_SCREEN_PRIV(screenInfo.screens[index]);

@@ -1009,7 +1010,7 @@ Bool
 DGAIsDgaEvent (xEvent *e)

 {

     int	    coreEquiv;

-    if (DGAScreenKey == NULL || XDGAEventBase == 0)

+    if (!DGAScreenKeyRegistered || XDGAEventBase == 0)

 	return FALSE;

     coreEquiv = e->u.u.type - *XDGAEventBase;

     if (KeyPress <= coreEquiv && coreEquiv <= MotionNotify)

@@ -1203,7 +1204,7 @@ DGAHandleEvent(int screen_num, InternalEvent *ev, DeviceIntPtr device)
     DGAScreenPtr    pScreenPriv;

 

     /* no DGA */

-    if (DGAScreenKey == NULL || XDGAEventBase == 0)

+    if (!DGAScreenKeyRegistered || XDGAEventBase == 0)

 	return;

     pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);

 

diff --git a/xorg-server/hw/xfree86/common/xf86DPMS.c b/xorg-server/hw/xfree86/common/xf86DPMS.c
index 3040cb294..1a8aed306 100644
--- a/xorg-server/hw/xfree86/common/xf86DPMS.c
+++ b/xorg-server/hw/xfree86/common/xf86DPMS.c
@@ -46,7 +46,7 @@
 

 

 #ifdef DPMSExtension

-static int DPMSKeyIndex;

+static DevPrivateKeyRec DPMSKeyRec;

 static DevPrivateKey DPMSKey;

 static Bool DPMSClose(int i, ScreenPtr pScreen);

 static int DPMSCount = 0;

@@ -62,10 +62,9 @@ xf86DPMSInit(ScreenPtr pScreen, DPMSSetProcPtr set, int flags)
     pointer DPMSOpt;

     MessageType enabled_from;

 

-    DPMSKey = &DPMSKeyIndex;

+    DPMSKey = &DPMSKeyRec;

 

-    if (!dixSetPrivate(&pScreen->devPrivates, DPMSKey,

-		       calloc(sizeof(DPMSRec), 1)))

+    if (!dixRegisterPrivateKey(&DPMSKeyRec, PRIVATE_SCREEN, sizeof (DPMSRec)))

 	return FALSE;

 

     pDPMS = dixLookupPrivate(&pScreen->devPrivates, DPMSKey);

@@ -127,8 +126,6 @@ DPMSClose(int i, ScreenPtr pScreen)
  	xf86Screens[i]->DPMSSet(xf86Screens[i],DPMSModeOn,0);

     }

     

-    free(pDPMS);

-    dixSetPrivate(&pScreen->devPrivates, DPMSKey, NULL);

     if (--DPMSCount == 0)

 	DPMSKey = NULL;

     return pScreen->CloseScreen(i, pScreen);

diff --git a/xorg-server/hw/xfree86/common/xf86Globals.c b/xorg-server/hw/xfree86/common/xf86Globals.c
index 8b483f35c..44252c75f 100644
--- a/xorg-server/hw/xfree86/common/xf86Globals.c
+++ b/xorg-server/hw/xfree86/common/xf86Globals.c
@@ -1,208 +1,204 @@
-
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-/*
- * This file contains all the XFree86 global variables.
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include "os.h"
-#include "windowstr.h"
-#include "propertyst.h"
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86Parser.h"
-#include "xf86Xinput.h"
-#include "xf86InPriv.h"
-#include "xf86Config.h"
-
-/* Globals that video drivers may access */
-
-/* Index into pScreen.devPrivates */
-static int xf86CreateRootWindowKeyIndex;
-DevPrivateKey xf86CreateRootWindowKey = &xf86CreateRootWindowKeyIndex;
-/* Index of ScrnInfo in pScreen.devPrivates */
-static int xf86ScreenKeyIndex;
-DevPrivateKey xf86ScreenKey = &xf86ScreenKeyIndex;
-static int xf86PixmapKeyIndex;
-DevPrivateKey xf86PixmapKey = &xf86PixmapKeyIndex;
-ScrnInfoPtr *xf86Screens = NULL;	/* List of ScrnInfos */
-const unsigned char byte_reversed[256] =
-{
-    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
-    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
-    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
-    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
-    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
-    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
-    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
-    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
-    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
-    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
-    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
-    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
-    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
-    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
-    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
-    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
-    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
-    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
-    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
-    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
-    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
-    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
-    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
-    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
-    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
-    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
-    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
-    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
-    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
-    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
-};
-
-/* Globals that input drivers may access */
-InputInfoPtr xf86InputDevs = NULL;
-
-
-/* Globals that video drivers may not access */
-
-xf86InfoRec xf86Info = {
-    .consoleFd                  = -1,
-    .vtno                       = -1,
-    .vtSysreq                   = FALSE,
-    .lastEventTime              = -1,
-    .vtRequestsPending          = FALSE,
-#ifdef sun
-    .vtPendingNum               = -1,
-#endif
-    .dontVTSwitch               = FALSE,
-    .dontZap                    = FALSE,
-    .dontZoom                   = FALSE,
-    .notrapSignals              = FALSE,
-    .caughtSignal               = FALSE,
-    .currentScreen              = NULL,
-#ifdef CSRG_BASED
-    .screenFd                   = -1,
-    .consType                   = -1,
-#endif
-    .allowMouseOpenFail         = FALSE,
-    .vidModeEnabled             = TRUE,
-    .vidModeAllowNonLocal       = FALSE,
-    .miscModInDevEnabled        = TRUE,
-    .miscModInDevAllowNonLocal  = FALSE,
-    .pixmap24                   = Pix24DontCare,
-    .pix24From                  = X_DEFAULT,
-#ifdef SUPPORT_PC98
-    .pc98                       = FALSE,
-#endif
-    .pmFlag                     = TRUE,
-    .log                        = LogNone,
-    .kbdCustomKeycodes          = FALSE,
-    .disableRandR               = FALSE,
-    .randRFrom                  = X_DEFAULT,
-#if defined(CONFIG_HAL) || defined(CONFIG_UDEV)
-    .allowEmptyInput            = TRUE,
-    .autoAddDevices             = TRUE,
-    .autoEnableDevices          = TRUE
-#else
-    .allowEmptyInput            = FALSE,
-    .autoAddDevices             = FALSE,
-    .autoEnableDevices          = FALSE
-#endif
-};
-const char *xf86ConfigFile = NULL;
-const char *xf86ConfigDir = NULL;
-const char *xf86ModulePath = DEFAULT_MODULE_PATH;
-MessageType xf86ModPathFrom = X_DEFAULT;
-const char *xf86LogFile = DEFAULT_LOGPREFIX;
-MessageType xf86LogFileFrom = X_DEFAULT;
-Bool xf86LogFileWasOpened = FALSE;
-serverLayoutRec xf86ConfigLayout = {NULL, };
-confDRIRec xf86ConfigDRI = {0, };
-XF86ConfigPtr xf86configptr = NULL;
-Bool xf86Resetting = FALSE;
-Bool xf86Initialising = FALSE;
-Bool xf86DoConfigure = FALSE;
-Bool xf86DoShowOptions = FALSE;
-DriverPtr *xf86DriverList = NULL;
-int xf86NumDrivers = 0;
-InputDriverPtr *xf86InputDriverList = NULL;
-int xf86NumInputDrivers = 0;
-int xf86NumScreens = 0;
-
-const char *xf86VisualNames[] = {
-	"StaticGray",
-	"GrayScale",
-	"StaticColor",
-	"PseudoColor",
-	"TrueColor",
-	"DirectColor"
-};
-
-/* Parameters set only from the command line */
-char *xf86ServerName = "no-name";
-Bool xf86fpFlag = FALSE;
-Bool xf86sFlag = FALSE;
-Bool xf86bsEnableFlag = FALSE;
-Bool xf86bsDisableFlag = FALSE;
-Bool xf86silkenMouseDisableFlag = FALSE;
-Bool xf86xkbdirFlag = FALSE;
-#ifdef HAVE_ACPI
-Bool xf86acpiDisableFlag = FALSE;
-#endif
-char *xf86LayoutName = NULL;
-char *xf86ScreenName = NULL;
-char *xf86PointerName = NULL;
-char *xf86KeyboardName = NULL;
-int xf86Verbose = DEFAULT_VERBOSE;
-int xf86LogVerbose = DEFAULT_LOG_VERBOSE;
-int xf86FbBpp = -1;
-Pix24Flags xf86Pix24 = Pix24DontCare;
-int xf86Depth = -1;
-rgb xf86Weight = {0, 0, 0};
-Bool xf86FlipPixels = FALSE;
-Gamma xf86Gamma = {0.0, 0.0, 0.0};
-Bool xf86AllowMouseOpenFail = FALSE;
-#ifdef XF86VIDMODE
-Bool xf86VidModeDisabled = FALSE;
-Bool xf86VidModeAllowNonLocal = FALSE;
-#endif
-RootWinPropPtr *xf86RegisteredPropertiesTable = NULL;
-Bool xf86inSuspend = FALSE;
-Bool xorgHWAccess = FALSE;
-
-struct pci_slot_match xf86IsolateDevice = {
-    PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, 0
-};
+

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+/*

+ * This file contains all the XFree86 global variables.

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+#include "os.h"

+#include "windowstr.h"

+#include "propertyst.h"

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86Parser.h"

+#include "xf86Xinput.h"

+#include "xf86InPriv.h"

+#include "xf86Config.h"

+

+/* Globals that video drivers may access */

+

+DevPrivateKeyRec xf86CreateRootWindowKeyRec;

+DevPrivateKeyRec xf86ScreenKeyRec;

+DevPrivateKeyRec xf86PixmapKeyRec;

+

+ScrnInfoPtr *xf86Screens = NULL;	/* List of ScrnInfos */

+const unsigned char byte_reversed[256] =

+{

+    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,

+    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,

+    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,

+    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,

+    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,

+    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,

+    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,

+    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,

+    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,

+    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,

+    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,

+    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,

+    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,

+    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,

+    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,

+    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,

+    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,

+    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,

+    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,

+    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,

+    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,

+    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,

+    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,

+    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,

+    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,

+    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,

+    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,

+    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,

+    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,

+    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,

+    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,

+    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,

+};

+

+/* Globals that input drivers may access */

+InputInfoPtr xf86InputDevs = NULL;

+

+

+/* Globals that video drivers may not access */

+

+xf86InfoRec xf86Info = {

+    .consoleFd                  = -1,

+    .vtno                       = -1,

+    .vtSysreq                   = FALSE,

+    .lastEventTime              = -1,

+    .vtRequestsPending          = FALSE,

+#ifdef sun

+    .vtPendingNum               = -1,

+#endif

+    .dontVTSwitch               = FALSE,

+    .dontZap                    = FALSE,

+    .dontZoom                   = FALSE,

+    .notrapSignals              = FALSE,

+    .caughtSignal               = FALSE,

+    .currentScreen              = NULL,

+#ifdef CSRG_BASED

+    .screenFd                   = -1,

+    .consType                   = -1,

+#endif

+    .allowMouseOpenFail         = FALSE,

+    .vidModeEnabled             = TRUE,

+    .vidModeAllowNonLocal       = FALSE,

+    .miscModInDevEnabled        = TRUE,

+    .miscModInDevAllowNonLocal  = FALSE,

+    .pixmap24                   = Pix24DontCare,

+    .pix24From                  = X_DEFAULT,

+#ifdef SUPPORT_PC98

+    .pc98                       = FALSE,

+#endif

+    .pmFlag                     = TRUE,

+    .log                        = LogNone,

+    .kbdCustomKeycodes          = FALSE,

+    .disableRandR               = FALSE,

+    .randRFrom                  = X_DEFAULT,

+#if defined(CONFIG_HAL) || defined(CONFIG_UDEV)

+    .allowEmptyInput            = TRUE,

+    .autoAddDevices             = TRUE,

+    .autoEnableDevices          = TRUE

+#else

+    .allowEmptyInput            = FALSE,

+    .autoAddDevices             = FALSE,

+    .autoEnableDevices          = FALSE

+#endif

+};

+const char *xf86ConfigFile = NULL;

+const char *xf86ConfigDir = NULL;

+const char *xf86ModulePath = DEFAULT_MODULE_PATH;

+MessageType xf86ModPathFrom = X_DEFAULT;

+const char *xf86LogFile = DEFAULT_LOGPREFIX;

+MessageType xf86LogFileFrom = X_DEFAULT;

+Bool xf86LogFileWasOpened = FALSE;

+serverLayoutRec xf86ConfigLayout = {NULL, };

+confDRIRec xf86ConfigDRI = {0, };

+XF86ConfigPtr xf86configptr = NULL;

+Bool xf86Resetting = FALSE;

+Bool xf86Initialising = FALSE;

+Bool xf86DoConfigure = FALSE;

+Bool xf86DoShowOptions = FALSE;

+DriverPtr *xf86DriverList = NULL;

+int xf86NumDrivers = 0;

+InputDriverPtr *xf86InputDriverList = NULL;

+int xf86NumInputDrivers = 0;

+int xf86NumScreens = 0;

+

+const char *xf86VisualNames[] = {

+	"StaticGray",

+	"GrayScale",

+	"StaticColor",

+	"PseudoColor",

+	"TrueColor",

+	"DirectColor"

+};

+

+/* Parameters set only from the command line */

+char *xf86ServerName = "no-name";

+Bool xf86fpFlag = FALSE;

+Bool xf86sFlag = FALSE;

+Bool xf86bsEnableFlag = FALSE;

+Bool xf86bsDisableFlag = FALSE;

+Bool xf86silkenMouseDisableFlag = FALSE;

+Bool xf86xkbdirFlag = FALSE;

+#ifdef HAVE_ACPI

+Bool xf86acpiDisableFlag = FALSE;

+#endif

+char *xf86LayoutName = NULL;

+char *xf86ScreenName = NULL;

+char *xf86PointerName = NULL;

+char *xf86KeyboardName = NULL;

+int xf86Verbose = DEFAULT_VERBOSE;

+int xf86LogVerbose = DEFAULT_LOG_VERBOSE;

+int xf86FbBpp = -1;

+Pix24Flags xf86Pix24 = Pix24DontCare;

+int xf86Depth = -1;

+rgb xf86Weight = {0, 0, 0};

+Bool xf86FlipPixels = FALSE;

+Gamma xf86Gamma = {0.0, 0.0, 0.0};

+Bool xf86AllowMouseOpenFail = FALSE;

+#ifdef XF86VIDMODE

+Bool xf86VidModeDisabled = FALSE;

+Bool xf86VidModeAllowNonLocal = FALSE;

+#endif

+RootWinPropPtr *xf86RegisteredPropertiesTable = NULL;

+Bool xf86inSuspend = FALSE;

+Bool xorgHWAccess = FALSE;

+

+struct pci_slot_match xf86IsolateDevice = {

+    PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, 0

+};

diff --git a/xorg-server/hw/xfree86/common/xf86Helper.c b/xorg-server/hw/xfree86/common/xf86Helper.c
index 0fa695a3a..a88a1e758 100644
--- a/xorg-server/hw/xfree86/common/xf86Helper.c
+++ b/xorg-server/hw/xfree86/common/xf86Helper.c
@@ -234,8 +234,7 @@ xf86DeleteScreen(int scrnIndex, int flags)
     if (pScrn->drv)

 	pScrn->drv->refCount--;

 

-    if (pScrn->privates)

-	free(pScrn->privates);

+    free(pScrn->privates);

 

     xf86ClearEntityListForScreen(scrnIndex);

 

@@ -269,7 +268,7 @@ xf86AllocateScrnInfoPrivateIndex(void)
 	nprivs = xnfrealloc(pScr->privates,

 			    xf86ScrnInfoPrivateCount * sizeof(DevUnion));

 	/* Zero the new private */

-	bzero(&nprivs[idx], sizeof(DevUnion));

+	memset(&nprivs[idx], 0, sizeof(DevUnion));

 	pScr->privates = nprivs;

     }

     return idx;

@@ -327,8 +326,7 @@ xf86DeleteInput(InputInfoPtr pInp, int flags)
     /* This should *really* be handled in drv->UnInit(dev) call instead, but

      * if the driver forgets about it make sure we free it or at least crash

      * with flying colors */

-    if (pInp->private)

-	free(pInp->private);

+    free(pInp->private);

 

     FreeInputAttributes(pInp->attrs);

 

@@ -1062,7 +1060,7 @@ xf86SetBlackWhitePixels(ScreenPtr pScreen)
 static void

 xf86SetRootClip (ScreenPtr pScreen, Bool enable)

 {

-    WindowPtr	pWin = WindowTable[pScreen->myNum];

+    WindowPtr	pWin = pScreen->root;

     WindowPtr	pChild;

     Bool	WasViewable = (Bool)(pWin->viewable);

     Bool	anyMarked = FALSE;

@@ -1085,8 +1083,8 @@ xf86SetRootClip (ScreenPtr pScreen, Bool enable)
 	    {

 		RegionPtr	borderVisible;

 

-		borderVisible = REGION_CREATE(pScreen, NullBox, 1);

-		REGION_SUBTRACT(pScreen, borderVisible,

+		borderVisible = RegionCreate(NullBox, 1);

+		RegionSubtract(borderVisible,

 				&pWin->borderClip, &pWin->winSize);

 		pWin->valdata->before.borderVisible = borderVisible;

 	    }

@@ -1105,18 +1103,18 @@ xf86SetRootClip (ScreenPtr pScreen, Bool enable)
 	box.y1 = 0;

 	box.x2 = pScreen->width;

 	box.y2 = pScreen->height;

-	REGION_INIT (pScreen, &pWin->winSize, &box, 1);

-	REGION_INIT (pScreen, &pWin->borderSize, &box, 1);

+	RegionInit(&pWin->winSize, &box, 1);

+	RegionInit(&pWin->borderSize, &box, 1);

 	if (WasViewable)

-	    REGION_RESET(pScreen, &pWin->borderClip, &box);

+	    RegionReset(&pWin->borderClip, &box);

 	pWin->drawable.width = pScreen->width;

 	pWin->drawable.height = pScreen->height;

-        REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList);

+        RegionBreak(&pWin->clipList);

     }

     else

     {

-	REGION_EMPTY(pScreen, &pWin->borderClip);

-	REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList);

+	RegionEmpty(&pWin->borderClip);

+	RegionBreak(&pWin->clipList);

     }

 

     ResizeChildrenWinSize (pWin, 0, 0, 0, 0);

@@ -1362,7 +1360,7 @@ xf86TokenToString(SymTabPtr table, int token)
     if (table[i].token < 0)

 	return NULL;

     else

-	return(table[i].name);

+	return table[i].name;

 }

 

 int

@@ -1376,7 +1374,7 @@ xf86StringToToken(SymTabPtr table, const char *string)
     for (i = 0; table[i].token >= 0 && xf86NameCmp(string, table[i].name); i++)

 	;

 

-    return(table[i].token);

+    return table[i].token;

 }

 

 /*

@@ -1995,7 +1993,7 @@ xf86RegisterRootWindowProperty(int ScrnIndex, Atom property, Atom type,
 	   ScrnIndex, property, type, format, len, value);

 

     if (ScrnIndex<0 || ScrnIndex>=xf86NumScreens) {

-      return(BadMatch);

+      return BadMatch;

     }

 

     if (xf86RegisteredPropertiesTable &&

@@ -2009,7 +2007,7 @@ xf86RegisterRootWindowProperty(int ScrnIndex, Atom property, Atom type,
 

     if (!pNewProp) {

       if ((pNewProp = (RootWinPropPtr)malloc(sizeof(RootWinProp))) == NULL) {

-	return(BadAlloc);

+	return BadAlloc;

       }

       /*

        * We will put this property at the end of the list so that

@@ -2017,8 +2015,7 @@ xf86RegisterRootWindowProperty(int ScrnIndex, Atom property, Atom type,
        */

       pNewProp->next = NULL;

     } else {

-      if (pNewProp->name)

-	free(pNewProp->name);

+      free(pNewProp->name);

       existing = TRUE;

     }

 

@@ -2034,7 +2031,7 @@ xf86RegisterRootWindowProperty(int ScrnIndex, Atom property, Atom type,
       DebugF("creating xf86RegisteredPropertiesTable[] size %d\n",

 	     xf86NumScreens);

       if ( NULL==(xf86RegisteredPropertiesTable=(RootWinPropPtr*)xnfcalloc(sizeof(RootWinProp),xf86NumScreens) )) {

-	return(BadAlloc);

+	return BadAlloc;

       }

       for (i=0; i<xf86NumScreens; i++) {

 	xf86RegisteredPropertiesTable[i] = NULL;

@@ -2059,7 +2056,7 @@ xf86RegisterRootWindowProperty(int ScrnIndex, Atom property, Atom type,
       }

     }

     DebugF("xf86RegisterRootWindowProperty succeeded\n");

-    return(Success);

+    return Success;

 }

 

 Bool

diff --git a/xorg-server/hw/xfree86/common/xf86Init.c b/xorg-server/hw/xfree86/common/xf86Init.c
index ed9aca67c..fd3281b83 100644
--- a/xorg-server/hw/xfree86/common/xf86Init.c
+++ b/xorg-server/hw/xfree86/common/xf86Init.c
@@ -66,6 +66,7 @@
 #include "xf86Priv.h"

 #include "xf86Config.h"

 #include "xf86_OSlib.h"

+#include "xf86cmap.h"

 #include "xorgVersion.h"

 #include "xf86Build.h"

 #include "mipointer.h"

@@ -202,8 +203,8 @@ xf86PrintBanner(void)
     struct tm t;

     char buf[100];

 

-    bzero(&t, sizeof(t));

-    bzero(buf, sizeof(buf));

+    memset(&t, 0, sizeof(t));

+    memset(buf, 0, sizeof(buf));

     t.tm_mday = BUILD_DATE % 100;

     t.tm_mon = (BUILD_DATE / 100) % 100 - 1;

     t.tm_year = BUILD_DATE / 10000 - 1900;

@@ -293,7 +294,7 @@ xf86CreateRootWindow(WindowPtr pWin)
   }

 

   DebugF("xf86CreateRootWindow() returns %d\n", ret);

-  return (ret);

+  return ret;

 }

 

 

@@ -734,6 +735,15 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
   }

 #endif /* SCO325 */

 

+  for (i = 0; i < xf86NumScreens; i++)

+      if (!xf86ColormapAllocatePrivates(xf86Screens[i]))

+	  FatalError("Cannot register DDX private keys");

+

+  if (!dixRegisterPrivateKey(&xf86ScreenKeyRec, PRIVATE_SCREEN, 0) ||

+      !dixRegisterPrivateKey(&xf86CreateRootWindowKeyRec, PRIVATE_SCREEN, 0) ||

+      !dixRegisterPrivateKey(&xf86PixmapKeyRec, PRIVATE_PIXMAP, 0))

+      FatalError("Cannot register DDX private keys");

+

   for (i = 0; i < xf86NumScreens; i++) {

 	xf86VGAarbiterLock(xf86Screens[i]);

 	/*

diff --git a/xorg-server/hw/xfree86/common/xf86Option.c b/xorg-server/hw/xfree86/common/xf86Option.c
index d1dcb0f94..5b20229a9 100644
--- a/xorg-server/hw/xfree86/common/xf86Option.c
+++ b/xorg-server/hw/xfree86/common/xf86Option.c
@@ -745,7 +745,7 @@ xf86IsOptionSet(const OptionInfoRec *table, int token)
     OptionInfoPtr p;

 

     p = xf86TokenToOptinfo(table, token);

-    return (p && p->found);

+    return p && p->found;

 }

 

 

diff --git a/xorg-server/hw/xfree86/common/xf86RandR.c b/xorg-server/hw/xfree86/common/xf86RandR.c
index 1893974e2..3bd15e059 100644
--- a/xorg-server/hw/xfree86/common/xf86RandR.c
+++ b/xorg-server/hw/xfree86/common/xf86RandR.c
@@ -46,7 +46,7 @@ typedef struct _xf86RandRInfo {
     Rotation			    rotation;

 } XF86RandRInfoRec, *XF86RandRInfoPtr;

 

-static int xf86RandRKeyIndex;

+static DevPrivateKeyRec xf86RandRKeyRec;

 static DevPrivateKey xf86RandRKey;

 

 #define XF86RANDRINFO(p) ((XF86RandRInfoPtr)dixLookupPrivate(&(p)->devPrivates, xf86RandRKey))

@@ -159,7 +159,7 @@ xf86RandRSetMode (ScreenPtr	    pScreen,
     int			oldmmHeight = pScreen->mmHeight;

     int			oldVirtualX = scrp->virtualX;

     int			oldVirtualY = scrp->virtualY;

-    WindowPtr		pRoot = WindowTable[pScreen->myNum];

+    WindowPtr		pRoot = pScreen->root;

     Bool		ret = TRUE;

 

     if (pRoot && scrp->vtSema)

@@ -424,7 +424,10 @@ xf86RandRInit (ScreenPtr    pScreen)
 	return TRUE;

 #endif

 

-    xf86RandRKey = &xf86RandRKeyIndex;

+    xf86RandRKey = &xf86RandRKeyRec;

+

+    if (!dixRegisterPrivateKey(&xf86RandRKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

 

     randrp = malloc(sizeof (XF86RandRInfoRec));

     if (!randrp)

diff --git a/xorg-server/hw/xfree86/common/xf86VGAarbiter.c b/xorg-server/hw/xfree86/common/xf86VGAarbiter.c
index ac44c5e67..e5fd0fb85 100644
--- a/xorg-server/hw/xfree86/common/xf86VGAarbiter.c
+++ b/xorg-server/hw/xfree86/common/xf86VGAarbiter.c
@@ -62,10 +62,10 @@ static miPointerSpriteFuncRec VGAarbiterSpriteFuncs = {
     VGAarbiterDeviceCursorInitialize, VGAarbiterDeviceCursorCleanup

 };

 

-static int VGAarbiterKeyIndex;

-static DevPrivateKey VGAarbiterScreenKey = &VGAarbiterKeyIndex;

-static int VGAarbiterGCIndex;

-static DevPrivateKey VGAarbiterGCKey = &VGAarbiterGCIndex;

+static DevPrivateKeyRec VGAarbiterScreenKeyRec;

+#define VGAarbiterScreenKey (&VGAarbiterScreenKeyRec)

+static DevPrivateKeyRec VGAarbiterGCKeyRec;

+#define VGAarbiterGCKey (&VGAarbiterGCKeyRec)

 

 static int vga_no_arb = 0;

 void

@@ -175,9 +175,12 @@ xf86VGAarbiterWrapFunctions(void)
         pScrn = xf86Screens[pScreen->myNum];

         PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey);

 

-        if (!dixRequestPrivate(VGAarbiterGCKey, sizeof(VGAarbiterGCRec)))

+        if (!dixRegisterPrivateKey(&VGAarbiterGCKeyRec, PRIVATE_GC, sizeof(VGAarbiterGCRec)))

             return FALSE;

 

+	if (!dixRegisterPrivateKey(&VGAarbiterScreenKeyRec, PRIVATE_SCREEN, 0))

+	    return FALSE;

+

         if (!(pScreenPriv = malloc(sizeof(VGAarbiterScreenRec))))

             return FALSE;

 

diff --git a/xorg-server/hw/xfree86/common/xf86VidMode.c b/xorg-server/hw/xfree86/common/xf86VidMode.c
index 08f27b8e4..591c338b1 100644
--- a/xorg-server/hw/xfree86/common/xf86VidMode.c
+++ b/xorg-server/hw/xfree86/common/xf86VidMode.c
@@ -47,7 +47,7 @@
 #include "vidmodeproc.h"

 #include "xf86cmap.h"

 

-static int VidModeKeyIndex;

+static DevPrivateKeyRec VidModeKeyRec;

 static DevPrivateKey VidModeKey;

 static int VidModeCount = 0;

 static Bool VidModeClose(int i, ScreenPtr pScreen);

@@ -67,15 +67,17 @@ VidModeExtensionInit(ScreenPtr pScreen)
 	return FALSE;

     }

 

-    VidModeKey = &VidModeKeyIndex;

+    VidModeKey = &VidModeKeyRec;

 

-    if (!dixSetPrivate(&pScreen->devPrivates, VidModeKey,

-		       calloc(sizeof(VidModeRec), 1))) {

-	DebugF("xcalloc failed\n");

+    if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, 0))

 	return FALSE;

-    }

 

-    pVidMode = VMPTR(pScreen);

+    pVidMode = calloc(sizeof(VidModeRec), 1);

+    if (!pVidMode)

+	return FALSE;

+

+    dixSetPrivate(&pScreen->devPrivates, VidModeKey, pVidMode);

+

     pVidMode->Flags = 0;

     pVidMode->Next = NULL;

     pVidMode->CloseScreen = pScreen->CloseScreen;

diff --git a/xorg-server/hw/xfree86/common/xf86Xinput.c b/xorg-server/hw/xfree86/common/xf86Xinput.c
index 2d82ccdbc..845bde87a 100644
--- a/xorg-server/hw/xfree86/common/xf86Xinput.c
+++ b/xorg-server/hw/xfree86/common/xf86Xinput.c
@@ -80,6 +80,9 @@
 #ifdef HAVE_FNMATCH_H

 #include <fnmatch.h>

 #endif

+#ifdef HAVE_SYS_UTSNAME_H

+#include <sys/utsname.h>

+#endif

 

 #include "extnsionst.h"

 

@@ -278,9 +281,9 @@ xf86SendDragEvents(DeviceIntPtr	device)
     LocalDevicePtr local = (LocalDevicePtr) device->public.devicePrivate;

     

     if (device->button && device->button->buttonsDown > 0)

-        return (local->flags & XI86_SEND_DRAG_EVENTS);

+        return local->flags & XI86_SEND_DRAG_EVENTS;

     else

-        return (TRUE);

+        return TRUE;

 }

 

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

@@ -497,73 +500,152 @@ AddOtherInputDevices(void)
 }

 

 /*

- * Classes without any Match statements match all devices. Otherwise, all

- * statements must match.

+ * Get the operating system name from uname and store it statically to avoid

+ * repeating the system call each time MatchOS is checked.

  */

-static Bool

-InputClassMatches(XF86ConfInputClassPtr iclass, InputAttributes *attrs)

+static const char *

+HostOS(void)

 {

-    char **cur;

-    Bool match;

-

-    if (iclass->match_product) {

-        if (!attrs->product)

-            return FALSE;

-        /* see if any of the values match */

-        for (cur = iclass->match_product, match = FALSE; *cur; cur++)

-            if (strstr(attrs->product, *cur)) {

-                match = TRUE;

-                break;

-            }

-        if (!match)

-            return FALSE;

-    }

-    if (iclass->match_vendor) {

-        if (!attrs->vendor)

-            return FALSE;

-        /* see if any of the values match */

-        for (cur = iclass->match_vendor, match = FALSE; *cur; cur++)

-            if (strstr(attrs->vendor, *cur)) {

-                match = TRUE;

-                break;

-            }

-        if (!match)

-            return FALSE;

+#ifdef HAVE_SYS_UTSNAME_H

+    struct utsname name;

+    static char host_os[sizeof(name.sysname)] = "";

+

+    if (*host_os == '\0') {

+        if (uname(&name) >= 0)

+            strcpy(host_os, name.sysname);

+        else {

+            strncpy(host_os, "unknown", sizeof(host_os));

+            host_os[sizeof(host_os)-1] = '\0';

+        }

     }

-    if (iclass->match_device) {

-        if (!attrs->device)

-            return FALSE;

-        /* see if any of the values match */

-        for (cur = iclass->match_device, match = FALSE; *cur; cur++)

+    return host_os;

+#else

+    return "";

+#endif

+}

+

+static int

+match_substring(const char *attr, const char *pattern)

+{

+    return (strstr(attr, pattern)) ? 0 : -1;

+}

+

+#ifdef HAVE_FNMATCH_H

+static int

+match_pattern(const char *attr, const char *pattern)

+{

+    return fnmatch(pattern, attr, 0);

+}

+#else

+#define match_pattern match_substring

+#endif

+

 #ifdef HAVE_FNMATCH_H

-            if (fnmatch(*cur, attrs->device, FNM_PATHNAME) == 0) {

+static int

+match_path_pattern(const char *attr, const char *pattern)

+{

+    return fnmatch(pattern, attr, FNM_PATHNAME);

+}

 #else

-            if (strstr(attrs->device, *cur)) {

+#define match_path_pattern match_substring

 #endif

+

+/*

+ * Match an attribute against a list of NULL terminated arrays of patterns.

+ * If a pattern in each list entry is matched, return TRUE.

+ */

+static Bool

+MatchAttrToken(const char *attr, struct list *patterns,

+               int (*compare)(const char *attr, const char *pattern))

+{

+    const xf86MatchGroup *group;

+

+    /* If there are no patterns, accept the match */

+    if (list_is_empty(patterns))

+        return TRUE;

+

+    /* If there are patterns but no attribute, reject the match */

+    if (!attr)

+        return FALSE;

+

+    /*

+     * Otherwise, iterate the list of patterns ensuring each entry has a

+     * match. Each list entry is a separate Match line of the same type.

+     */

+    list_for_each_entry(group, patterns, entry) {

+        char * const *cur;

+        Bool match = FALSE;

+

+        for (cur = group->values; *cur; cur++)

+            if ((*compare)(attr, *cur) == 0) {

                 match = TRUE;

                 break;

             }

         if (!match)

             return FALSE;

     }

-    if (iclass->match_tag) {

+

+    /* All the entries in the list matched the attribute */

+    return TRUE;

+}

+

+/*

+ * Classes without any Match statements match all devices. Otherwise, all

+ * statements must match.

+ */

+static Bool

+InputClassMatches(const XF86ConfInputClassPtr iclass, const IDevPtr idev,

+                  const InputAttributes *attrs)

+{

+    /* MatchProduct substring */

+    if (!MatchAttrToken(attrs->product, &iclass->match_product, match_substring))

+        return FALSE;

+

+    /* MatchVendor substring */

+    if (!MatchAttrToken(attrs->vendor, &iclass->match_vendor, match_substring))

+        return FALSE;

+

+    /* MatchDevicePath pattern */

+    if (!MatchAttrToken(attrs->device, &iclass->match_device, match_path_pattern))

+        return FALSE;

+

+    /* MatchOS case-insensitive string */

+    if (!MatchAttrToken(HostOS(), &iclass->match_os, strcasecmp))

+        return FALSE;

+

+    /* MatchPnPID pattern */

+    if (!MatchAttrToken(attrs->pnp_id, &iclass->match_pnpid, match_pattern))

+        return FALSE;

+

+    /* MatchUSBID pattern */

+    if (!MatchAttrToken(attrs->usb_id, &iclass->match_usbid, match_pattern))

+        return FALSE;

+

+    /* MatchDriver string */

+    if (!MatchAttrToken(idev->driver, &iclass->match_driver, strcmp))

+        return FALSE;

+

+    /*

+     * MatchTag string

+     * See if any of the device's tags match any of the MatchTag tokens.

+     */

+    if (!list_is_empty(&iclass->match_tag)) {

+        char * const *tag;

+        Bool match;

+

         if (!attrs->tags)

             return FALSE;

-

-        for (cur = iclass->match_tag, match = FALSE; *cur && !match; cur++) {

-            char * const *tag;

-            for(tag = attrs->tags; *tag; tag++) {

-                if (!strcmp(*tag, *cur)) {

-                    match = TRUE;

-                    break;

-                }

+        for (tag = attrs->tags, match = FALSE; *tag; tag++) {

+            if (MatchAttrToken(*tag, &iclass->match_tag, strcmp)) {

+                match = TRUE;

+                break;

             }

         }

-

         if (!match)

             return FALSE;

     }

 

+    /* MatchIs* booleans */

     if (iclass->is_keyboard.set &&

         iclass->is_keyboard.val != !!(attrs->flags & ATTR_KEYBOARD))

         return FALSE;

@@ -582,6 +664,7 @@ InputClassMatches(XF86ConfInputClassPtr iclass, InputAttributes *attrs)
     if (iclass->is_touchscreen.set &&

         iclass->is_touchscreen.val != !!(attrs->flags & ATTR_TOUCHSCREEN))

         return FALSE;

+

     return TRUE;

 }

 

@@ -591,37 +674,36 @@ InputClassMatches(XF86ConfInputClassPtr iclass, InputAttributes *attrs)
  * well as any previous InputClass sections.

  */

 static int

-MergeInputClasses(IDevPtr idev, InputAttributes *attrs)

+MergeInputClasses(const IDevPtr idev, const InputAttributes *attrs)

 {

     XF86ConfInputClassPtr cl;

-    XF86OptionPtr classopts, mergedopts = NULL;

-    char *classdriver = NULL;

+    XF86OptionPtr classopts;

 

     for (cl = xf86configptr->conf_inputclass_lst; cl; cl = cl->list.next) {

-        if (!InputClassMatches(cl, attrs))

+        if (!InputClassMatches(cl, idev, attrs))

             continue;

 

-        /* Collect class options and merge over previous classes */

+        /* Collect class options and driver settings */

+        classopts = xf86optionListDup(cl->option_lst);

+        if (cl->driver) {

+            free(idev->driver);

+            idev->driver = xstrdup(cl->driver);

+            if (!idev->driver) {

+                xf86Msg(X_ERROR, "Failed to allocate memory while merging "

+                        "InputClass configuration");

+                return BadAlloc;

+            }

+            classopts = xf86ReplaceStrOption(classopts, "driver",

+                                             idev->driver);

+        }

+

+        /* Apply options to device with InputClass settings preferred. */

         xf86Msg(X_CONFIG, "%s: Applying InputClass \"%s\"\n",

                 idev->identifier, cl->identifier);

-        if (cl->driver)

-            classdriver = cl->driver;

-        classopts = xf86optionListDup(cl->option_lst);

-        mergedopts = xf86optionListMerge(mergedopts, classopts);

+        idev->commonOptions = xf86optionListMerge(idev->commonOptions,

+                                                  classopts);

     }

 

-    /* Apply options to device with InputClass settings preferred. */

-    if (classdriver) {

-        free(idev->driver);

-        idev->driver = xstrdup(classdriver);

-        if (!idev->driver) {

-            xf86Msg(X_ERROR, "Failed to allocate memory while merging "

-                    "InputClass configuration");

-            return BadAlloc;

-        }

-        mergedopts = xf86ReplaceStrOption(mergedopts, "driver", idev->driver);

-    }

-    idev->commonOptions = xf86optionListMerge(idev->commonOptions, mergedopts);

     return Success;

 }

 

@@ -630,14 +712,14 @@ MergeInputClasses(IDevPtr idev, InputAttributes *attrs)
  * value of the last matching class and holler when returning TRUE.

  */

 static Bool

-IgnoreInputClass(IDevPtr idev, InputAttributes *attrs)

+IgnoreInputClass(const IDevPtr idev, const InputAttributes *attrs)

 {

     XF86ConfInputClassPtr cl;

     Bool ignore = FALSE;

     const char *ignore_class;

 

     for (cl = xf86configptr->conf_inputclass_lst; cl; cl = cl->list.next) {

-        if (!InputClassMatches(cl, attrs))

+        if (!InputClassMatches(cl, idev, attrs))

             continue;

         if (xf86findOption(cl->option_lst, "Ignore")) {

             ignore = xf86CheckBoolOption(cl->option_lst, "Ignore", FALSE);

@@ -844,10 +926,8 @@ NewInputDeviceRequest (InputOption *options, InputAttributes *attrs,
 unwind:

     if (is_auto && !xf86Info.autoAddDevices)

         xf86Msg(X_INFO, "AutoAddDevices is off - not adding device.\n");

-    if(idev->driver)

-        free(idev->driver);

-    if(idev->identifier)

-        free(idev->identifier);

+    free(idev->driver);

+    free(idev->identifier);

     xf86optionListFree(idev->commonOptions);

     free(idev);

     return rval;

@@ -1195,7 +1275,7 @@ xf86ScaleAxis(int	Cx,
     if (X < Sxlow)

 	X = Sxlow;

     

-    return (X);

+    return X;

 }

 

 /*

diff --git a/xorg-server/hw/xfree86/common/xf86cmap.c b/xorg-server/hw/xfree86/common/xf86cmap.c
index fa0ebc8eb..851843faa 100644
--- a/xorg-server/hw/xfree86/common/xf86cmap.c
+++ b/xorg-server/hw/xfree86/common/xf86cmap.c
@@ -102,10 +102,11 @@ typedef struct {
   int		overscan;

 } CMapColormapRec, *CMapColormapPtr;

 

-static int CMapScreenKeyIndex;

-static DevPrivateKey CMapScreenKey;

-static int CMapColormapKeyIndex;

-static DevPrivateKey CMapColormapKey = &CMapColormapKeyIndex;

+static DevPrivateKeyRec CMapScreenKeyRec;

+#define CMapScreenKeyRegistered dixPrivateKeyRegistered(&CMapScreenKeyRec)

+#define CMapScreenKey (&CMapScreenKeyRec)

+static DevPrivateKeyRec CMapColormapKeyRec;

+#define CMapColormapKey (&CMapColormapKeyRec)

 

 static void CMapInstallColormap(ColormapPtr);

 static void CMapStoreColors(ColormapPtr, int, xColorItem *);

@@ -128,6 +129,18 @@ static void CMapReinstallMap(ColormapPtr);
 static void CMapUnwrapScreen(ScreenPtr pScreen);

 

 

+Bool xf86ColormapAllocatePrivates(ScrnInfoPtr pScrn)

+{

+    /* If we support a better colormap system, then pretend we succeeded. */

+    if (xf86_crtc_supports_gamma(pScrn))

+	return TRUE;

+    if (!dixRegisterPrivateKey(&CMapScreenKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+

+    if (!dixRegisterPrivateKey(&CMapColormapKeyRec, PRIVATE_COLORMAP, 0))

+	return FALSE;

+    return TRUE;

+}

 

 Bool xf86HandleColormaps(

     ScreenPtr pScreen,

@@ -151,8 +164,6 @@ Bool xf86HandleColormaps(
     if(!maxColors || !sigRGBbits || !loadPalette)

 	return FALSE;

 

-    CMapScreenKey = &CMapScreenKeyIndex;

-

     elements = 1 << sigRGBbits;

 

     if(!(gamma = malloc(elements * sizeof(LOCO))))

@@ -169,7 +180,7 @@ Bool xf86HandleColormaps(
 	return FALSE;     

     }

 

-    dixSetPrivate(&pScreen->devPrivates, CMapScreenKey, pScreenPriv);

+    dixSetPrivate(&pScreen->devPrivates, &CMapScreenKeyRec, pScreenPriv);

      

     pScreenPriv->CloseScreen = pScreen->CloseScreen;

     pScreenPriv->CreateColormap = pScreen->CreateColormap;

@@ -316,7 +327,7 @@ CMapDestroyColormap (ColormapPtr cmap)
     CMapLinkPtr prevLink = NULL, pLink = pScreenPriv->maps;

 

     if(pColPriv) {

-	if(pColPriv->colors) free(pColPriv->colors);

+	free(pColPriv->colors);

 	free(pColPriv);

     }

    

@@ -900,7 +911,7 @@ CMapChangeGamma(
     CMapLinkPtr pLink;

         

     /* Is this sufficient checking ? */

-    if(CMapScreenKey == NULL)

+    if(!CMapScreenKeyRegistered)

 	return BadImplementation;

 

     pScreenPriv = (CMapScreenPtr)dixLookupPrivate(&pScreen->devPrivates,

@@ -1012,7 +1023,7 @@ xf86ChangeGammaRamp(
 	}

     }

 

-    if(CMapScreenKey == NULL)

+    if(!CMapScreenKeyRegistered)

         return BadImplementation;

 

     pScreenPriv = (CMapScreenPtr)dixLookupPrivate(&pScreen->devPrivates,

@@ -1080,7 +1091,7 @@ xf86GetGammaRampSize(ScreenPtr pScreen)
 	    return crtc->gammaSize;

     }

 

-    if(CMapScreenKey == NULL) return 0;

+    if(!CMapScreenKeyRegistered) return 0;

 

     pScreenPriv = (CMapScreenPtr)dixLookupPrivate(&pScreen->devPrivates,

 						  CMapScreenKey);

@@ -1120,7 +1131,7 @@ xf86GetGammaRamp(
 	}

     }

 

-    if(CMapScreenKey == NULL) 

+    if(!CMapScreenKeyRegistered)

 	return BadImplementation;

 

     pScreenPriv = (CMapScreenPtr)dixLookupPrivate(&pScreen->devPrivates,

diff --git a/xorg-server/hw/xfree86/common/xf86cmap.h b/xorg-server/hw/xfree86/common/xf86cmap.h
index f15844e59..caa01e8ed 100644
--- a/xorg-server/hw/xfree86/common/xf86cmap.h
+++ b/xorg-server/hw/xfree86/common/xf86cmap.h
@@ -1,75 +1,79 @@
-
-/*
- * Copyright (c) 1998-2001 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-#ifndef _XF86CMAP_H
-#define _XF86CMAP_H
-
-#include "xf86str.h"
-#include "colormapst.h"
-
-#define CMAP_PALETTED_TRUECOLOR		0x0000001
-#define CMAP_RELOAD_ON_MODE_SWITCH	0x0000002
-#define CMAP_LOAD_EVEN_IF_OFFSCREEN	0x0000004
-
-extern _X_EXPORT Bool xf86HandleColormaps(
-    ScreenPtr pScreen,
-    int maxCol,
-    int sigRGBbits,
-    xf86LoadPaletteProc *loadPalette,
-    xf86SetOverscanProc *setOverscan,
-    unsigned int flags
-);
-
-extern _X_EXPORT int
-xf86ChangeGamma(
-   ScreenPtr pScreen,
-   Gamma newGamma
-);
-
-extern _X_EXPORT int
-xf86ChangeGammaRamp(
-   ScreenPtr pScreen,
-   int size,
-   unsigned short *red,
-   unsigned short *green,
-   unsigned short *blue
-);
-
-extern _X_EXPORT int xf86GetGammaRampSize(ScreenPtr pScreen);
-
-extern _X_EXPORT int
-xf86GetGammaRamp(
-   ScreenPtr pScreen,
-   int size,
-   unsigned short *red,
-   unsigned short *green,
-   unsigned short *blue
-);
-
-#endif /* _XF86CMAP_H */
-
+

+/*

+ * Copyright (c) 1998-2001 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+#ifndef _XF86CMAP_H

+#define _XF86CMAP_H

+

+#include "xf86str.h"

+#include "colormapst.h"

+

+#define CMAP_PALETTED_TRUECOLOR		0x0000001

+#define CMAP_RELOAD_ON_MODE_SWITCH	0x0000002

+#define CMAP_LOAD_EVEN_IF_OFFSCREEN	0x0000004

+

+extern _X_EXPORT Bool xf86HandleColormaps(

+    ScreenPtr pScreen,

+    int maxCol,

+    int sigRGBbits,

+    xf86LoadPaletteProc *loadPalette,

+    xf86SetOverscanProc *setOverscan,

+    unsigned int flags

+);

+

+extern _X_EXPORT Bool xf86ColormapAllocatePrivates(

+    ScrnInfoPtr pScrn

+);

+

+extern _X_EXPORT int

+xf86ChangeGamma(

+   ScreenPtr pScreen,

+   Gamma newGamma

+);

+

+extern _X_EXPORT int

+xf86ChangeGammaRamp(

+   ScreenPtr pScreen,

+   int size,

+   unsigned short *red,

+   unsigned short *green,

+   unsigned short *blue

+);

+

+extern _X_EXPORT int xf86GetGammaRampSize(ScreenPtr pScreen);

+

+extern _X_EXPORT int

+xf86GetGammaRamp(

+   ScreenPtr pScreen,

+   int size,

+   unsigned short *red,

+   unsigned short *green,

+   unsigned short *blue

+);

+

+#endif /* _XF86CMAP_H */

+

diff --git a/xorg-server/hw/xfree86/common/xf86fbman.c b/xorg-server/hw/xfree86/common/xf86fbman.c
index 1ca27015f..ccb761a2c 100644
--- a/xorg-server/hw/xfree86/common/xf86fbman.c
+++ b/xorg-server/hw/xfree86/common/xf86fbman.c
@@ -42,7 +42,7 @@
 #define DEBUG

 */

 

-static int xf86FBManagerKeyIndex;

+static DevPrivateKeyRec xf86FBManagerKeyRec;

 static DevPrivateKey xf86FBManagerKey;

 

 Bool xf86RegisterOffscreenManager(

@@ -50,7 +50,11 @@ Bool xf86RegisterOffscreenManager(
     FBManagerFuncsPtr funcs

 ){

 

-   xf86FBManagerKey = &xf86FBManagerKeyIndex;

+   xf86FBManagerKey = &xf86FBManagerKeyRec;

+

+   if (!dixRegisterPrivateKey(&xf86FBManagerKeyRec, PRIVATE_SCREEN, 0))

+       return FALSE;

+

    dixSetPrivate(&pScreen->devPrivates, xf86FBManagerKey, funcs);

 

    return TRUE;

@@ -60,8 +64,9 @@ Bool xf86RegisterOffscreenManager(
 Bool

 xf86FBManagerRunning(ScreenPtr pScreen)

 {

-    if(xf86FBManagerKey == NULL) 

+    if (xf86FBManagerKey == NULL)

 	return FALSE;

+

     if(!dixLookupPrivate(&pScreen->devPrivates, xf86FBManagerKey))

 	return FALSE;

 

@@ -270,8 +275,8 @@ xf86PurgeUnlockedOffscreenAreas(ScreenPtr pScreen)
 

 \************************************************************/ 

 

-static int xf86FBScreenKeyIndex;

-static DevPrivateKey xf86FBScreenKey = &xf86FBScreenKeyIndex;

+static DevPrivateKeyRec xf86FBScreenKeyRec;

+#define xf86FBScreenKey (&xf86FBScreenKeyRec)

 

 typedef struct _FBLink {

   FBArea area;

@@ -363,8 +368,8 @@ AllocateArea(
 

    if(granularity <= 1) granularity = 0;

 

-   boxp = REGION_RECTS(offman->FreeBoxes);

-   num = REGION_NUM_RECTS(offman->FreeBoxes);

+   boxp = RegionRects(offman->FreeBoxes);

+   num = RegionNumRects(offman->FreeBoxes);

 

    /* look through the free boxes */

    for(i = 0; i < num; i++, boxp++) {

@@ -407,9 +412,9 @@ AllocateArea(
 

 	   /* bye, bye */

 	   (*link->area.RemoveAreaCallback)(&link->area);

-	   REGION_INIT(pScreen, &NewReg, &(link->area.box), 1); 

-	   REGION_UNION(pScreen, offman->FreeBoxes, offman->FreeBoxes, &NewReg);

-	   REGION_UNINIT(pScreen, &NewReg); 

+	   RegionInit(&NewReg, &(link->area.box), 1);

+	   RegionUnion(offman->FreeBoxes, offman->FreeBoxes, &NewReg);

+	   RegionUninit(&NewReg);

 

            area = &(link->area);

 	   break;

@@ -427,9 +432,9 @@ AllocateArea(
 	area->RemoveAreaCallback = removeCB;

 	area->devPrivate.ptr = privData;

 

-        REGION_INIT(pScreen, &NewReg, &(area->box), 1);

-	REGION_SUBTRACT(pScreen, offman->FreeBoxes, offman->FreeBoxes, &NewReg);

-	REGION_UNINIT(pScreen, &NewReg);

+        RegionInit(&NewReg, &(area->box), 1);

+	RegionSubtract(offman->FreeBoxes, offman->FreeBoxes, &NewReg);

+	RegionUninit(&NewReg);

    }

 

    return area;

@@ -477,9 +482,9 @@ localFreeOffscreenArea(FBAreaPtr area)
    }

 

    /* put the area back into the pool */

-   REGION_INIT(pScreen, &FreedRegion, &(pLink->area.box), 1); 

-   REGION_UNION(pScreen, offman->FreeBoxes, offman->FreeBoxes, &FreedRegion);

-   REGION_UNINIT(pScreen, &FreedRegion); 

+   RegionInit(&FreedRegion, &(pLink->area.box), 1);

+   RegionUnion(offman->FreeBoxes, offman->FreeBoxes, &FreedRegion);

+   RegionUninit(&FreedRegion);

 

    if(pLinkPrev)

 	pLinkPrev->next = pLink->next;

@@ -536,12 +541,12 @@ localResizeOffscreenArea(
 	   (resize->box.x2 == OrigArea.x2))

 		return TRUE;

 

-	REGION_INIT(pScreen, &FreedReg, &OrigArea, 1); 

-	REGION_INIT(pScreen, &NewReg, &(resize->box), 1); 

-	REGION_SUBTRACT(pScreen, &FreedReg, &FreedReg, &NewReg);

-	REGION_UNION(pScreen, offman->FreeBoxes, offman->FreeBoxes, &FreedReg);

-	REGION_UNINIT(pScreen, &FreedReg); 

-	REGION_UNINIT(pScreen, &NewReg); 

+	RegionInit(&FreedReg, &OrigArea, 1);

+	RegionInit(&NewReg, &(resize->box), 1);

+	RegionSubtract(&FreedReg, &FreedReg, &NewReg);

+	RegionUnion(offman->FreeBoxes, offman->FreeBoxes, &FreedReg);

+	RegionUninit(&FreedReg);

+	RegionUninit(&NewReg);

 

 	SendCallFreeBoxCallbacks(offman);

 

@@ -551,8 +556,8 @@ localResizeOffscreenArea(
 

    /* otherwise we remove the old region */

 

-   REGION_INIT(pScreen, &FreedReg, &OrigArea, 1); 

-   REGION_UNION(pScreen, offman->FreeBoxes, offman->FreeBoxes, &FreedReg);

+   RegionInit(&FreedReg, &OrigArea, 1);

+   RegionUnion(offman->FreeBoxes, offman->FreeBoxes, &FreedReg);

   

    /* remove the old link */

    if(pLinkPrev)

@@ -589,8 +594,8 @@ localResizeOffscreenArea(
 	offman->NumUsedAreas--;  

    } else {

       /* reinstate the old region */

-      REGION_SUBTRACT(pScreen, offman->FreeBoxes, offman->FreeBoxes, &FreedReg);

-      REGION_UNINIT(pScreen, &FreedReg); 

+      RegionSubtract(offman->FreeBoxes, offman->FreeBoxes, &FreedReg);

+      RegionUninit(&FreedReg);

 

       pLink->next = offman->UsedAreas;

       offman->UsedAreas = pLink;

@@ -598,7 +603,7 @@ localResizeOffscreenArea(
    }

 

 

-   REGION_UNINIT(pScreen, &FreedReg); 

+   RegionUninit(&FreedReg);

 

    SendCallFreeBoxCallbacks(offman);

 

@@ -636,47 +641,47 @@ localQueryLargestOffscreenArea(
 	if(offman->NumUsedAreas) {

 	    FBLinkPtr pLink;

 	    RegionRec tmpRegion;

-	    newRegion = REGION_CREATE(pScreen, NULL, 1);

-	    REGION_COPY(pScreen, newRegion, offman->InitialBoxes);

+	    newRegion = RegionCreate(NULL, 1);

+	    RegionCopy(newRegion, offman->InitialBoxes);

 	    pLink = offman->UsedAreas;

 

 	    while(pLink) {

 		if(!pLink->area.RemoveAreaCallback) {

-		    REGION_INIT(pScreen, &tmpRegion, &(pLink->area.box), 1);

-		    REGION_SUBTRACT(pScreen, newRegion, newRegion, &tmpRegion);

-		    REGION_UNINIT(pScreen, &tmpRegion);

+		    RegionInit(&tmpRegion, &(pLink->area.box), 1);

+		    RegionSubtract(newRegion, newRegion, &tmpRegion);

+		    RegionUninit(&tmpRegion);

 		}

 		pLink = pLink->next;

 	    }

 

-	    nbox = REGION_NUM_RECTS(newRegion);

-	    pbox = REGION_RECTS(newRegion);

+	    nbox = RegionNumRects(newRegion);

+	    pbox = RegionRects(newRegion);

 	    break;

 	}

     case 1:

 	if(offman->NumUsedAreas) {

 	    FBLinkPtr pLink;

 	    RegionRec tmpRegion;

-	    newRegion = REGION_CREATE(pScreen, NULL, 1);

-	    REGION_COPY(pScreen, newRegion, offman->FreeBoxes);

+	    newRegion = RegionCreate(NULL, 1);

+	    RegionCopy(newRegion, offman->FreeBoxes);

 	    pLink = offman->UsedAreas;

 

 	    while(pLink) {

 		if(pLink->area.RemoveAreaCallback) {

-		    REGION_INIT(pScreen, &tmpRegion, &(pLink->area.box), 1);

-		    REGION_APPEND(pScreen, newRegion, &tmpRegion);

-		    REGION_UNINIT(pScreen, &tmpRegion);

+		    RegionInit(&tmpRegion, &(pLink->area.box), 1);

+		    RegionAppend(newRegion, &tmpRegion);

+		    RegionUninit(&tmpRegion);

 		}

 		pLink = pLink->next;

 	    }

 

-	    nbox = REGION_NUM_RECTS(newRegion);

-	    pbox = REGION_RECTS(newRegion);

+	    nbox = RegionNumRects(newRegion);

+	    pbox = RegionRects(newRegion);

 	    break;

 	}

     default:

-	nbox = REGION_NUM_RECTS(offman->FreeBoxes);

-	pbox = REGION_RECTS(offman->FreeBoxes);

+	nbox = RegionNumRects(offman->FreeBoxes);

+	pbox = RegionRects(offman->FreeBoxes);

 	break;

     }

 

@@ -719,7 +724,7 @@ localQueryLargestOffscreenArea(
     }

 

     if(newRegion)

-	REGION_DESTROY(pScreen, newRegion);

+	RegionDestroy(newRegion);

 

     return TRUE;

 }

@@ -741,9 +746,9 @@ localPurgeUnlockedOffscreenAreas(ScreenPtr pScreen)
 	if(pLink->area.RemoveAreaCallback) {

 	    (*pLink->area.RemoveAreaCallback)(&pLink->area);

 

-	    REGION_INIT(pScreen, &FreedRegion, &(pLink->area.box), 1); 

-	    REGION_APPEND(pScreen, offman->FreeBoxes, &FreedRegion);

-	    REGION_UNINIT(pScreen, &FreedRegion); 

+	    RegionInit(&FreedRegion, &(pLink->area.box), 1);

+	    RegionAppend(offman->FreeBoxes, &FreedRegion);

+	    RegionUninit(&FreedRegion);

 

 	    if(pPrev)

 	      pPrev->next = pLink->next;

@@ -761,7 +766,7 @@ localPurgeUnlockedOffscreenAreas(ScreenPtr pScreen)
    }

 

    if(anyUsed) {

-	REGION_VALIDATE(pScreen, offman->FreeBoxes, &anyUsed);

+	RegionValidate(offman->FreeBoxes, &anyUsed);

 	SendCallFreeBoxCallbacks(offman);

    }

 

@@ -924,7 +929,7 @@ localAllocateOffscreenLinear(
      return NULL;

 

    /* No linear available, so try and pinch some from the XY areas */

-   extents = REGION_EXTENTS(pScreen, offman->InitialBoxes);

+   extents = RegionExtents(offman->InitialBoxes);

    pitch = extents->x2 - extents->x1;

 

    if (gran > 1) {

@@ -1055,7 +1060,7 @@ localResizeOffscreenLinear(FBLinearPtr resize, int length)
 	BoxPtr extents;

 	int pitch, w, h;

 

-	extents = REGION_EXTENTS(pScreen, offman->InitialBoxes);

+	extents = RegionExtents(offman->InitialBoxes);

 	pitch = extents->x2 - extents->x1;

 

 	if(length < pitch) { /* special case */

@@ -1121,7 +1126,7 @@ localQueryLargestOffscreenLinear(
 

 	    offman = (FBManagerPtr)dixLookupPrivate(&pScreen->devPrivates,

 						    xf86FBScreenKey);

-	    extents = REGION_EXTENTS(pScreen, offman->InitialBoxes);

+	    extents = RegionExtents(offman->InitialBoxes);

 	    if((extents->x2 - extents->x1) == w)

 	    	*size = w * h;

 	    return TRUE;

@@ -1171,8 +1176,8 @@ xf86FBCloseScreen (int i, ScreenPtr pScreen)
 	free(tmp2);

    }

 

-   REGION_DESTROY(pScreen, offman->InitialBoxes);

-   REGION_DESTROY(pScreen, offman->FreeBoxes);

+   RegionDestroy(offman->InitialBoxes);

+   RegionDestroy(offman->FreeBoxes);

 

    free(offman->FreeBoxesUpdateCallback);

    free(offman->devPrivates);

@@ -1206,15 +1211,15 @@ xf86InitFBManager(
    if (FullBox->y2 < FullBox->y1) return FALSE;

    if (FullBox->x2 < FullBox->x1) return FALSE;

 

-   REGION_INIT(pScreen, &ScreenRegion, &ScreenBox, 1); 

-   REGION_INIT(pScreen, &FullRegion, FullBox, 1); 

+   RegionInit(&ScreenRegion, &ScreenBox, 1);

+   RegionInit(&FullRegion, FullBox, 1);

 

-   REGION_SUBTRACT(pScreen, &FullRegion, &FullRegion, &ScreenRegion);

+   RegionSubtract(&FullRegion, &FullRegion, &ScreenRegion);

 

    ret = xf86InitFBManagerRegion(pScreen, &FullRegion);

 

-   REGION_UNINIT(pScreen, &ScreenRegion);

-   REGION_UNINIT(pScreen, &FullRegion);

+   RegionUninit(&ScreenRegion);

+   RegionUninit(&FullRegion);

     

    return ret;

 }

@@ -1249,17 +1254,17 @@ xf86InitFBManagerArea(
     }

 

     /* Factor out virtual resolution */

-    pRegion = RECTS_TO_REGION(pScreen, nRect, Rect, 0);

+    pRegion = RegionFromRects(nRect, Rect, 0);

     if (pRegion) {

-	if (!REGION_NAR(pRegion)) {

+	if (!RegionNar(pRegion)) {

 	    Rect[2].x = Rect[2].y = 0;

 	    Rect[2].width = pScrn->virtualX;

 	    Rect[2].height = pScrn->virtualY;

 

-	    pScreenRegion = RECTS_TO_REGION(pScreen, 1, &Rect[2], 0);

+	    pScreenRegion = RegionFromRects(1, &Rect[2], 0);

 	    if (pScreenRegion) {

-		if (!REGION_NAR(pScreenRegion)) {

-		    REGION_SUBTRACT(pScreen, pRegion, pRegion, pScreenRegion);

+		if (!RegionNar(pScreenRegion)) {

+		    RegionSubtract(pRegion, pRegion, pScreenRegion);

 

 		    ret = xf86InitFBManagerRegion(pScreen, pRegion);

 

@@ -1301,11 +1306,11 @@ xf86InitFBManagerArea(
 		    }

 		}

 

-		REGION_DESTROY(pScreen, pScreenRegion);

+		RegionDestroy(pScreenRegion);

 	    }

 	}

 

-	REGION_DESTROY(pScreen, pRegion);

+	RegionDestroy(pRegion);

     }

 

     return ret;

@@ -1318,9 +1323,12 @@ xf86InitFBManagerRegion(
 ){

    FBManagerPtr offman;

 

-   if(REGION_NIL(FullRegion))

+   if(RegionNil(FullRegion))

 	return FALSE;

 

+   if (!dixRegisterPrivateKey(&xf86FBScreenKeyRec, PRIVATE_SCREEN, 0))

+       return FALSE;

+

    if(!xf86RegisterOffscreenManager(pScreen, &xf86FBManFuncs))

 	return FALSE;

 

@@ -1332,11 +1340,11 @@ xf86InitFBManagerRegion(
    offman->CloseScreen = pScreen->CloseScreen;

    pScreen->CloseScreen = xf86FBCloseScreen;

 

-   offman->InitialBoxes = REGION_CREATE(pScreen, NULL, 1);

-   offman->FreeBoxes = REGION_CREATE(pScreen, NULL, 1);

+   offman->InitialBoxes = RegionCreate(NULL, 1);

+   offman->FreeBoxes = RegionCreate(NULL, 1);

 

-   REGION_COPY(pScreen, offman->InitialBoxes, FullRegion);

-   REGION_COPY(pScreen, offman->FreeBoxes, FullRegion);

+   RegionCopy(offman->InitialBoxes, FullRegion);

+   RegionCopy(offman->FreeBoxes, FullRegion);

 

    offman->pScreen = pScreen;

    offman->UsedAreas = NULL;

@@ -1415,7 +1423,7 @@ xf86AllocateLinearOffscreenArea (
 

    offman = (FBManagerPtr)dixLookupPrivate(&pScreen->devPrivates,

 					   xf86FBScreenKey);

-   extents = REGION_EXTENTS(pScreen, offman->InitialBoxes);

+   extents = RegionExtents(offman->InitialBoxes);

    w = extents->x2 - extents->x1;

 

    if (gran > 1) {

diff --git a/xorg-server/hw/xfree86/common/xf86pciBus.c b/xorg-server/hw/xfree86/common/xf86pciBus.c
index 8d968dc39..461c7c235 100644
--- a/xorg-server/hw/xfree86/common/xf86pciBus.c
+++ b/xorg-server/hw/xfree86/common/xf86pciBus.c
@@ -465,7 +465,7 @@ xf86PciAddMatchingDev(DriverPtr drvp)
 

     pci_iterator_destroy(iter);

 

-    return (numFound != 0);

+    return numFound != 0;

 }

 

 Bool

@@ -1294,7 +1294,11 @@ matchDriverFromFiles (char** matches, uint16_t match_vendor, uint16_t match_chip
 }

 #endif /* __linux__ */

 

-void

+/**

+ *  @return The numbers of found devices that match with the current system

+ *  drivers.

+ */

+int

 xf86PciMatchDriver(char* matches[], int nmatches) {

     int i;

     struct pci_device * info = NULL;

@@ -1326,4 +1330,6 @@ xf86PciMatchDriver(char* matches[], int nmatches) {
     if ((info != NULL) && (i < nmatches)) {

 	i += videoPtrToDriverList(info, &(matches[i]), nmatches - i);

     }

+

+    return i;

 }

diff --git a/xorg-server/hw/xfree86/common/xf86pciBus.h b/xorg-server/hw/xfree86/common/xf86pciBus.h
index c8a2eebdd..bcbb8b822 100644
--- a/xorg-server/hw/xfree86/common/xf86pciBus.h
+++ b/xorg-server/hw/xfree86/common/xf86pciBus.h
@@ -37,6 +37,6 @@ void xf86PciProbe(void);
 Bool xf86PciAddMatchingDev(DriverPtr drvp);

 Bool xf86PciProbeDev(DriverPtr drvp);

 void xf86PciIsolateDevice(char *argument);

-void xf86PciMatchDriver(char* matches[], int nmatches);

+int xf86PciMatchDriver(char* matches[], int nmatches);

 

 #endif /* _XF86_PCI_BUS_H */

diff --git a/xorg-server/hw/xfree86/common/xf86sbusBus.c b/xorg-server/hw/xfree86/common/xf86sbusBus.c
index 8df3a6c7a..51e7894db 100644
--- a/xorg-server/hw/xfree86/common/xf86sbusBus.c
+++ b/xorg-server/hw/xfree86/common/xf86sbusBus.c
@@ -478,8 +478,7 @@ xf86MatchSbusInstances(const char *driverName, int sbusDevId,
 	    instances[i].claimed = TRUE;

 	    instances[i].dev = dev;

 	}

-	if (promPath)

-	    free(promPath);

+	free(promPath);

     }

 

     DebugF("%s instances found: %d\n", driverName, numClaimedInstances);

@@ -531,7 +530,7 @@ xf86GetSbusInfoForEntity(int entityIndex)
 

     for (psdpp = xf86SbusInfo; *psdpp != NULL; psdpp++) {

 	if (p->bus.id.sbus.fbNum == (*psdpp)->fbNum)

-	    return (*psdpp);

+	    return *psdpp;

     }

     return NULL;

 }

diff --git a/xorg-server/hw/xfree86/common/xf86xv.c b/xorg-server/hw/xfree86/common/xf86xv.c
index e35b8d667..6dae62717 100644
--- a/xorg-server/hw/xfree86/common/xf86xv.c
+++ b/xorg-server/hw/xfree86/common/xf86xv.c
@@ -110,10 +110,11 @@ static void xf86XVAdjustFrame(int index, int x, int y, int flags);
 static Bool xf86XVInitAdaptors(ScreenPtr, XF86VideoAdaptorPtr*, int);

 

 

-static int XF86XVWindowKeyIndex;

-static DevPrivateKey XF86XVWindowKey = &XF86XVWindowKeyIndex;

-static int XF86XvScreenKeyIndex;

-DevPrivateKey XF86XvScreenKey = &XF86XvScreenKeyIndex;

+static DevPrivateKeyRec XF86XVWindowKeyRec;

+#define XF86XVWindowKey (&XF86XVWindowKeyRec)

+

+DevPrivateKey XF86XvScreenKey;

+

 static unsigned long PortResource = 0;

 

 DevPrivateKey (*XvGetScreenKeyProc)(void) = NULL;

@@ -186,8 +187,8 @@ typedef struct {
    int num;

 } OffscreenImageRec;

 

-static int OffscreenPrivateKeyIndex;

-static DevPrivateKey OffscreenPrivateKey = &OffscreenPrivateKeyIndex;

+static DevPrivateKeyRec OffscreenPrivateKeyRec;

+#define OffscreenPrivateKey (&OffscreenPrivateKeyRec)

 #define GetOffscreenImage(pScreen) ((OffscreenImageRec *) dixLookupPrivate(&(pScreen)->devPrivates, OffscreenPrivateKey))

 

 Bool

@@ -198,9 +199,9 @@ xf86XVRegisterOffscreenImages(
 ){

     OffscreenImageRec *OffscreenImage;

     /* This function may be called before xf86XVScreenInit, so there's

-     * no better place than this to call dixRequestPrivate to ensure we

+     * no better place than this to call dixRegisterPrivateKey to ensure we

      * have space reserved. After the first call it is a no-op. */

-    if(!dixRequestPrivate(OffscreenPrivateKey, sizeof(OffscreenImageRec)) ||

+    if(!dixRegisterPrivateKey(OffscreenPrivateKey, PRIVATE_SCREEN, sizeof(OffscreenImageRec)) ||

        !(OffscreenImage = GetOffscreenImage(pScreen)))

         /* Every X.org driver assumes this function always succeeds, so

          * just die on allocation failure. */

@@ -251,7 +252,11 @@ xf86XVScreenInit(
 

   if(Success != (*XvScreenInitProc)(pScreen)) return FALSE;

 

+  if (!dixRegisterPrivateKey(&XF86XVWindowKeyRec, PRIVATE_WINDOW, 0))

+      return FALSE;

+

   XF86XvScreenKey = (*XvGetScreenKeyProc)();

+

   PortResource = (*XvGetRTPortProc)();

 

   pxvs = GET_XV_SCREEN(pScreen);

@@ -322,9 +327,9 @@ xf86XVFreeAdaptor(XvAdaptorPtr pAdaptor)
 	  pPriv = (XvPortRecPrivatePtr)pPort->devPriv.ptr;

 	  if(pPriv) {

 	     if(pPriv->clientClip)

-		REGION_DESTROY(pAdaptor->pScreen, pPriv->clientClip);

+		RegionDestroy(pPriv->clientClip);

 	     if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-		REGION_DESTROY(pAdaptor->pScreen, pPriv->pCompositeClip);

+		RegionDestroy(pPriv->pCompositeClip);

 	     free(pPriv);

 	  }

       }

@@ -636,14 +641,12 @@ xf86XVUpdateCompositeClip(XvPortRecPrivatePtr portPriv)
 {

    RegionPtr	pregWin, pCompositeClip;

    WindowPtr	pWin;

-   ScreenPtr	pScreen;

    Bool		freeCompClip = FALSE;

 

    if(portPriv->pCompositeClip)

 	return;

 

    pWin = (WindowPtr)portPriv->pDraw;

-   pScreen = pWin->drawable.pScreen;

 

    /* get window clip list */

    if(portPriv->subWindowMode == IncludeInferiors) {

@@ -658,18 +661,18 @@ xf86XVUpdateCompositeClip(XvPortRecPrivatePtr portPriv)
 	return;

    }

 

-   pCompositeClip = REGION_CREATE(pScreen, NullBox, 1);

-   REGION_COPY(pScreen, pCompositeClip, portPriv->clientClip);

-   REGION_TRANSLATE(pScreen, pCompositeClip,

+   pCompositeClip = RegionCreate(NullBox, 1);

+   RegionCopy(pCompositeClip, portPriv->clientClip);

+   RegionTranslate(pCompositeClip,

 			portPriv->pDraw->x + portPriv->clipOrg.x,

 			portPriv->pDraw->y + portPriv->clipOrg.y);

-   REGION_INTERSECT(pScreen, pCompositeClip, pregWin, pCompositeClip);

+   RegionIntersect(pCompositeClip, pregWin, pCompositeClip);

 

    portPriv->pCompositeClip = pCompositeClip;

    portPriv->FreeCompositeClip = TRUE;

 

    if(freeCompClip) {

-	REGION_DESTROY(pScreen, pregWin);

+	RegionDestroy(pregWin);

    }

 }

 

@@ -684,17 +687,17 @@ xf86XVCopyClip(
     /* copy the new clip if it exists */

     if((pGC->clientClipType == CT_REGION) && pGC->clientClip) {

 	if(!portPriv->clientClip)

-	    portPriv->clientClip = REGION_CREATE(pScreen, NullBox, 1);

+	    portPriv->clientClip = RegionCreate(NullBox, 1);

 	/* Note: this is in window coordinates */

-	REGION_COPY(pScreen, portPriv->clientClip, pGC->clientClip);

+	RegionCopy(portPriv->clientClip, pGC->clientClip);

     } else if(portPriv->clientClip) { /* free the old clientClip */

-	REGION_DESTROY(pScreen, portPriv->clientClip);

+	RegionDestroy(portPriv->clientClip);

 	portPriv->clientClip = NULL;

     }

 

     /* get rid of the old clip list */

     if(portPriv->pCompositeClip && portPriv->FreeCompositeClip) {

-	REGION_DESTROY(pScreen, portPriv->pCompositeClip);

+	RegionDestroy(portPriv->pCompositeClip);

     }

 

     portPriv->clipOrg = pGC->clipOrg;

@@ -709,11 +712,9 @@ xf86XVRegetVideo(XvPortRecPrivatePtr portPriv)
   RegionRec WinRegion;

   RegionRec ClipRegion;

   BoxRec WinBox;

-  ScreenPtr pScreen;

   int ret = Success;

   Bool clippedAway = FALSE;

 

-  pScreen = portPriv->pDraw->pScreen;

   xf86XVUpdateCompositeClip(portPriv);

 

   /* translate the video region to the screen */

@@ -723,18 +724,18 @@ xf86XVRegetVideo(XvPortRecPrivatePtr portPriv)
   WinBox.y2 = WinBox.y1 + portPriv->drw_h;

 

   /* clip to the window composite clip */

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_NULL(pScreen, &ClipRegion);

-  REGION_INTERSECT(pScreen, &ClipRegion, &WinRegion, portPriv->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionNull(&ClipRegion);

+  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);

 

   /* that's all if it's totally obscured */

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

 	clippedAway = TRUE;

 	goto CLIP_VIDEO_BAILOUT;

   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->GetVideo)(portPriv->pScrn,

@@ -760,8 +761,8 @@ CLIP_VIDEO_BAILOUT:
   if(!portPriv->FreeCompositeClip)

      portPriv->pCompositeClip = NULL;

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -773,12 +774,9 @@ xf86XVReputVideo(XvPortRecPrivatePtr portPriv)
   RegionRec WinRegion;

   RegionRec ClipRegion;

   BoxRec WinBox;

-  ScreenPtr pScreen;

   int ret = Success;

   Bool clippedAway = FALSE;

 

-  pScreen = portPriv->pDraw->pScreen;

-

   xf86XVUpdateCompositeClip(portPriv);

 

   /* translate the video region to the screen */

@@ -788,9 +786,9 @@ xf86XVReputVideo(XvPortRecPrivatePtr portPriv)
   WinBox.y2 = WinBox.y1 + portPriv->drw_h;

 

   /* clip to the window composite clip */

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_NULL(pScreen, &ClipRegion);

-  REGION_INTERSECT(pScreen, &ClipRegion, &WinRegion, portPriv->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionNull(&ClipRegion);

+  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);

 

   /* clip and translate to the viewport */

   if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

@@ -802,21 +800,21 @@ xf86XVReputVideo(XvPortRecPrivatePtr portPriv)
      VPBox.x2 = portPriv->pScrn->frameX1 + 1;

      VPBox.y2 = portPriv->pScrn->frameY1 + 1;

 

-     REGION_INIT(pScreen, &VPReg, &VPBox, 1);

-     REGION_INTERSECT(pScreen, &ClipRegion, &ClipRegion, &VPReg);

-     REGION_UNINIT(pScreen, &VPReg);

+     RegionInit(&VPReg, &VPBox, 1);

+     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

+     RegionUninit(&VPReg);

   }

 

   /* that's all if it's totally obscured */

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

 	clippedAway = TRUE;

 	goto CLIP_VIDEO_BAILOUT;

   }

 

   /* bailout if we have to clip but the hardware doesn't support it */

   if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = REGION_RECTS(&ClipRegion);

-     if(  (REGION_NUM_RECTS(&ClipRegion) != 1) ||

+     BoxPtr clipBox = RegionRects(&ClipRegion);

+     if(  (RegionNumRects(&ClipRegion) != 1) ||

 	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

 	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

      {

@@ -826,7 +824,7 @@ xf86XVReputVideo(XvPortRecPrivatePtr portPriv)
   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->PutVideo)(portPriv->pScrn,

@@ -851,8 +849,8 @@ CLIP_VIDEO_BAILOUT:
   if(!portPriv->FreeCompositeClip)

      portPriv->pCompositeClip = NULL;

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -863,12 +861,9 @@ xf86XVReputImage(XvPortRecPrivatePtr portPriv)
   RegionRec WinRegion;

   RegionRec ClipRegion;

   BoxRec WinBox;

-  ScreenPtr pScreen;

   int ret = Success;

   Bool clippedAway = FALSE;

 

-  pScreen = portPriv->pDraw->pScreen;

-

   xf86XVUpdateCompositeClip(portPriv);

 

   /* translate the video region to the screen */

@@ -878,9 +873,9 @@ xf86XVReputImage(XvPortRecPrivatePtr portPriv)
   WinBox.y2 = WinBox.y1 + portPriv->drw_h;

 

   /* clip to the window composite clip */

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_NULL(pScreen, &ClipRegion);

-  REGION_INTERSECT(pScreen, &ClipRegion, &WinRegion, portPriv->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionNull(&ClipRegion);

+  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);

 

   /* clip and translate to the viewport */

   if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

@@ -892,21 +887,21 @@ xf86XVReputImage(XvPortRecPrivatePtr portPriv)
      VPBox.x2 = portPriv->pScrn->frameX1 + 1;

      VPBox.y2 = portPriv->pScrn->frameY1 + 1;

 

-     REGION_INIT(pScreen, &VPReg, &VPBox, 1);

-     REGION_INTERSECT(pScreen, &ClipRegion, &ClipRegion, &VPReg);

-     REGION_UNINIT(pScreen, &VPReg);

+     RegionInit(&VPReg, &VPBox, 1);

+     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

+     RegionUninit(&VPReg);

   }

 

   /* that's all if it's totally obscured */

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

 	clippedAway = TRUE;

 	goto CLIP_VIDEO_BAILOUT;

   }

 

   /* bailout if we have to clip but the hardware doesn't support it */

   if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = REGION_RECTS(&ClipRegion);

-     if(  (REGION_NUM_RECTS(&ClipRegion) != 1) ||

+     BoxPtr clipBox = RegionRects(&ClipRegion);

+     if(  (RegionNumRects(&ClipRegion) != 1) ||

 	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

 	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

      {

@@ -916,7 +911,7 @@ xf86XVReputImage(XvPortRecPrivatePtr portPriv)
   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->ReputImage)(portPriv->pScrn,

@@ -938,8 +933,8 @@ CLIP_VIDEO_BAILOUT:
   if(!portPriv->FreeCompositeClip)

      portPriv->pCompositeClip = NULL;

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -1060,7 +1055,7 @@ xf86XVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
   XvPortRecPrivatePtr pPriv;

   Bool AreasExposed;

 

-  AreasExposed = (WinPriv && reg1 && REGION_NOTEMPTY(pScreen, reg1));

+  AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));

 

   pScreen->WindowExposures = ScreenPriv->WindowExposures;

   (*pScreen->WindowExposures)(pWin, reg1, reg2);

@@ -1131,7 +1126,7 @@ xf86XVClipNotify(WindowPtr pWin, int dx, int dy)
      if(!pPriv) goto next;

  

      if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-	REGION_DESTROY(pScreen, pPriv->pCompositeClip);

+	RegionDestroy(pPriv->pCompositeClip);

 

      pPriv->pCompositeClip = NULL;

 

@@ -1225,7 +1220,7 @@ xf86XVQueryAdaptors(
   *p_nAdaptors = pxvs->nAdaptors;

   *p_pAdaptors = pxvs->pAdaptors;

 

-  return (Success);

+  return Success;

 }

 

 

@@ -1268,7 +1263,7 @@ xf86XVLeaveVT(int index, int flags)
 		pPriv->isOn = XV_OFF;

 

 		if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-		    REGION_DESTROY(pScreen, pPriv->pCompositeClip);

+		    RegionDestroy(pPriv->pCompositeClip);

 

 		pPriv->pCompositeClip = NULL;

 

@@ -1309,7 +1304,7 @@ xf86XVAdjustFrame(int index, int x, int y, int flags)
 	if(!pPriv->type && (pPriv->isOn != XV_OFF)) { /* overlaid still/image */

 

 	  if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-	     REGION_DESTROY(pScreen, pPriv->pCompositeClip);

+	     RegionDestroy(pPriv->pCompositeClip);

 

 	  pPriv->pCompositeClip = NULL;

 

@@ -1413,7 +1408,6 @@ xf86XVPutStill(
    CARD16 drw_w, CARD16 drw_h

 ){

   XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-  ScreenPtr pScreen;

   RegionRec WinRegion;

   RegionRec ClipRegion;

   BoxRec WinBox;

@@ -1425,16 +1419,14 @@ xf86XVPutStill(
 

   if(!portPriv->pScrn->vtSema) return Success; /* Success ? */

 

-  pScreen = pDraw->pScreen;

-

   WinBox.x1 = pDraw->x + drw_x;

   WinBox.y1 = pDraw->y + drw_y;

   WinBox.x2 = WinBox.x1 + drw_w;

   WinBox.y2 = WinBox.y1 + drw_h;

 

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_NULL(pScreen, &ClipRegion);

-  REGION_INTERSECT(pScreen, &ClipRegion, &WinRegion, pGC->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionNull(&ClipRegion);

+  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);

 

   if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

      RegionRec VPReg;

@@ -1445,23 +1437,23 @@ xf86XVPutStill(
      VPBox.x2 = portPriv->pScrn->frameX1 + 1;

      VPBox.y2 = portPriv->pScrn->frameY1 + 1;

 

-     REGION_INIT(pScreen, &VPReg, &VPBox, 1);

-     REGION_INTERSECT(pScreen, &ClipRegion, &ClipRegion, &VPReg);

-     REGION_UNINIT(pScreen, &VPReg);

+     RegionInit(&VPReg, &VPBox, 1);

+     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

+     RegionUninit(&VPReg);

   }

 

   if(portPriv->pDraw) {

      xf86XVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

   }

 

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

      clippedAway = TRUE;

      goto PUT_STILL_BAILOUT;

   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = REGION_RECTS(&ClipRegion);

-     if(  (REGION_NUM_RECTS(&ClipRegion) != 1) ||

+     BoxPtr clipBox = RegionRects(&ClipRegion);

+     if(  (RegionNumRects(&ClipRegion) != 1) ||

 	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

 	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

      {

@@ -1471,7 +1463,7 @@ xf86XVPutStill(
   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->PutStill)(portPriv->pScrn,

@@ -1500,8 +1492,8 @@ PUT_STILL_BAILOUT:
 	portPriv->isOn = XV_PENDING;

   }

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -1565,7 +1557,6 @@ xf86XVGetStill(
    CARD16 drw_w, CARD16 drw_h

 ){

   XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-  ScreenPtr pScreen;

   RegionRec WinRegion;

   RegionRec ClipRegion;

   BoxRec WinBox;

@@ -1577,28 +1568,26 @@ xf86XVGetStill(
 

   if(!portPriv->pScrn->vtSema) return Success; /* Success ? */

 

-  pScreen = pDraw->pScreen;

-

   WinBox.x1 = pDraw->x + drw_x;

   WinBox.y1 = pDraw->y + drw_y;

   WinBox.x2 = WinBox.x1 + drw_w;

   WinBox.y2 = WinBox.y1 + drw_h;

 

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_NULL(pScreen, &ClipRegion);

-  REGION_INTERSECT(pScreen, &ClipRegion, &WinRegion, pGC->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionNull(&ClipRegion);

+  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);

 

   if(portPriv->pDraw) {

      xf86XVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

   }

 

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

      clippedAway = TRUE;

      goto GET_STILL_BAILOUT;

   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->GetStill)(portPriv->pScrn,

@@ -1615,8 +1604,8 @@ GET_STILL_BAILOUT:
 	portPriv->isOn = XV_PENDING;

   }

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -1713,7 +1702,6 @@ xf86XVPutImage(
    CARD16 width, CARD16 height

 ){

   XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-  ScreenPtr pScreen;

   RegionRec WinRegion;

   RegionRec ClipRegion;

   BoxRec WinBox;

@@ -1725,16 +1713,14 @@ xf86XVPutImage(
 

   if(!portPriv->pScrn->vtSema) return Success; /* Success ? */

 

-  pScreen = pDraw->pScreen;

-

   WinBox.x1 = pDraw->x + drw_x;

   WinBox.y1 = pDraw->y + drw_y;

   WinBox.x2 = WinBox.x1 + drw_w;

   WinBox.y2 = WinBox.y1 + drw_h;

 

-  REGION_INIT(pScreen, &WinRegion, &WinBox, 1);

-  REGION_NULL(pScreen, &ClipRegion);

-  REGION_INTERSECT(pScreen, &ClipRegion, &WinRegion, pGC->pCompositeClip);

+  RegionInit(&WinRegion, &WinBox, 1);

+  RegionNull(&ClipRegion);

+  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);

 

   if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

      RegionRec VPReg;

@@ -1745,9 +1731,9 @@ xf86XVPutImage(
      VPBox.x2 = portPriv->pScrn->frameX1 + 1;

      VPBox.y2 = portPriv->pScrn->frameY1 + 1;

 

-     REGION_INIT(pScreen, &VPReg, &VPBox, 1);

-     REGION_INTERSECT(pScreen, &ClipRegion, &ClipRegion, &VPReg);

-     REGION_UNINIT(pScreen, &VPReg);

+     RegionInit(&VPReg, &VPBox, 1);

+     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

+     RegionUninit(&VPReg);

   }

 

   /* If we are changing windows, unregister our port in the old window */

@@ -1758,14 +1744,14 @@ xf86XVPutImage(
   ret =  xf86XVEnlistPortInWindow((WindowPtr)pDraw, portPriv);

   if(ret != Success) goto PUT_IMAGE_BAILOUT;

 

-  if(!REGION_NOTEMPTY(pScreen, &ClipRegion)) {

+  if(!RegionNotEmpty(&ClipRegion)) {

      clippedAway = TRUE;

      goto PUT_IMAGE_BAILOUT;

   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = REGION_RECTS(&ClipRegion);

-     if(  (REGION_NUM_RECTS(&ClipRegion) != 1) ||

+     BoxPtr clipBox = RegionRects(&ClipRegion);

+     if(  (RegionNumRects(&ClipRegion) != 1) ||

 	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

 	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

      {

@@ -1775,7 +1761,7 @@ xf86XVPutImage(
   }

 

   if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     REGION_SUBTRACT(pScreen, &ClipRegion, &WinRegion, &ClipRegion);

+     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

   }

 

   ret = (*portPriv->AdaptorRec->PutImage)(portPriv->pScrn,

@@ -1803,8 +1789,8 @@ PUT_IMAGE_BAILOUT:
 	portPriv->isOn = XV_PENDING;

   }

 

-  REGION_UNINIT(pScreen, &WinRegion);

-  REGION_UNINIT(pScreen, &ClipRegion);

+  RegionUninit(&WinRegion);

+  RegionUninit(&ClipRegion);

 

   return ret;

 }

@@ -1834,8 +1820,8 @@ xf86XVFillKeyHelperDrawable (DrawablePtr pDraw, CARD32 key, RegionPtr clipboxes)
    WindowPtr pWin = (WindowPtr)pDraw;

    XF86XVWindowPtr pPriv = GET_XF86XV_WINDOW(pWin);

    GCPtr pGC = NULL;

-   BoxPtr pbox = REGION_RECTS(clipboxes);

-   int i, nbox = REGION_NUM_RECTS(clipboxes);

+   BoxPtr pbox = RegionRects(clipboxes);

+   int i, nbox = RegionNumRects(clipboxes);

    xRectangle *rects;

 

    if(!xf86Screens[pScreen->myNum]->vtSema) return;

@@ -1860,7 +1846,7 @@ xf86XVFillKeyHelperDrawable (DrawablePtr pDraw, CARD32 key, RegionPtr clipboxes)
        ValidateGC(pDraw, pGC);

    }

 

-   REGION_TRANSLATE(pDraw->pScreen, clipboxes, -pDraw->x, -pDraw->y);

+   RegionTranslate(clipboxes, -pDraw->x, -pDraw->y);

 

    rects = malloc(nbox * sizeof(xRectangle));

 

@@ -1881,10 +1867,10 @@ xf86XVFillKeyHelperDrawable (DrawablePtr pDraw, CARD32 key, RegionPtr clipboxes)
 void

 xf86XVFillKeyHelper (ScreenPtr pScreen, CARD32 key, RegionPtr clipboxes)

 {

-   DrawablePtr root = &WindowTable[pScreen->myNum]->drawable;

+   DrawablePtr root = &pScreen->root->drawable;

    ChangeGCVal pval[2];

-   BoxPtr pbox = REGION_RECTS(clipboxes);

-   int i, nbox = REGION_NUM_RECTS(clipboxes);

+   BoxPtr pbox = RegionRects(clipboxes);

+   int i, nbox = RegionNumRects(clipboxes);

    xRectangle *rects;

    GCPtr gc;

 

@@ -1921,8 +1907,6 @@ xf86XVFillKeyHelper (ScreenPtr pScreen, CARD32 key, RegionPtr clipboxes)
    boundaries in 16.16 fixed point.

 */

 

-#define DummyScreen screenInfo.screens[0]

-

 Bool

 xf86XVClipVideoHelper(

     BoxPtr dst,

@@ -1936,7 +1920,7 @@ xf86XVClipVideoHelper(
 ){

     double xsw, xdw, ysw, ydw;

     INT32 delta;

-    BoxPtr extents = REGION_EXTENTS(DummyScreen, reg);

+    BoxPtr extents = RegionExtents(reg);

     int diff;

 

     xsw = (*xb - *xa) << 16;

@@ -1998,9 +1982,9 @@ xf86XVClipVideoHelper(
 	(dst->y1 > extents->y1) || (dst->y2 < extents->y2))

     {

 	RegionRec clipReg;

-	REGION_INIT(DummyScreen, &clipReg, dst, 1);

-	REGION_INTERSECT(DummyScreen, reg, reg, &clipReg);

-	REGION_UNINIT(DummyScreen, &clipReg);

+	RegionInit(&clipReg, dst, 1);

+	RegionIntersect(reg, reg, &clipReg);

+	RegionUninit(&clipReg);

     }

     return TRUE;

 }

diff --git a/xorg-server/hw/xfree86/common/xf86xvmc.c b/xorg-server/hw/xfree86/common/xf86xvmc.c
index 9cf36f526..5a7f69d8a 100644
--- a/xorg-server/hw/xfree86/common/xf86xvmc.c
+++ b/xorg-server/hw/xfree86/common/xf86xvmc.c
@@ -55,8 +55,8 @@ typedef struct {
   XvMCAdaptorPtr dixinfo;

 } xf86XvMCScreenRec, *xf86XvMCScreenPtr;

 

-static int XF86XvMCScreenKeyIndex;

-static DevPrivateKey XF86XvMCScreenKey = &XF86XvMCScreenKeyIndex;

+static DevPrivateKeyRec XF86XvMCScreenKeyRec;

+#define XF86XvMCScreenKey (&XF86XvMCScreenKeyRec)

 

 #define XF86XVMC_GET_PRIVATE(pScreen) (xf86XvMCScreenPtr) \

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

@@ -172,6 +172,9 @@ Bool xf86XvMCScreenInit(
    if(!(pAdapt = malloc(sizeof(XvMCAdaptorRec) * num_adaptors)))

 	return FALSE;

 

+   if (!dixRegisterPrivateKey(&XF86XvMCScreenKeyRec, PRIVATE_SCREEN, 0))

+       return FALSE;

+

    if(!(pScreenPriv = malloc(sizeof(xf86XvMCScreenRec)))) {

 	free(pAdapt);

 	return FALSE;

diff --git a/xorg-server/hw/xfree86/common/xisb.c b/xorg-server/hw/xfree86/common/xisb.c
index f08327fb3..287a98b53 100644
--- a/xorg-server/hw/xfree86/common/xisb.c
+++ b/xorg-server/hw/xfree86/common/xisb.c
@@ -69,12 +69,12 @@ XisbNew (int fd, ssize_t size)
 

 	b = malloc(sizeof (XISBuffer));

 	if (!b)

-		return (NULL);

+		return NULL;

 	b->buf = malloc((sizeof (unsigned char) * size));

 	if (!b->buf)

 	{

 		free(b);

-		return (NULL);

+		return NULL;

 	}

 

 	b->fd = fd;

@@ -83,7 +83,7 @@ XisbNew (int fd, ssize_t size)
 	b->current = 1;	/* force it to be past the end to trigger initial read */

 	b->end = 0;

 	b->buffer_size = size;

-	return (b);

+	return b;

 }

 

 void

@@ -103,7 +103,7 @@ XisbRead (XISBuffer *b)
 		if (b->block_duration >= 0)

 		{

 			if (xf86WaitForInput (b->fd, b->block_duration) < 1)

-				return (-1);

+				return -1;

 		}

 		else

 		{

@@ -119,9 +119,9 @@ XisbRead (XISBuffer *b)
 		switch (ret)

 		{

 			case 0:

-				return (-1); /* timeout */

+				return -1; /* timeout */

 			case -1:

-				return (-2); /* error */

+				return -2; /* error */

 			default:

 				b->end = ret;

 				b->current = 0;

@@ -132,7 +132,7 @@ XisbRead (XISBuffer *b)
 		ErrorF ("read 0x%02x (%c)\n", b->buf[b->current], 

 			isprint(b->buf[b->current])?b->buf[b->current]:'.');

 

-	return (b->buf[b->current++]);

+	return b->buf[b->current++];

 }

 

 /* the only purpose of this function is to provide output tracing */

diff --git a/xorg-server/hw/xfree86/ddc/ddc.c b/xorg-server/hw/xfree86/ddc/ddc.c
index ec6465818..3b70ce508 100644
--- a/xorg-server/hw/xfree86/ddc/ddc.c
+++ b/xorg-server/hw/xfree86/ddc/ddc.c
@@ -53,8 +53,8 @@ find_start(unsigned int *ptr)
 	}

     }

     for (i=0;i<9;i++)

-	if (test[i]) return (i+1);

-    return (-1);

+	if (test[i]) return i+1;

+    return -1;

 }

 

 static unsigned char *

@@ -75,8 +75,8 @@ find_header(unsigned char *block)
 	if (i==8) break;

 	ptr++; 

     }

-    if (ptr == end) return (NULL);

-    return (ptr);

+    if (ptr == end) return NULL;

+    return ptr;

 }

 

 static unsigned char *

@@ -98,7 +98,7 @@ resort(unsigned char *s_block)
 	if (s_ptr == s_end) s_ptr = s_block;

     }

     free(s_block);

-    return (d_new);

+    return d_new;

 }

 

 static int

@@ -120,7 +120,7 @@ DDC_checksum(unsigned char *block, int len)
     /* catch the trivial case where all bytes are 0 */

     if (!not_null) return 1;

 

-    return (result&0xFF);

+    return result&0xFF;

 }

 

 static unsigned char *

@@ -169,7 +169,7 @@ FetchEDID_DDC1(register ScrnInfoPtr pScrn,
 	*xp = read_DDC(pScrn);

 	xp++;

     } while(--count);

-    return (ptr);

+    return ptr;

 }

 

 /* test if DDC1  return 0 if not */

@@ -184,7 +184,7 @@ TestDDC1(ScrnInfoPtr pScrn, unsigned int (*read_DDC)(ScrnInfoPtr))
 	/* wait for next retrace */

 	if (old != read_DDC(pScrn)) break;

     } while(count--);

-    return (count);

+    return count;

 }

 

 /* 

diff --git a/xorg-server/hw/xfree86/ddc/interpret_edid.c b/xorg-server/hw/xfree86/ddc/interpret_edid.c
index 1a2d2f487..7558206cc 100644
--- a/xorg-server/hw/xfree86/ddc/interpret_edid.c
+++ b/xorg-server/hw/xfree86/ddc/interpret_edid.c
@@ -183,7 +183,7 @@ xf86InterpretEDID(int scrnIndex, Uchar *block)
     handle_edid_quirks(m);

     encode_aspect_ratio(m);

 

-    return (m);

+    return m;

 

  error:

     free(m);

diff --git a/xorg-server/hw/xfree86/dixmods/extmod/xf86dga2.c b/xorg-server/hw/xfree86/dixmods/extmod/xf86dga2.c
index 0b7d62dca..453ade80b 100644
--- a/xorg-server/hw/xfree86/dixmods/extmod/xf86dga2.c
+++ b/xorg-server/hw/xfree86/dixmods/extmod/xf86dga2.c
@@ -61,10 +61,11 @@ unsigned char DGAReqCode = 0;
 int DGAErrorBase;

 int DGAEventBase;

 

-static int DGAScreenPrivateKeyIndex;

-static DevPrivateKey DGAScreenPrivateKey = &DGAScreenPrivateKeyIndex;

-static int DGAClientPrivateKeyIndex;

-static DevPrivateKey DGAClientPrivateKey = &DGAClientPrivateKeyIndex;

+static DevPrivateKeyRec DGAScreenPrivateKeyRec;

+#define DGAScreenPrivateKey (&DGAScreenPrivateKeyRec)

+#define DGAScreenPrivateKeyRegistered (DGAScreenPrivateKeyRec.initialized)

+static DevPrivateKeyRec DGAClientPrivateKeyRec;

+#define DGAClientPrivateKey (&DGAClientPrivateKeyRec)

 static int DGACallbackRefCount = 0;

 

 /* This holds the client's version information */

@@ -89,6 +90,12 @@ XFree86DGAExtensionInit(INITARGS)
 {

     ExtensionEntry* extEntry;

 

+    if (!dixRegisterPrivateKey(&DGAClientPrivateKeyRec, PRIVATE_CLIENT, 0))

+	return;

+

+    if (!dixRegisterPrivateKey(&DGAScreenPrivateKeyRec, PRIVATE_SCREEN, 0))

+	return;

+

     if ((extEntry = AddExtension(XF86DGANAME,

 				XF86DGANumberEvents,

 				XF86DGANumberErrors,

@@ -685,10 +692,10 @@ ProcXF86DGAGetVideoLL(ClientPtr client)
     rep.sequenceNumber = client->sequence;

 

     if(!DGAAvailable(stuff->screen))

-	return (DGAErrorBase + XF86DGANoDirectVideoMode);

+	return DGAErrorBase + XF86DGANoDirectVideoMode;

 

     if(!(num = DGAGetOldDGAMode(stuff->screen)))

-	return (DGAErrorBase + XF86DGANoDirectVideoMode);

+	return DGAErrorBase + XF86DGANoDirectVideoMode;

 

     /* get the parameters for the mode that best matches */

     DGAGetModeInfo(stuff->screen, &mode, num);

@@ -717,24 +724,24 @@ ProcXF86DGADirectVideo(ClientPtr client)
 

     if (stuff->screen > screenInfo.numScreens)

 	return BadValue;

-    owner = DGA_GETCLIENT(stuff->screen);

-

     REQUEST_SIZE_MATCH(xXF86DGADirectVideoReq);

 

     if (!DGAAvailable(stuff->screen))

 	return DGAErrorBase + XF86DGANoDirectVideoMode;

 

+    owner = DGA_GETCLIENT(stuff->screen);

+

     if (owner && owner != client)

         return DGAErrorBase + XF86DGANoDirectVideoMode;

 

     if (stuff->enable & XF86DGADirectGraphics) {

 	if(!(num = DGAGetOldDGAMode(stuff->screen)))

-	    return (DGAErrorBase + XF86DGANoDirectVideoMode);

+	    return DGAErrorBase + XF86DGANoDirectVideoMode;

     } else

 	num = 0;

 

     if(Success != DGASetMode(stuff->screen, num, &mode, &pix))

-	return (DGAErrorBase + XF86DGAScreenNotActive);

+	return DGAErrorBase + XF86DGAScreenNotActive;

 

     DGASetInputMode (stuff->screen,

 		     (stuff->enable & XF86DGADirectKeyb) != 0,

@@ -778,10 +785,10 @@ ProcXF86DGAGetViewPortSize(ClientPtr client)
     rep.sequenceNumber = client->sequence;

 

     if (!DGAAvailable(stuff->screen))

-	return (DGAErrorBase + XF86DGANoDirectVideoMode);

+	return DGAErrorBase + XF86DGANoDirectVideoMode;

 

     if(!(num = DGAGetOldDGAMode(stuff->screen)))

-	return (DGAErrorBase + XF86DGANoDirectVideoMode);

+	return DGAErrorBase + XF86DGANoDirectVideoMode;

 

     DGAGetModeInfo(stuff->screen, &mode, num);

 

@@ -806,7 +813,7 @@ ProcXF86DGASetViewPort(ClientPtr client)
     REQUEST_SIZE_MATCH(xXF86DGASetViewPortReq);

 

     if (!DGAAvailable(stuff->screen))

-	return (DGAErrorBase + XF86DGANoDirectVideoMode);

+	return DGAErrorBase + XF86DGANoDirectVideoMode;

 

     if (!DGAActive(stuff->screen))

 	return DGAErrorBase + XF86DGADirectNotActivated;

@@ -870,7 +877,7 @@ ProcXF86DGAInstallColormap(ClientPtr client)
     REQUEST_SIZE_MATCH(xXF86DGAInstallColormapReq);

 

     if (!DGAActive(stuff->screen))

-	return (DGAErrorBase + XF86DGADirectNotActivated);

+	return DGAErrorBase + XF86DGADirectNotActivated;

 

     rc = dixLookupResourceByType((pointer *)&pcmp, stuff->id, RT_COLORMAP,

 				 client, DixInstallAccess);

@@ -919,7 +926,7 @@ ProcXF86DGAViewPortChanged(ClientPtr client)
     REQUEST_SIZE_MATCH(xXF86DGAViewPortChangedReq);

 

     if (!DGAActive(stuff->screen))

-	return (DGAErrorBase + XF86DGADirectNotActivated);

+	return DGAErrorBase + XF86DGADirectNotActivated;

 

     rep.type = X_Reply;

     rep.length = 0;

diff --git a/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c b/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c
index f29f5bad2..31bb311b3 100644
--- a/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c
+++ b/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c
@@ -51,8 +51,8 @@ from Kaleb S. KEITHLEY
 #define DEFAULT_XF86VIDMODE_VERBOSITY	3

 

 static int VidModeErrorBase;

-static int VidModeClientPrivateKeyIndex;

-static DevPrivateKey VidModeClientPrivateKey = &VidModeClientPrivateKeyIndex;

+static DevPrivateKeyRec VidModeClientPrivateKeyRec;

+#define VidModeClientPrivateKey (&VidModeClientPrivateKeyRec)

 

 /* This holds the client's version information */

 typedef struct {

@@ -141,8 +141,8 @@ typedef struct _XF86VidModeScreenPrivate {
     Bool		hasWindow;

 } XF86VidModeScreenPrivateRec, *XF86VidModeScreenPrivatePtr;

 

-static int ScreenPrivateKeyIndex;

-static DevPrivateKey ScreenPrivateKey = &ScreenPrivateKeyIndex;

+static DevPrivateKeyRec ScreenPrivateKeyRec;

+#define ScreenPrivateKey (&ScreenPrivateKeyRec)

 

 #define GetScreenPrivate(s) ((ScreenSaverScreenPrivatePtr) \

     dixLookupPrivate(&(s)->devPrivates, ScreenPrivateKey))

@@ -169,6 +169,13 @@ XFree86VidModeExtensionInit(void)
 

     DEBUG_P("XFree86VidModeExtensionInit");

 

+    if (!dixRegisterPrivateKey(&VidModeClientPrivateKeyRec, PRIVATE_CLIENT, 0))

+	return;

+#ifdef XF86VIDMODE_EVENTS

+    if (!dixRegisterPrivateKey(&ScreenPrivateKeyRec, PRIVATE_SCREEN, 0))

+	return;

+#endif

+

 #ifdef XF86VIDMODE_EVENTS

     EventType = CreateNewResourceType(XF86VidModeFreeEvents, "VidModeEvent");

 #endif

@@ -177,9 +184,6 @@ XFree86VidModeExtensionInit(void)
         pScreen = screenInfo.screens[i];

 	if (VidModeExtensionInit(pScreen))

 	    enabled = TRUE;

-#ifdef XF86VIDMODE_EVENTS

-	SetScreenPrivate (pScreen, NULL);

-#endif

     }

     /* This means that the DDX doesn't want the vidmode extension enabled */

     if (!enabled)

@@ -347,7 +351,7 @@ SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced)
 	ev.type = XF86VidModeNotify + XF86VidModeEventBase;

 	ev.state = state;

 	ev.timestamp = currentTime.milliseconds;

-	ev.root = WindowTable[pScreen->myNum]->drawable.id;

+	ev.root = pScreen->root->drawable.id;

 	ev.kind = kind;

 	ev.forced = forced;

 	WriteEventsToClient (pEv->client, 1, (xEvent *) &ev);

@@ -516,7 +520,7 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
 

     modecount = VidModeGetNumOfModes(stuff->screen);

     if (modecount < 1)

-      return (VidModeErrorBase + XF86VidModeExtensionDisabled);

+      return VidModeErrorBase + XF86VidModeExtensionDisabled;

 

     if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock))

 	return BadValue;

@@ -1098,8 +1102,7 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
     status = VidModeCheckModeForDriver(stuff->screen, modetmp);

 

 status_reply:

-    if(modetmp)

-      free(modetmp);

+    free(modetmp);

 

     rep.type = X_Reply;

     rep.length = bytes_to_int32(SIZEOF(xXF86VidModeValidateModeLineReply)

diff --git a/xorg-server/hw/xfree86/doc/man/xorg.conf.man.pre b/xorg-server/hw/xfree86/doc/man/xorg.conf.man.pre
index bf1adc4e8..1bec1bf27 100644
--- a/xorg-server/hw/xfree86/doc/man/xorg.conf.man.pre
+++ b/xorg-server/hw/xfree86/doc/man/xorg.conf.man.pre
@@ -1065,35 +1065,85 @@ of the class. If none of the optional entries appear, the
 .B InputClass

 section is generic and will match any input device. If more than one of

 these entries appear, they all must match for the configuration to apply.

-The allowed matching entries are shown below.

 .PP

+There are two types of match entries used in

+.B InputClass

+sections. The first allows various tokens to be matched against attributes

+of the device. An entry can be constructed to match attributes from different

+devices by separating arguments with a '|' character. Multiple entries of the

+same type may be supplied to add multiple matching conditions on the same

+attribute. For example:

+.PP

+.RS 4

+.nf

+.B  "Section \*qInputClass\*q"

+.B  "    Identifier   \*qMy Class\*q"

+.B  "    # product string must contain example and

+.B  "    # either gizmo or gadget

+.B  "    MatchProduct \*qexample\*q

+.B  "    MatchProduct \*qgizmo|gadget\*q

+.I  "    ..."

+.B  "EndSection"

+.fi

+.RE

 .TP 7

 .BI "MatchProduct  \*q" matchproduct \*q

 This entry can be used to check if the substring

 .RI \*q matchproduct \*q

-occurs in the device's product name. Multiple substrings can be matched by

-separating arguments with a '|' character.

+occurs in the device's product name.

 .TP 7

 .BI "MatchVendor  \*q" matchvendor \*q

 This entry can be used to check if the substring

 .RI \*q matchvendor \*q

-occurs in the device's vendor name. Multiple substrings can be matched by

-separating arguments with a '|' character.

+occurs in the device's vendor name.

 .TP 7

 .BI "MatchDevicePath \*q" matchdevice \*q

 This entry can be used to check if the device file matches the

 .RI \*q matchdevice \*q

-pathname pattern. Multiple patterns can be matched by separating arguments

-with a '|' character.

+pathname pattern.

+.TP 7

+.BI "MatchOS \*q" matchos \*q

+This entry can be used to check if the operating system matches the

+case-insensitive

+.RI \*q matchos \*q

+string. This entry is only supported on platforms providing the

+.BR uname (2)

+system call.

+.TP 7

+.BI "MatchPnPID \*q" matchpnp \*q

+The device's Plug and Play (PnP) ID can be checked against the

+.RI \*q matchpnp \*q

+shell wildcard pattern.

+.TP 7

+.BI "MatchUSBID \*q" matchusb \*q

+The device's USB ID can be checked against the

+.RI \*q matchusb \*q

+shell wildcard pattern. The ID is constructed as lowercase hexadecimal numbers

+separated by a ':'. This is the same format as the

+.BR lsusb (8)

+program.

+.TP 7

+.BI "MatchDriver \*q" matchdriver \*q

+Check the case-sensitive string

+.RI \*q matchdriver \*q

+against the currently configured driver of the device. Ordering of sections

+using this entry is important since it will not match unless the driver has

+been set by the config backend or a previous

+.B InputClass

+section.

 .TP 7

 .BI "MatchTag \*q" matchtag \*q

 This entry can be used to check if tags assigned by the config backend

 matches the

 .RI \*q matchtag \*q

-pattern.  Multiple patterns can be matched by separating arguments

-with a '|' character. A match is found if at least one of the tags given in

+pattern. A match is found if at least one of the tags given in

 .RI \*q matchtag \*q

 matches at least one of the tags assigned by the backend.

+.PP

+The second type of entry is used to match device types. These entries take a

+boolean argument similar to

+.B Option

+entries.

 .TP 7

 .BI "MatchIsKeyboard     \*q" bool \*q

 .TP 7

@@ -1106,9 +1156,6 @@ matches at least one of the tags assigned by the backend.
 .BI "MatchIsTouchpad     \*q" bool \*q

 .TP 7

 .BI "MatchIsTouchscreen  \*q" bool \*q

-Match device types. These entries take a boolean argument similar to

-.B Option

-entries.

 .PP

 When an input device has been matched to the

 .B InputClass

diff --git a/xorg-server/hw/xfree86/doc/sgml/DESIGN.xml b/xorg-server/hw/xfree86/doc/sgml/DESIGN.xml
index ff132a182..52a104cbc 100644
--- a/xorg-server/hw/xfree86/doc/sgml/DESIGN.xml
+++ b/xorg-server/hw/xfree86/doc/sgml/DESIGN.xml
@@ -118,8 +118,9 @@ routines common to all the X servers in the sample implementation.
     <title>The xorg.conf File</title>

 

     <para>

-The xorg.conf file format is similar to the old format, with the following

-changes:

+The xorg.conf file format is based on the XF86Config format from XFree86 4.4,

+which is in turn similar to the old XFree86 3.x XF86Config format, with the

+following changes:

     </para>

 

     <sect2>

diff --git a/xorg-server/hw/xfree86/dri/dri.c b/xorg-server/hw/xfree86/dri/dri.c
index a8b050a94..378731624 100644
--- a/xorg-server/hw/xfree86/dri/dri.c
+++ b/xorg-server/hw/xfree86/dri/dri.c
@@ -74,10 +74,10 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #define PCI_BUS_NO_DOMAIN(bus) ((bus) & 0xffu)

 

 static int DRIEntPrivIndex = -1;

-static int DRIScreenPrivKeyIndex;

-static DevPrivateKey DRIScreenPrivKey = &DRIScreenPrivKeyIndex;

-static int DRIWindowPrivKeyIndex;

-static DevPrivateKey DRIWindowPrivKey = &DRIWindowPrivKeyIndex;

+static DevPrivateKeyRec DRIScreenPrivKeyRec;

+#define DRIScreenPrivKey (&DRIScreenPrivKeyRec)

+static DevPrivateKeyRec DRIWindowPrivKeyRec;

+#define DRIWindowPrivKey (&DRIWindowPrivKeyRec)

 static unsigned long DRIGeneration = 0;

 static unsigned int DRIDrawableValidationStamp = 0;

 

@@ -357,6 +357,11 @@ DRIScreenInit(ScreenPtr pScreen, DRIInfoPtr pDRIInfo, int *pDRMFD)
     if (DRIGeneration != serverGeneration)

 	DRIGeneration = serverGeneration;

 

+    if (!dixRegisterPrivateKey(&DRIScreenPrivKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+    if (!dixRegisterPrivateKey(&DRIWindowPrivKeyRec, PRIVATE_WINDOW, 0))

+	return FALSE;

+

     pDRIPriv = (DRIScreenPrivPtr) calloc(1, sizeof(DRIScreenPrivRec));

     if (!pDRIPriv) {

 	dixSetPrivate(&pScreen->devPrivates, DRIScreenPrivKey, NULL);

@@ -573,10 +578,8 @@ DRIScreenInit(ScreenPtr pScreen, DRIInfoPtr pDRIInfo, int *pDRMFD)
 	      drmInstallSIGIOHandler(pDRIPriv->drmFD, DRISwapContext))) {

 	    DRIDrvMsg(pScreen->myNum, X_ERROR,

 		      "[drm] failed to setup DRM signal handler\n");

-	    if (pDRIPriv->hiddenContextStore)

-		free(pDRIPriv->hiddenContextStore);

-	    if (pDRIPriv->partial3DContextStore)

-		free(pDRIPriv->partial3DContextStore);

+	    free(pDRIPriv->hiddenContextStore);

+	    free(pDRIPriv->partial3DContextStore);

 	    DRIDestroyContextPriv(pDRIContextPriv);

 	    return FALSE;

 	} else {

@@ -785,7 +788,7 @@ drmServerInfo DRIDRMServerInfo =  {
 Bool

 DRIExtensionInit(void)

 {

-    if (!DRIScreenPrivKey || DRIGeneration != serverGeneration) {

+    if (DRIGeneration != serverGeneration) {

 	return FALSE;

     }

 

@@ -1157,7 +1160,7 @@ DRIDCNTreeTraversal(WindowPtr pWin, pointer data)
 	ScreenPtr pScreen = pWin->drawable.pScreen;

 	DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);

 

-	if (REGION_NUM_RECTS(&pWin->clipList) > 0) {

+	if (RegionNumRects(&pWin->clipList) > 0) {

 	    WindowPtr *pDRIWindows = (WindowPtr*)data;

 	    int i = 0;

 

@@ -1187,7 +1190,7 @@ DRIDriverClipNotify(ScreenPtr pScreen)
 

 	if (pDRIPriv->nrWindows > 0) {

 	    pDRIPriv->nrWalked = 0;

-	    TraverseTree(WindowTable[pScreen->myNum], DRIDCNTreeTraversal,

+	    TraverseTree(pScreen->root, DRIDCNTreeTraversal,

 			 (pointer)pDRIWindows);

 	}

 

@@ -1269,7 +1272,7 @@ DRICreateDrawable(ScreenPtr pScreen, ClientPtr client, DrawablePtr pDrawable,
 	    pDRIDrawablePriv->pScreen = pScreen;

 	    pDRIDrawablePriv->refCount = 1;

 	    pDRIDrawablePriv->drawableIndex = -1;

-	    pDRIDrawablePriv->nrects = REGION_NUM_RECTS(&pWin->clipList);

+	    pDRIDrawablePriv->nrects = RegionNumRects(&pWin->clipList);

 

 	    /* save private off of preallocated index */

 	    dixSetPrivate(&pWin->devPrivates, DRIWindowPrivKey,

@@ -1288,8 +1291,8 @@ DRICreateDrawable(ScreenPtr pScreen, ClientPtr client, DrawablePtr pDrawable,
 	    drmUpdateDrawableInfo(pDRIPriv->drmFD,

 				  pDRIDrawablePriv->hwDrawable,

 				  DRM_DRAWABLE_CLIPRECTS,

-				  REGION_NUM_RECTS(&pWin->clipList),

-				  REGION_RECTS(&pWin->clipList));

+				  RegionNumRects(&pWin->clipList),

+				  RegionRects(&pWin->clipList));

 	    *hHWDrawable = pDRIDrawablePriv->hwDrawable;

 	}

     }

@@ -1502,8 +1505,8 @@ DRIGetDrawableInfo(ScreenPtr pScreen,
 #endif

 	    *W = (int)(pWin->drawable.width);

 	    *H = (int)(pWin->drawable.height);

-	    *numClipRects = REGION_NUM_RECTS(&pWin->clipList);

-	    *pClipRects = (drm_clip_rect_t *)REGION_RECTS(&pWin->clipList);

+	    *numClipRects = RegionNumRects(&pWin->clipList);

+	    *pClipRects = (drm_clip_rect_t *)RegionRects(&pWin->clipList);

 

 	    if (!*numClipRects && pDRIPriv->fullscreen) {

 				/* use fake full-screen clip rect */

@@ -1613,7 +1616,7 @@ DRICreateInfoRec(void)
 void

 DRIDestroyInfoRec(DRIInfoPtr DRIInfo)

 {

-    if (DRIInfo->busIdString) free(DRIInfo->busIdString);

+    free(DRIInfo->busIdString);

     free((char*)DRIInfo);

 }

 

@@ -1883,10 +1886,10 @@ DRITreeTraversal(WindowPtr pWin, pointer data)
         ScreenPtr pScreen = pWin->drawable.pScreen;

         DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);

 

-	if(REGION_NUM_RECTS(&(pWin->clipList)) > 0) {

+	if(RegionNumRects(&(pWin->clipList)) > 0) {

 	   RegionPtr reg = (RegionPtr)data;

 

-	   REGION_UNION(pScreen, reg, reg, &(pWin->clipList));

+	   RegionUnion(reg, reg, &(pWin->clipList));

 	   pDRIPriv->nrWalked++;

 	}

 

@@ -1932,21 +1935,21 @@ DRICopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
     if(pDRIPriv->nrWindowsVisible > 0) {

        RegionRec reg;

 

-       REGION_NULL(pScreen, &reg);

+       RegionNull(&reg);

        pDRIPriv->nrWalked = 0;

        TraverseTree(pWin, DRITreeTraversal, (pointer)(&reg));

 

-       if(REGION_NOTEMPTY(pScreen, &reg)) {

-           REGION_TRANSLATE(pScreen, &reg, ptOldOrg.x - pWin->drawable.x,  

+       if(RegionNotEmpty(&reg)) {

+           RegionTranslate(&reg, ptOldOrg.x - pWin->drawable.x,

                                         ptOldOrg.y - pWin->drawable.y);

-           REGION_INTERSECT(pScreen, &reg, &reg, prgnSrc);

+           RegionIntersect(&reg, &reg, prgnSrc);

 

            /* The MoveBuffers interface is not ideal */

            (*pDRIPriv->pDriverInfo->MoveBuffers)(pWin, ptOldOrg, &reg,

 				pDRIPriv->pDriverInfo->ddxDrawableTableEntry);

        }

 

-       REGION_UNINIT(pScreen, &reg);

+       RegionUninit(&reg);

     }

 

     /* call lower wrapped functions */

@@ -2122,7 +2125,7 @@ DRIClipNotify(WindowPtr pWin, int dx, int dy)
     if(!pDRIPriv) return;

 

     if ((pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin))) {

-        int nrects = REGION_NUM_RECTS(&pWin->clipList);

+        int nrects = RegionNumRects(&pWin->clipList);

 

         if(!pDRIPriv->windowsTouched) {

             DRILockTree(pScreen);

@@ -2143,7 +2146,7 @@ DRIClipNotify(WindowPtr pWin, int dx, int dy)
 

 	drmUpdateDrawableInfo(pDRIPriv->drmFD, pDRIDrawablePriv->hwDrawable,

 			      DRM_DRAWABLE_CLIPRECTS,

-			      nrects, REGION_RECTS(&pWin->clipList));

+			      nrects, RegionRects(&pWin->clipList));

     }

 

     /* call lower wrapped functions */

@@ -2368,9 +2371,9 @@ DRIMoveBuffersHelper(
    BoxRec tmpBox;

    int y, nbox;

 

-   extents = REGION_EXTENTS(pScreen, reg);

-   nbox = REGION_NUM_RECTS(reg);

-   pbox = REGION_RECTS(reg);

+   extents = RegionExtents(reg);

+   nbox = RegionNumRects(reg);

+   pbox = RegionRects(reg);

 

    if((dy > 0) && (dy < (extents->y2 - extents->y1))) {

      *ydir = -1;

diff --git a/xorg-server/hw/xfree86/dri/dristruct.h b/xorg-server/hw/xfree86/dri/dristruct.h
index fc929c2f9..bbd158e11 100644
--- a/xorg-server/hw/xfree86/dri/dristruct.h
+++ b/xorg-server/hw/xfree86/dri/dristruct.h
@@ -1,128 +1,129 @@
-/**************************************************************************
-
-Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
-All Rights Reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sub license, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice (including the
-next paragraph) shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
-IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
-ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-**************************************************************************/
-
-/*
- * Authors:
- *   Jens Owen <jens@tungstengraphics.com>
- *
- */
-
-#ifndef DRI_STRUCT_H
-#define DRI_STRUCT_H
-
-#include "xf86drm.h"
-#include "xf86Crtc.h"
-
-
-#define DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin) ((DRIDrawablePrivPtr) \
-    dixLookupPrivate(&(pWin)->devPrivates, DRIWindowPrivKey))
-#define DRI_DRAWABLE_PRIV_FROM_PIXMAP(pPix) ((DRIDrawablePrivPtr) \
-    dixLookupPrivate(&(pPix)->devPrivates, DRIWindowPrivKey))
-
-typedef struct _DRIDrawablePrivRec
-{
-    drm_drawable_t		hwDrawable;
-    int			drawableIndex;
-    ScreenPtr		pScreen;
-    int 		refCount;
-    int 		nrects;
-} DRIDrawablePrivRec, *DRIDrawablePrivPtr;
-
-struct _DRIContextPrivRec
-{
-    drm_context_t		hwContext;
-    ScreenPtr		pScreen;
-    Bool     		valid3D;
-    DRIContextFlags     flags;
-    void**     		pContextStore;
-};
-
-#define DRI_SCREEN_PRIV(pScreen) ((DRIScreenPrivPtr) \
-    dixLookupPrivate(&(pScreen)->devPrivates, DRIScreenPrivKey))
-
-#define DRI_SCREEN_PRIV_FROM_INDEX(screenIndex) ((DRIScreenPrivPtr) \
-    dixLookupPrivate(&screenInfo.screens[screenIndex]->devPrivates, \
-		     DRIScreenPrivKey))
-
-#define DRI_ENT_PRIV(pScrn)  \
-    ((DRIEntPrivIndex < 0) ? \
-     NULL:		     \
-     ((DRIEntPrivPtr)(xf86GetEntityPrivate((pScrn)->entityList[0], \
-					   DRIEntPrivIndex)->ptr)))
-
-typedef struct _DRIScreenPrivRec
-{
-    Bool		directRenderingSupport;
-    int			drmFD;	      /* File descriptor for /dev/video/?   */
-    drm_handle_t   	hSAREA;	      /* Handle to SAREA, for mapping       */
-    XF86DRISAREAPtr	pSAREA;	      /* Mapped pointer to SAREA            */
-    drm_context_t          myContext;    /* DDX Driver's context               */
-    DRIContextPrivPtr   myContextPriv;/* Pointer to server's private area   */
-    DRIContextPrivPtr   lastPartial3DContext;  /* last one partially saved  */
-    void**		hiddenContextStore;    /* hidden X context          */
-    void**		partial3DContextStore; /* parital 3D context        */
-    DRIInfoPtr		pDriverInfo;
-    int                 nrWindows;
-    int                 nrWindowsVisible;
-    int                 nrWalked;
-    drm_clip_rect_t  private_buffer_rect; /* management of private buffers */
-    DrawablePtr         fullscreen; /* pointer to fullscreen drawable */
-    drm_clip_rect_t  fullscreen_rect; /* fake rect for fullscreen mode */
-    DRIWrappedFuncsRec	wrap;
-    DestroyWindowProcPtr DestroyWindow;
-    DrawablePtr		DRIDrawables[SAREA_MAX_DRAWABLES];
-    DRIContextPrivPtr   dummyCtxPriv; /* Pointer to dummy context */
-    Bool		createDummyCtx;
-    Bool		createDummyCtxPriv;
-    Bool		grabbedDRILock;
-    Bool		drmSIGIOHandlerInstalled;
-    Bool		wrapped;
-    Bool		windowsTouched;
-    int			lockRefCount;
-    drm_handle_t        hLSAREA;      /* Handle to SAREA containing lock, for mapping */
-    XF86DRILSAREAPtr    pLSAREA;      /* Mapped pointer to SAREA containing lock */
-    int*                pLockRefCount;
-    int*                pLockingContext;
-    xf86_crtc_notify_proc_ptr	xf86_crtc_notify;
-} DRIScreenPrivRec, *DRIScreenPrivPtr;
-
-
-typedef struct _DRIEntPrivRec {
-    int drmFD;
-    Bool drmOpened;
-    Bool sAreaGrabbed;
-    drm_handle_t hLSAREA;
-    XF86DRILSAREAPtr pLSAREA;
-    unsigned long sAreaSize;
-    int lockRefCount;
-    int lockingContext;
-    ScreenPtr resOwner;
-    Bool keepFDOpen;
-    int refCount;
-} DRIEntPrivRec, *DRIEntPrivPtr;
-
-#endif /* DRI_STRUCT_H */
+/**************************************************************************

+

+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.

+All Rights Reserved.

+

+Permission is hereby granted, free of charge, to any person obtaining a

+copy of this software and associated documentation files (the

+"Software"), to deal in the Software without restriction, including

+without limitation the rights to use, copy, modify, merge, publish,

+distribute, sub license, and/or sell copies of the Software, and to

+permit persons to whom the Software is furnished to do so, subject to

+the following conditions:

+

+The above copyright notice and this permission notice (including the

+next paragraph) shall be included in all copies or substantial portions

+of the Software.

+

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.

+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR

+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+

+**************************************************************************/

+

+/*

+ * Authors:

+ *   Jens Owen <jens@tungstengraphics.com>

+ *

+ */

+

+#ifndef DRI_STRUCT_H

+#define DRI_STRUCT_H

+

+#include "xf86drm.h"

+#include "xf86Crtc.h"

+

+

+#define DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin) ((DRIDrawablePrivPtr) \

+    dixLookupPrivate(&(pWin)->devPrivates, DRIWindowPrivKey))

+#define DRI_DRAWABLE_PRIV_FROM_PIXMAP(pPix) ((DRIDrawablePrivPtr) \

+    dixLookupPrivate(&(pPix)->devPrivates, DRIWindowPrivKey))

+

+typedef struct _DRIDrawablePrivRec

+{

+    drm_drawable_t		hwDrawable;

+    int			drawableIndex;

+    ScreenPtr		pScreen;

+    int 		refCount;

+    int 		nrects;

+} DRIDrawablePrivRec, *DRIDrawablePrivPtr;

+

+struct _DRIContextPrivRec

+{

+    drm_context_t		hwContext;

+    ScreenPtr		pScreen;

+    Bool     		valid3D;

+    DRIContextFlags     flags;

+    void**     		pContextStore;

+};

+

+#define DRI_SCREEN_PRIV(pScreen) ((DRIScreenPrivPtr) \

+    (dixPrivateKeyRegistered(DRIScreenPrivKey) ?			\

+     dixLookupPrivate(&(pScreen)->devPrivates, DRIScreenPrivKey) : NULL))

+

+#define DRI_SCREEN_PRIV_FROM_INDEX(screenIndex) ((DRIScreenPrivPtr) \

+    dixLookupPrivate(&screenInfo.screens[screenIndex]->devPrivates, \

+		     DRIScreenPrivKey))

+

+#define DRI_ENT_PRIV(pScrn)  \

+    ((DRIEntPrivIndex < 0) ? \

+     NULL:		     \

+     ((DRIEntPrivPtr)(xf86GetEntityPrivate((pScrn)->entityList[0], \

+					   DRIEntPrivIndex)->ptr)))

+

+typedef struct _DRIScreenPrivRec

+{

+    Bool		directRenderingSupport;

+    int			drmFD;	      /* File descriptor for /dev/video/?   */

+    drm_handle_t   	hSAREA;	      /* Handle to SAREA, for mapping       */

+    XF86DRISAREAPtr	pSAREA;	      /* Mapped pointer to SAREA            */

+    drm_context_t          myContext;    /* DDX Driver's context               */

+    DRIContextPrivPtr   myContextPriv;/* Pointer to server's private area   */

+    DRIContextPrivPtr   lastPartial3DContext;  /* last one partially saved  */

+    void**		hiddenContextStore;    /* hidden X context          */

+    void**		partial3DContextStore; /* parital 3D context        */

+    DRIInfoPtr		pDriverInfo;

+    int                 nrWindows;

+    int                 nrWindowsVisible;

+    int                 nrWalked;

+    drm_clip_rect_t  private_buffer_rect; /* management of private buffers */

+    DrawablePtr         fullscreen; /* pointer to fullscreen drawable */

+    drm_clip_rect_t  fullscreen_rect; /* fake rect for fullscreen mode */

+    DRIWrappedFuncsRec	wrap;

+    DestroyWindowProcPtr DestroyWindow;

+    DrawablePtr		DRIDrawables[SAREA_MAX_DRAWABLES];

+    DRIContextPrivPtr   dummyCtxPriv; /* Pointer to dummy context */

+    Bool		createDummyCtx;

+    Bool		createDummyCtxPriv;

+    Bool		grabbedDRILock;

+    Bool		drmSIGIOHandlerInstalled;

+    Bool		wrapped;

+    Bool		windowsTouched;

+    int			lockRefCount;

+    drm_handle_t        hLSAREA;      /* Handle to SAREA containing lock, for mapping */

+    XF86DRILSAREAPtr    pLSAREA;      /* Mapped pointer to SAREA containing lock */

+    int*                pLockRefCount;

+    int*                pLockingContext;

+    xf86_crtc_notify_proc_ptr	xf86_crtc_notify;

+} DRIScreenPrivRec, *DRIScreenPrivPtr;

+

+

+typedef struct _DRIEntPrivRec {

+    int drmFD;

+    Bool drmOpened;

+    Bool sAreaGrabbed;

+    drm_handle_t hLSAREA;

+    XF86DRILSAREAPtr pLSAREA;

+    unsigned long sAreaSize;

+    int lockRefCount;

+    int lockingContext;

+    ScreenPtr resOwner;

+    Bool keepFDOpen;

+    int refCount;

+} DRIEntPrivRec, *DRIEntPrivPtr;

+

+#endif /* DRI_STRUCT_H */

diff --git a/xorg-server/hw/xfree86/dri2/dri2.c b/xorg-server/hw/xfree86/dri2/dri2.c
index 29c917f21..bb1be358b 100644
--- a/xorg-server/hw/xfree86/dri2/dri2.c
+++ b/xorg-server/hw/xfree86/dri2/dri2.c
@@ -1,1140 +1,1177 @@
-/*
- * Copyright © 2007, 2008 Red Hat, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Soft-
- * ware"), to deal in the Software without restriction, including without
- * limitation the rights to use, copy, modify, merge, publish, distribute,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, provided that the above copyright
- * notice(s) and this permission notice appear in all copies of the Soft-
- * ware and that both the above copyright notice(s) and this permission
- * notice appear in supporting documentation.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
- * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
- * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
- * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
- * QUENTIAL 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 PERFOR-
- * MANCE OF THIS SOFTWARE.
- *
- * Except as contained in this notice, the name of a copyright holder shall
- * not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization of
- * the copyright holder.
- *
- * Authors:
- *   Kristian Høgsberg (krh@redhat.com)
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <errno.h>
-#include <xf86drm.h>
-#include "xf86Module.h"
-#include "list.h"
-#include "scrnintstr.h"
-#include "windowstr.h"
-#include "dixstruct.h"
-#include "dri2.h"
-#include "xf86VGAarbiter.h"
-
-#include "xf86.h"
-
-CARD8 dri2_major; /* version of DRI2 supported by DDX */
-CARD8 dri2_minor;
-
-static int           dri2ScreenPrivateKeyIndex;
-static DevPrivateKey dri2ScreenPrivateKey = &dri2ScreenPrivateKeyIndex;
-static int dri2WindowPrivateKeyIndex;
-static DevPrivateKey dri2WindowPrivateKey = &dri2WindowPrivateKeyIndex;
-static int dri2PixmapPrivateKeyIndex;
-static DevPrivateKey dri2PixmapPrivateKey = &dri2PixmapPrivateKeyIndex;
-static RESTYPE       dri2DrawableRes;
-
-typedef struct _DRI2Screen *DRI2ScreenPtr;
-
-typedef struct _DRI2Drawable {
-    DRI2ScreenPtr        dri2_screen;
-    DrawablePtr		 drawable;
-    struct list		 reference_list;
-    int			 width;
-    int			 height;
-    DRI2BufferPtr	*buffers;
-    int			 bufferCount;
-    unsigned int	 swapsPending;
-    ClientPtr		 blockedClient;
-    Bool		 blockedOnMsc;
-    int			 swap_interval;
-    CARD64		 swap_count;
-    int64_t		 target_sbc; /* -1 means no SBC wait outstanding */
-    CARD64		 last_swap_target; /* most recently queued swap target */
-    CARD64		 last_swap_msc; /* msc at completion of most recent swap */
-    CARD64		 last_swap_ust; /* ust at completion of most recent swap */
-    int			 swap_limit; /* for N-buffering */
-} DRI2DrawableRec, *DRI2DrawablePtr;
-
-typedef struct _DRI2Screen {
-    ScreenPtr			 screen;
-    int				 refcnt;
-    unsigned int		 numDrivers;
-    const char			**driverNames;
-    const char			*deviceName;
-    int				 fd;
-    unsigned int		 lastSequence;
-
-    DRI2CreateBufferProcPtr	 CreateBuffer;
-    DRI2DestroyBufferProcPtr	 DestroyBuffer;
-    DRI2CopyRegionProcPtr	 CopyRegion;
-    DRI2ScheduleSwapProcPtr	 ScheduleSwap;
-    DRI2GetMSCProcPtr		 GetMSC;
-    DRI2ScheduleWaitMSCProcPtr	 ScheduleWaitMSC;
-
-    HandleExposuresProcPtr       HandleExposures;
-
-    ConfigNotifyProcPtr		 ConfigNotify;
-} DRI2ScreenRec;
-
-static DRI2ScreenPtr
-DRI2GetScreen(ScreenPtr pScreen)
-{
-    return dixLookupPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey);
-}
-
-static DRI2DrawablePtr
-DRI2GetDrawable(DrawablePtr pDraw)
-{
-    WindowPtr pWin;
-    PixmapPtr pPixmap;
-
-    if (pDraw->type == DRAWABLE_WINDOW) {
-	pWin = (WindowPtr) pDraw;
-	return dixLookupPrivate(&pWin->devPrivates, dri2WindowPrivateKey);
-    } else {
-	pPixmap = (PixmapPtr) pDraw;
-	return dixLookupPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey);
-    }
-}
-
-static DRI2DrawablePtr
-DRI2AllocateDrawable(DrawablePtr pDraw)
-{
-    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    CARD64          ust;
-    WindowPtr pWin;
-    PixmapPtr pPixmap;
-
-    pPriv = malloc(sizeof *pPriv);
-    if (pPriv == NULL)
-	return NULL;
-
-    pPriv->dri2_screen = ds;
-    pPriv->drawable = pDraw;
-    pPriv->width = pDraw->width;
-    pPriv->height = pDraw->height;
-    pPriv->buffers = NULL;
-    pPriv->bufferCount = 0;
-    pPriv->swapsPending = 0;
-    pPriv->blockedClient = NULL;
-    pPriv->blockedOnMsc = FALSE;
-    pPriv->swap_count = 0;
-    pPriv->target_sbc = -1;
-    pPriv->swap_interval = 1;
-    /* Initialize last swap target from DDX if possible */
-    if (!ds->GetMSC || !(*ds->GetMSC)(pDraw, &ust, &pPriv->last_swap_target))
-	pPriv->last_swap_target = 0;
-
-    pPriv->swap_limit = 1; /* default to double buffering */
-    pPriv->last_swap_msc = 0;
-    pPriv->last_swap_ust = 0;
-    list_init(&pPriv->reference_list);
-
-    if (pDraw->type == DRAWABLE_WINDOW) {
-	pWin = (WindowPtr) pDraw;
-	dixSetPrivate(&pWin->devPrivates, dri2WindowPrivateKey, pPriv);
-    } else {
-	pPixmap = (PixmapPtr) pDraw;
-	dixSetPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey, pPriv);
-    }
-
-    return pPriv;
-}
-
-typedef struct DRI2DrawableRefRec {
-    XID		  id;
-    XID		  dri2_id;
-    DRI2InvalidateProcPtr	invalidate;
-    void	 *priv;
-    struct list	  link;
-} DRI2DrawableRefRec, *DRI2DrawableRefPtr;
-
-static DRI2DrawableRefPtr
-DRI2LookupDrawableRef(DRI2DrawablePtr pPriv, XID id)
-{
-    DRI2DrawableRefPtr ref;
-
-    list_for_each_entry(ref, &pPriv->reference_list, link) {
-	if (ref->id == id)
-	    return ref;
-    }
-    
-    return NULL;
-}
-
-static int
-DRI2AddDrawableRef(DRI2DrawablePtr pPriv, XID id, XID dri2_id,
-		   DRI2InvalidateProcPtr invalidate, void *priv)
-{
-    DRI2DrawableRefPtr ref;
-
-    ref = malloc(sizeof *ref);
-    if (ref == NULL)
-	return BadAlloc;
-	
-    if (!AddResource(dri2_id, dri2DrawableRes, pPriv))
-	return BadAlloc;
-    if (!DRI2LookupDrawableRef(pPriv, id))
-	if (!AddResource(id, dri2DrawableRes, pPriv))
-	    return BadAlloc;
-
-    ref->id = id;
-    ref->dri2_id = dri2_id; 
-    ref->invalidate = invalidate;
-    ref->priv = priv;
-    list_add(&ref->link, &pPriv->reference_list);
-
-    return Success;
-}
-
-int
-DRI2CreateDrawable(ClientPtr client, DrawablePtr pDraw, XID id,
-		   DRI2InvalidateProcPtr invalidate, void *priv)
-{
-    DRI2DrawablePtr pPriv;
-    XID dri2_id;
-    int rc;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	pPriv = DRI2AllocateDrawable(pDraw);
-    if (pPriv == NULL)
-	return BadAlloc;
-    
-    dri2_id = FakeClientID(client->index);
-    rc = DRI2AddDrawableRef(pPriv, id, dri2_id, invalidate, priv);
-    if (rc != Success)
-	return rc;
-
-    return Success;
-}
-
-static int DRI2DrawableGone(pointer p, XID id)
-{
-    DRI2DrawablePtr pPriv = p;
-    DRI2ScreenPtr   ds = pPriv->dri2_screen;
-    DRI2DrawableRefPtr ref, next;
-    WindowPtr pWin;
-    PixmapPtr pPixmap;
-    DrawablePtr pDraw;
-    int i;
-
-    list_for_each_entry_safe(ref, next, &pPriv->reference_list, link) {
-	if (ref->dri2_id == id) {
-	    list_del(&ref->link);
-	    /* If this was the last ref under this X drawable XID,
-	     * unregister the X drawable resource. */
-	    if (!DRI2LookupDrawableRef(pPriv, ref->id))
-		FreeResourceByType(ref->id, dri2DrawableRes, TRUE);
-	    free(ref);
-	    break;
-	}
-
-	if (ref->id == id) {
-	    list_del(&ref->link);
-	    FreeResourceByType(ref->dri2_id, dri2DrawableRes, TRUE);
-	    free(ref);
-	}
-    }
-
-    if (!list_is_empty(&pPriv->reference_list))
-	return Success;
-
-    pDraw = pPriv->drawable;
-    if (pDraw->type == DRAWABLE_WINDOW) {
-	pWin = (WindowPtr) pDraw;
-	dixSetPrivate(&pWin->devPrivates, dri2WindowPrivateKey, NULL);
-    } else {
-	pPixmap = (PixmapPtr) pDraw;
-	dixSetPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey, NULL);
-    }
-
-    if (pPriv->buffers != NULL) {
-	for (i = 0; i < pPriv->bufferCount; i++)
-	    (*ds->DestroyBuffer)(pDraw, pPriv->buffers[i]);
-
-	free(pPriv->buffers);
-    }
-
-    free(pPriv);
-
-    return Success;
-}
-
-static int
-find_attachment(DRI2DrawablePtr pPriv, unsigned attachment)
-{
-    int i;
-
-    if (pPriv->buffers == NULL) {
-	return -1;
-    }
-
-    for (i = 0; i < pPriv->bufferCount; i++) {
-	if ((pPriv->buffers[i] != NULL)
-	    && (pPriv->buffers[i]->attachment == attachment)) {
-	    return i;
-	}
-    }
-
-    return -1;
-}
-
-static Bool
-allocate_or_reuse_buffer(DrawablePtr pDraw, DRI2ScreenPtr ds,
-			 DRI2DrawablePtr pPriv,
-			 unsigned int attachment, unsigned int format,
-			 int dimensions_match, DRI2BufferPtr *buffer)
-{
-    int old_buf = find_attachment(pPriv, attachment);
-
-    if ((old_buf < 0)
-	|| !dimensions_match
-	|| (pPriv->buffers[old_buf]->format != format)) {
-	*buffer = (*ds->CreateBuffer)(pDraw, attachment, format);
-	return TRUE;
-
-    } else {
-	*buffer = pPriv->buffers[old_buf];
-	pPriv->buffers[old_buf] = NULL;
-	return FALSE;
-    }
-}
-
-static void
-update_dri2_drawable_buffers(DRI2DrawablePtr pPriv, DrawablePtr pDraw,
-			     DRI2BufferPtr *buffers, int *out_count, int *width, int *height)
-{
-    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);
-    int i;
-
-    if (pPriv->buffers != NULL) {
-	for (i = 0; i < pPriv->bufferCount; i++) {
-	    if (pPriv->buffers[i] != NULL) {
-		(*ds->DestroyBuffer)(pDraw, pPriv->buffers[i]);
-	    }
-	}
-
-	free(pPriv->buffers);
-    }
-
-    pPriv->buffers = buffers;
-    pPriv->bufferCount = *out_count;
-    pPriv->width = pDraw->width;
-    pPriv->height = pDraw->height;
-    *width = pPriv->width;
-    *height = pPriv->height;
-}
-
-static DRI2BufferPtr *
-do_get_buffers(DrawablePtr pDraw, int *width, int *height,
-	       unsigned int *attachments, int count, int *out_count,
-	       int has_format)
-{
-    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);
-    DRI2BufferPtr  *buffers;
-    int need_real_front = 0;
-    int need_fake_front = 0;
-    int have_fake_front = 0;
-    int front_format = 0;
-    int dimensions_match;
-    int buffers_changed = 0;
-    int i;
-
-    if (!pPriv) {
-	*width = pDraw->width;
-	*height = pDraw->height;
-	*out_count = 0;
-	return NULL;
-    }
-
-    dimensions_match = (pDraw->width == pPriv->width)
-	&& (pDraw->height == pPriv->height);
-
-    buffers = malloc((count + 1) * sizeof(buffers[0]));
-
-    for (i = 0; i < count; i++) {
-	const unsigned attachment = *(attachments++);
-	const unsigned format = (has_format) ? *(attachments++) : 0;
-
-	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, attachment,
-				     format, dimensions_match,
-				     &buffers[i]))
-		buffers_changed = 1;
-
-	if (buffers[i] == NULL)
-	    goto err_out;
-
-	/* If the drawable is a window and the front-buffer is requested,
-	 * silently add the fake front-buffer to the list of requested
-	 * attachments.  The counting logic in the loop accounts for the case
-	 * where the client requests both the fake and real front-buffer.
-	 */
-	if (attachment == DRI2BufferBackLeft) {
-	    need_real_front++;
-	    front_format = format;
-	}
-
-	if (attachment == DRI2BufferFrontLeft) {
-	    need_real_front--;
-	    front_format = format;
-
-	    if (pDraw->type == DRAWABLE_WINDOW) {
-		need_fake_front++;
-	    }
-	}
-
-	if (pDraw->type == DRAWABLE_WINDOW) {
-	    if (attachment == DRI2BufferFakeFrontLeft) {
-		need_fake_front--;
-		have_fake_front = 1;
-	    }
-	}
-    }
-
-    if (need_real_front > 0) {
-	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, DRI2BufferFrontLeft,
-				     front_format, dimensions_match,
-				     &buffers[i]))
-	    buffers_changed = 1;
-
-	if (buffers[i] == NULL)
-	    goto err_out;
-	i++;
-    }
-
-    if (need_fake_front > 0) {
-	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, DRI2BufferFakeFrontLeft,
-				     front_format, dimensions_match,
-				     &buffers[i]))
-	    buffers_changed = 1;
-
-	if (buffers[i] == NULL)
-	    goto err_out;
-
-	i++;
-	have_fake_front = 1;
-    }
-
-    *out_count = i;
-
-    update_dri2_drawable_buffers(pPriv, pDraw, buffers, out_count, width, height);
-
-    /* If the client is getting a fake front-buffer, pre-fill it with the
-     * contents of the real front-buffer.  This ensures correct operation of
-     * applications that call glXWaitX before calling glDrawBuffer.
-     */
-    if (have_fake_front && buffers_changed) {
-	BoxRec box;
-	RegionRec region;
-
-	box.x1 = 0;
-	box.y1 = 0;
-	box.x2 = pPriv->width;
-	box.y2 = pPriv->height;
-	REGION_INIT(pDraw->pScreen, &region, &box, 0);
-
-	DRI2CopyRegion(pDraw, &region, DRI2BufferFakeFrontLeft,
-		       DRI2BufferFrontLeft);
-    }
-
-    return pPriv->buffers;
-
-err_out:
-
-    *out_count = 0;
-
-    for (i = 0; i < count; i++) {
-	    if (buffers[i] != NULL)
-		    (*ds->DestroyBuffer)(pDraw, buffers[i]);
-    }
-
-    free(buffers);
-    buffers = NULL;
-
-    update_dri2_drawable_buffers(pPriv, pDraw, buffers, out_count, width, height);
-
-    return buffers;
-}
-
-DRI2BufferPtr *
-DRI2GetBuffers(DrawablePtr pDraw, int *width, int *height,
-	       unsigned int *attachments, int count, int *out_count)
-{
-    return do_get_buffers(pDraw, width, height, attachments, count,
-			  out_count, FALSE);
-}
-
-DRI2BufferPtr *
-DRI2GetBuffersWithFormat(DrawablePtr pDraw, int *width, int *height,
-			 unsigned int *attachments, int count, int *out_count)
-{
-    return do_get_buffers(pDraw, width, height, attachments, count,
-			  out_count, TRUE);
-}
-
-static void
-DRI2InvalidateDrawable(DrawablePtr pDraw)
-{
-    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);
-    DRI2DrawableRefPtr ref;
-
-    if (!pPriv)
-        return;
-
-    list_for_each_entry(ref, &pPriv->reference_list, link)
-	ref->invalidate(pDraw, ref->priv);
-}
-
-/*
- * In the direct rendered case, we throttle the clients that have more
- * than their share of outstanding swaps (and thus busy buffers) when a
- * new GetBuffers request is received.  In the AIGLX case, we allow the
- * client to get the new buffers, but throttle when the next GLX request
- * comes in (see __glXDRIcontextWait()).
- */
-Bool
-DRI2ThrottleClient(ClientPtr client, DrawablePtr pDraw)
-{
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return FALSE;
-
-    /* Throttle to swap limit */
-    if ((pPriv->swapsPending >= pPriv->swap_limit) &&
-	!pPriv->blockedClient) {
-	ResetCurrentRequest(client);
-	client->sequence--;
-	IgnoreClient(client);
-	pPriv->blockedClient = client;
-	return TRUE;
-    }
-
-    return FALSE;
-}
-
-static void
-__DRI2BlockClient(ClientPtr client, DRI2DrawablePtr pPriv)
-{
-    if (pPriv->blockedClient == NULL) {
-	IgnoreClient(client);
-	pPriv->blockedClient = client;
-    }
-}
-
-void
-DRI2BlockClient(ClientPtr client, DrawablePtr pDraw)
-{
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return;
-
-    __DRI2BlockClient(client, pPriv);
-    pPriv->blockedOnMsc = TRUE;
-}
-
-int
-DRI2CopyRegion(DrawablePtr pDraw, RegionPtr pRegion,
-	       unsigned int dest, unsigned int src)
-{
-    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    DRI2BufferPtr   pDestBuffer, pSrcBuffer;
-    int		    i;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return BadDrawable;
-
-    pDestBuffer = NULL;
-    pSrcBuffer = NULL;
-    for (i = 0; i < pPriv->bufferCount; i++)
-    {
-	if (pPriv->buffers[i]->attachment == dest)
-	    pDestBuffer = (DRI2BufferPtr) pPriv->buffers[i];
-	if (pPriv->buffers[i]->attachment == src)
-	    pSrcBuffer = (DRI2BufferPtr) pPriv->buffers[i];
-    }
-    if (pSrcBuffer == NULL || pDestBuffer == NULL)
-	return BadValue;
-
-    (*ds->CopyRegion)(pDraw, pRegion, pDestBuffer, pSrcBuffer);
-
-    return Success;
-}
-
-/* Can this drawable be page flipped? */
-Bool
-DRI2CanFlip(DrawablePtr pDraw)
-{
-    ScreenPtr pScreen = pDraw->pScreen;
-    WindowPtr pWin, pRoot;
-    PixmapPtr pWinPixmap, pRootPixmap;
-
-    if (pDraw->type == DRAWABLE_PIXMAP)
-	return TRUE;
-
-    pRoot = WindowTable[pScreen->myNum];
-    pRootPixmap = pScreen->GetWindowPixmap(pRoot);
-
-    pWin = (WindowPtr) pDraw;
-    pWinPixmap = pScreen->GetWindowPixmap(pWin);
-    if (pRootPixmap != pWinPixmap)
-	return FALSE;
-    if (!REGION_EQUAL(pScreen, &pWin->clipList, &pRoot->winSize))
-	return FALSE;
-
-    return TRUE;
-}
-
-/* Can we do a pixmap exchange instead of a blit? */
-Bool
-DRI2CanExchange(DrawablePtr pDraw)
-{
-    return FALSE;
-}
-
-void
-DRI2WaitMSCComplete(ClientPtr client, DrawablePtr pDraw, int frame,
-		    unsigned int tv_sec, unsigned int tv_usec)
-{
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return;
-
-    ProcDRI2WaitMSCReply(client, ((CARD64)tv_sec * 1000000) + tv_usec,
-			 frame, pPriv->swap_count);
-
-    if (pPriv->blockedClient)
-	AttendClient(pPriv->blockedClient);
-
-    pPriv->blockedClient = NULL;
-    pPriv->blockedOnMsc = FALSE;
-}
-
-static void
-DRI2WakeClient(ClientPtr client, DrawablePtr pDraw, int frame,
-	       unsigned int tv_sec, unsigned int tv_usec)
-{
-    ScreenPtr	    pScreen = pDraw->pScreen;
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return;
-    }
-
-    /*
-     * Swap completed.
-     * Wake the client iff:
-     *   - it was waiting on SBC
-     *   - was blocked due to GLX make current
-     *   - was blocked due to swap throttling
-     *   - is not blocked due to an MSC wait
-     */
-    if (pPriv->target_sbc != -1 &&
-	pPriv->target_sbc <= pPriv->swap_count) {
-	ProcDRI2WaitMSCReply(client, ((CARD64)tv_sec * 1000000) + tv_usec,
-			     frame, pPriv->swap_count);
-	pPriv->target_sbc = -1;
-
-	AttendClient(pPriv->blockedClient);
-	pPriv->blockedClient = NULL;
-    } else if (pPriv->target_sbc == -1 && !pPriv->blockedOnMsc) {
-	if (pPriv->blockedClient) {
-	    AttendClient(pPriv->blockedClient);
-	    pPriv->blockedClient = NULL;
-	}
-    }
-}
-
-void
-DRI2SwapComplete(ClientPtr client, DrawablePtr pDraw, int frame,
-		   unsigned int tv_sec, unsigned int tv_usec, int type,
-		   DRI2SwapEventPtr swap_complete, void *swap_data)
-{
-    ScreenPtr	    pScreen = pDraw->pScreen;
-    DRI2DrawablePtr pPriv;
-    CARD64          ust = 0;
-    BoxRec          box;
-    RegionRec       region;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return;
-    }
-
-    pPriv->swapsPending--;
-    pPriv->swap_count++;
-
-    box.x1 = 0;
-    box.y1 = 0;
-    box.x2 = pDraw->width;
-    box.y2 = pDraw->height;
-    REGION_INIT(pScreen, &region, &box, 0);
-    DRI2CopyRegion(pDraw, &region, DRI2BufferFakeFrontLeft,
-		   DRI2BufferFrontLeft);
-
-    ust = ((CARD64)tv_sec * 1000000) + tv_usec;
-    if (swap_complete)
-	swap_complete(client, swap_data, type, ust, frame, pPriv->swap_count);
-
-    pPriv->last_swap_msc = frame;
-    pPriv->last_swap_ust = ust;
-
-    DRI2WakeClient(client, pDraw, frame, tv_sec, tv_usec);
-}
-
-Bool
-DRI2WaitSwap(ClientPtr client, DrawablePtr pDrawable)
-{
-    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDrawable);
-
-    /* If we're currently waiting for a swap on this drawable, reset
-     * the request and suspend the client.  We only support one
-     * blocked client per drawable. */
-    if ((pPriv->swapsPending) &&
-	pPriv->blockedClient == NULL) {
-	ResetCurrentRequest(client);
-	client->sequence--;
-	__DRI2BlockClient(client, pPriv);
-	return TRUE;
-    }
-
-    return FALSE;
-}
-
-int
-DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
-		CARD64 divisor, CARD64 remainder, CARD64 *swap_target,
-		DRI2SwapEventPtr func, void *data)
-{
-    ScreenPtr       pScreen = pDraw->pScreen;
-    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    DRI2BufferPtr   pDestBuffer = NULL, pSrcBuffer = NULL;
-    int             ret, i;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return BadDrawable;
-    }
-
-    for (i = 0; i < pPriv->bufferCount; i++) {
-	if (pPriv->buffers[i]->attachment == DRI2BufferFrontLeft)
-	    pDestBuffer = (DRI2BufferPtr) pPriv->buffers[i];
-	if (pPriv->buffers[i]->attachment == DRI2BufferBackLeft)
-	    pSrcBuffer = (DRI2BufferPtr) pPriv->buffers[i];
-    }
-    if (pSrcBuffer == NULL || pDestBuffer == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: drawable has no back or front?\n", __func__);
-	return BadDrawable;
-    }
-
-    /* Old DDX or no swap interval, just blit */
-    if (!ds->ScheduleSwap || !pPriv->swap_interval) {
-	BoxRec box;
-	RegionRec region;
-
-	box.x1 = 0;
-	box.y1 = 0;
-	box.x2 = pDraw->width;
-	box.y2 = pDraw->height;
-	REGION_INIT(pScreen, &region, &box, 0);
-
-	pPriv->swapsPending++;
-
-	(*ds->CopyRegion)(pDraw, &region, pDestBuffer, pSrcBuffer);
-	DRI2SwapComplete(client, pDraw, target_msc, 0, 0, DRI2_BLIT_COMPLETE,
-			 func, data);
-	return Success;
-    }
-
-    /*
-     * In the simple glXSwapBuffers case, all params will be 0, and we just
-     * need to schedule a swap for the last swap target + the swap interval.
-     */
-    if (target_msc == 0 && divisor == 0 && remainder == 0) {
-	/*
-	 * Swap target for this swap is last swap target + swap interval since
-	 * we have to account for the current swap count, interval, and the
-	 * number of pending swaps.
-	 */
-	*swap_target = pPriv->last_swap_target + pPriv->swap_interval;
-    } else {
-	/* glXSwapBuffersMscOML could have a 0 target_msc, honor it */
-	*swap_target = target_msc;
-    }
-
-    pPriv->swapsPending++;
-    ret = (*ds->ScheduleSwap)(client, pDraw, pDestBuffer, pSrcBuffer,
-			      swap_target, divisor, remainder, func, data);
-    if (!ret) {
-	pPriv->swapsPending--; /* didn't schedule */
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: driver failed to schedule swap\n", __func__);
-	return BadDrawable;
-    }
-
-    pPriv->last_swap_target = *swap_target;
-
-    /* According to spec, return expected swapbuffers count SBC after this swap
-     * will complete.
-     */
-    *swap_target = pPriv->swap_count + pPriv->swapsPending;
-
-    DRI2InvalidateDrawable(pDraw);
-
-    return Success;
-}
-
-void
-DRI2SwapInterval(DrawablePtr pDrawable, int interval)
-{
-    ScreenPtr       pScreen = pDrawable->pScreen;
-    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDrawable);
-
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return;
-    }
-
-    /* fixme: check against arbitrary max? */
-    pPriv->swap_interval = interval;
-}
-
-int
-DRI2GetMSC(DrawablePtr pDraw, CARD64 *ust, CARD64 *msc, CARD64 *sbc)
-{
-    ScreenPtr pScreen = pDraw->pScreen;
-    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    Bool ret;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return BadDrawable;
-    }
-
-    if (!ds->GetMSC) {
-	*ust = 0;
-	*msc = 0;
-	*sbc = pPriv->swap_count;
-	return Success;
-    }
-
-    /*
-     * Spec needs to be updated to include unmapped or redirected
-     * drawables
-     */
-
-    ret = (*ds->GetMSC)(pDraw, ust, msc);
-    if (!ret)
-	return BadDrawable;
-
-    *sbc = pPriv->swap_count;
-
-    return Success;
-}
-
-int
-DRI2WaitMSC(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
-	    CARD64 divisor, CARD64 remainder)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    Bool ret;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return BadDrawable;
-
-    /* Old DDX just completes immediately */
-    if (!ds->ScheduleWaitMSC) {
-	DRI2WaitMSCComplete(client, pDraw, target_msc, 0, 0);
-
-	return Success;
-    }
-
-    ret = (*ds->ScheduleWaitMSC)(client, pDraw, target_msc, divisor, remainder);
-    if (!ret)
-	return BadDrawable;
-
-    return Success;
-}
-
-int
-DRI2WaitSBC(ClientPtr client, DrawablePtr pDraw, CARD64 target_sbc,
-	    CARD64 *ust, CARD64 *msc, CARD64 *sbc)
-{
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return BadDrawable;
-
-    /* target_sbc == 0 means to block until all pending swaps are
-     * finished. Recalculate target_sbc to get that behaviour.
-     */
-    if (target_sbc == 0)
-        target_sbc = pPriv->swap_count + pPriv->swapsPending;
-
-    /* If current swap count already >= target_sbc,
-     * return immediately with (ust, msc, sbc) triplet of
-     * most recent completed swap.
-     */
-    if (pPriv->swap_count >= target_sbc) {
-        *sbc = pPriv->swap_count;
-        *msc = pPriv->last_swap_msc;
-        *ust = pPriv->last_swap_ust;
-        return Success;
-    }
-
-    pPriv->target_sbc = target_sbc;
-    __DRI2BlockClient(client, pPriv);
-
-    return Success;
-}
-
-Bool
-DRI2HasSwapControl(ScreenPtr pScreen)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
-
-    return (ds->ScheduleSwap && ds->GetMSC);
-}
-
-Bool
-DRI2Connect(ScreenPtr pScreen, unsigned int driverType, int *fd,
-	    const char **driverName, const char **deviceName)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
-
-    if (ds == NULL || driverType >= ds->numDrivers ||
-	    !ds->driverNames[driverType])
-	return FALSE;
-
-    *fd = ds->fd;
-    *driverName = ds->driverNames[driverType];
-    *deviceName = ds->deviceName;
-
-    return TRUE;
-}
-
-Bool
-DRI2Authenticate(ScreenPtr pScreen, drm_magic_t magic)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
-
-    if (ds == NULL || drmAuthMagic(ds->fd, magic))
-	return FALSE;
-
-    return TRUE;
-}
-
-static void
-DRI2ConfigNotify(WindowPtr pWin, int x, int y, int w, int h, int bw,
-		 WindowPtr pSib)
-{
-    DrawablePtr pDraw = (DrawablePtr)pWin;
-    ScreenPtr pScreen = pDraw->pScreen;
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
-    DRI2DrawablePtr dd = DRI2GetDrawable(pDraw);
-
-    if (ds->ConfigNotify) {
-	pScreen->ConfigNotify = ds->ConfigNotify;
-
-	(*pScreen->ConfigNotify)(pWin, x, y, w, h, bw, pSib);
-
-	ds->ConfigNotify = pScreen->ConfigNotify;
-	pScreen->ConfigNotify = DRI2ConfigNotify;
-    }
-
-    if (!dd || (dd->width == w && dd->height == h))
-	return;
-
-    DRI2InvalidateDrawable(pDraw);
-}
-
-Bool
-DRI2ScreenInit(ScreenPtr pScreen, DRI2InfoPtr info)
-{
-    DRI2ScreenPtr ds;
-    const char* driverTypeNames[] = {
-	"DRI", /* DRI2DriverDRI */
-	"VDPAU", /* DRI2DriverVDPAU */
-    };
-    unsigned int i;
-    CARD8 cur_minor;
-
-    if (info->version < 3)
-	return FALSE;
-
-    if (!xf86VGAarbiterAllowDRI(pScreen)) {
-        xf86DrvMsg(pScreen->myNum, X_WARNING,
-                  "[DRI2] Direct rendering is not supported when VGA arb is necessary for the device\n");
-        return FALSE;
-    }
-
-    ds = calloc(1, sizeof *ds);
-    if (!ds)
-	return FALSE;
-
-    ds->screen         = pScreen;
-    ds->fd	       = info->fd;
-    ds->deviceName     = info->deviceName;
-    dri2_major         = 1;
-
-    ds->CreateBuffer   = info->CreateBuffer;
-    ds->DestroyBuffer  = info->DestroyBuffer;
-    ds->CopyRegion     = info->CopyRegion;
-
-    if (info->version >= 4) {
-	ds->ScheduleSwap = info->ScheduleSwap;
-	ds->ScheduleWaitMSC = info->ScheduleWaitMSC;
-	ds->GetMSC = info->GetMSC;
-	cur_minor = 3;
-    } else {
-	cur_minor = 1;
-    }
-
-    /* Initialize minor if needed and set to minimum provied by DDX */
-    if (!dri2_minor || dri2_minor > cur_minor)
-	dri2_minor = cur_minor;
-
-    if (info->version == 3 || info->numDrivers == 0) {
-	/* Driver too old: use the old-style driverName field */
-	ds->numDrivers = 1;
-	ds->driverNames = malloc(sizeof(*ds->driverNames));
-	if (!ds->driverNames) {
-	    free(ds);
-	    return FALSE;
-	}
-	ds->driverNames[0] = info->driverName;
-    } else {
-	ds->numDrivers = info->numDrivers;
-	ds->driverNames = malloc(info->numDrivers * sizeof(*ds->driverNames));
-	if (!ds->driverNames) {
-	    free(ds);
-	    return FALSE;
-	}
-	memcpy(ds->driverNames, info->driverNames,
-	       info->numDrivers * sizeof(*ds->driverNames));
-    }
-
-    dixSetPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey, ds);
-
-    ds->ConfigNotify = pScreen->ConfigNotify;
-    pScreen->ConfigNotify = DRI2ConfigNotify;
-
-    xf86DrvMsg(pScreen->myNum, X_INFO, "[DRI2] Setup complete\n");
-    for (i = 0; i < sizeof(driverTypeNames) / sizeof(driverTypeNames[0]); i++) {
-	if (i < ds->numDrivers && ds->driverNames[i]) {
-	    xf86DrvMsg(pScreen->myNum, X_INFO, "[DRI2]   %s driver: %s\n",
-		       driverTypeNames[i], ds->driverNames[i]);
-	}
-    }
-
-    return TRUE;
-}
-
-void
-DRI2CloseScreen(ScreenPtr pScreen)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
-
-    free(ds->driverNames);
-    free(ds);
-    dixSetPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey, NULL);
-}
-
-extern ExtensionModule dri2ExtensionModule;
-
-static pointer
-DRI2Setup(pointer module, pointer opts, int *errmaj, int *errmin)
-{
-    static Bool setupDone = FALSE;
-
-    dri2DrawableRes = CreateNewResourceType(DRI2DrawableGone, "DRI2Drawable");
-
-    if (!setupDone)
-    {
-	setupDone = TRUE;
-	LoadExtension(&dri2ExtensionModule, FALSE);
-    }
-    else
-    {
-	if (errmaj)
-	    *errmaj = LDR_ONCEONLY;
-    }
-
-    return (pointer) 1;
-}
-
-static XF86ModuleVersionInfo DRI2VersRec =
-{
-    "dri2",
-    MODULEVENDORSTRING,
-    MODINFOSTRING1,
-    MODINFOSTRING2,
-    XORG_VERSION_CURRENT,
-    1, 2, 0,
-    ABI_CLASS_EXTENSION,
-    ABI_EXTENSION_VERSION,
-    MOD_CLASS_NONE,
-    { 0, 0, 0, 0 }
-};
-
-_X_EXPORT XF86ModuleData dri2ModuleData = { &DRI2VersRec, DRI2Setup, NULL };
-
-void
-DRI2Version(int *major, int *minor)
-{
-    if (major != NULL)
-	*major = DRI2VersRec.majorversion;
-
-    if (minor != NULL)
-	*minor = DRI2VersRec.minorversion;
-}
+/*

+ * Copyright © 2007, 2008 Red Hat, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Soft-

+ * ware"), to deal in the Software without restriction, including without

+ * limitation the rights to use, copy, modify, merge, publish, distribute,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, provided that the above copyright

+ * notice(s) and this permission notice appear in all copies of the Soft-

+ * ware and that both the above copyright notice(s) and this permission

+ * notice appear in supporting documentation.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-

+ * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY

+ * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN

+ * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-

+ * QUENTIAL 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 PERFOR-

+ * MANCE OF THIS SOFTWARE.

+ *

+ * Except as contained in this notice, the name of a copyright holder shall

+ * not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization of

+ * the copyright holder.

+ *

+ * Authors:

+ *   Kristian Høgsberg (krh@redhat.com)

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <errno.h>

+#ifdef WITH_LIBDRM

+#include <xf86drm.h>

+#endif

+#include "xf86Module.h"

+#include "list.h"

+#include "scrnintstr.h"

+#include "windowstr.h"

+#include "dixstruct.h"

+#include "dri2.h"

+#include "xf86VGAarbiter.h"

+

+#include "xf86.h"

+

+CARD8 dri2_major; /* version of DRI2 supported by DDX */

+CARD8 dri2_minor;

+

+static DevPrivateKeyRec dri2ScreenPrivateKeyRec;

+#define dri2ScreenPrivateKey (&dri2ScreenPrivateKeyRec)

+

+static DevPrivateKeyRec dri2WindowPrivateKeyRec;

+#define dri2WindowPrivateKey (&dri2WindowPrivateKeyRec)

+

+static DevPrivateKeyRec dri2PixmapPrivateKeyRec;

+#define dri2PixmapPrivateKey (&dri2PixmapPrivateKeyRec)

+

+static RESTYPE       dri2DrawableRes;

+

+typedef struct _DRI2Screen *DRI2ScreenPtr;

+

+typedef struct _DRI2Drawable {

+    DRI2ScreenPtr        dri2_screen;

+    DrawablePtr		 drawable;

+    struct list		 reference_list;

+    int			 width;

+    int			 height;

+    DRI2BufferPtr	*buffers;

+    int			 bufferCount;

+    unsigned int	 swapsPending;

+    ClientPtr		 blockedClient;

+    Bool		 blockedOnMsc;

+    int			 swap_interval;

+    CARD64		 swap_count;

+    int64_t		 target_sbc; /* -1 means no SBC wait outstanding */

+    CARD64		 last_swap_target; /* most recently queued swap target */

+    CARD64		 last_swap_msc; /* msc at completion of most recent swap */

+    CARD64		 last_swap_ust; /* ust at completion of most recent swap */

+    int			 swap_limit; /* for N-buffering */

+} DRI2DrawableRec, *DRI2DrawablePtr;

+

+typedef struct _DRI2Screen {

+    ScreenPtr			 screen;

+    int				 refcnt;

+    unsigned int		 numDrivers;

+    const char			**driverNames;

+    const char			*deviceName;

+    int				 fd;

+    unsigned int		 lastSequence;

+

+    DRI2CreateBufferProcPtr	 CreateBuffer;

+    DRI2DestroyBufferProcPtr	 DestroyBuffer;

+    DRI2CopyRegionProcPtr	 CopyRegion;

+    DRI2ScheduleSwapProcPtr	 ScheduleSwap;

+    DRI2GetMSCProcPtr		 GetMSC;

+    DRI2ScheduleWaitMSCProcPtr	 ScheduleWaitMSC;

+    DRI2AuthMagicProcPtr	 AuthMagic;

+

+    HandleExposuresProcPtr       HandleExposures;

+

+    ConfigNotifyProcPtr		 ConfigNotify;

+} DRI2ScreenRec;

+

+static DRI2ScreenPtr

+DRI2GetScreen(ScreenPtr pScreen)

+{

+    return dixLookupPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey);

+}

+

+static DRI2DrawablePtr

+DRI2GetDrawable(DrawablePtr pDraw)

+{

+    WindowPtr pWin;

+    PixmapPtr pPixmap;

+

+    switch (pDraw->type) {

+    case DRAWABLE_WINDOW:

+	pWin = (WindowPtr) pDraw;

+	return dixLookupPrivate(&pWin->devPrivates, dri2WindowPrivateKey);

+    case DRAWABLE_PIXMAP:

+	pPixmap = (PixmapPtr) pDraw;

+	return dixLookupPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey);

+    default:

+	return NULL;

+    }

+}

+

+static DRI2DrawablePtr

+DRI2AllocateDrawable(DrawablePtr pDraw)

+{

+    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    CARD64          ust;

+    WindowPtr pWin;

+    PixmapPtr pPixmap;

+

+    pPriv = malloc(sizeof *pPriv);

+    if (pPriv == NULL)

+	return NULL;

+

+    pPriv->dri2_screen = ds;

+    pPriv->drawable = pDraw;

+    pPriv->width = pDraw->width;

+    pPriv->height = pDraw->height;

+    pPriv->buffers = NULL;

+    pPriv->bufferCount = 0;

+    pPriv->swapsPending = 0;

+    pPriv->blockedClient = NULL;

+    pPriv->blockedOnMsc = FALSE;

+    pPriv->swap_count = 0;

+    pPriv->target_sbc = -1;

+    pPriv->swap_interval = 1;

+    /* Initialize last swap target from DDX if possible */

+    if (!ds->GetMSC || !(*ds->GetMSC)(pDraw, &ust, &pPriv->last_swap_target))

+	pPriv->last_swap_target = 0;

+

+    pPriv->swap_limit = 1; /* default to double buffering */

+    pPriv->last_swap_msc = 0;

+    pPriv->last_swap_ust = 0;

+    list_init(&pPriv->reference_list);

+

+    if (pDraw->type == DRAWABLE_WINDOW) {

+	pWin = (WindowPtr) pDraw;

+	dixSetPrivate(&pWin->devPrivates, dri2WindowPrivateKey, pPriv);

+    } else {

+	pPixmap = (PixmapPtr) pDraw;

+	dixSetPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey, pPriv);

+    }

+

+    return pPriv;

+}

+

+typedef struct DRI2DrawableRefRec {

+    XID		  id;

+    XID		  dri2_id;

+    DRI2InvalidateProcPtr	invalidate;

+    void	 *priv;

+    struct list	  link;

+} DRI2DrawableRefRec, *DRI2DrawableRefPtr;

+

+static DRI2DrawableRefPtr

+DRI2LookupDrawableRef(DRI2DrawablePtr pPriv, XID id)

+{

+    DRI2DrawableRefPtr ref;

+

+    list_for_each_entry(ref, &pPriv->reference_list, link) {

+	if (ref->id == id)

+	    return ref;

+    }

+    

+    return NULL;

+}

+

+static int

+DRI2AddDrawableRef(DRI2DrawablePtr pPriv, XID id, XID dri2_id,

+		   DRI2InvalidateProcPtr invalidate, void *priv)

+{

+    DRI2DrawableRefPtr ref;

+

+    ref = malloc(sizeof *ref);

+    if (ref == NULL)

+	return BadAlloc;

+	

+    if (!AddResource(dri2_id, dri2DrawableRes, pPriv))

+	return BadAlloc;

+    if (!DRI2LookupDrawableRef(pPriv, id))

+	if (!AddResource(id, dri2DrawableRes, pPriv))

+	    return BadAlloc;

+

+    ref->id = id;

+    ref->dri2_id = dri2_id; 

+    ref->invalidate = invalidate;

+    ref->priv = priv;

+    list_add(&ref->link, &pPriv->reference_list);

+

+    return Success;

+}

+

+int

+DRI2CreateDrawable(ClientPtr client, DrawablePtr pDraw, XID id,

+		   DRI2InvalidateProcPtr invalidate, void *priv)

+{

+    DRI2DrawablePtr pPriv;

+    XID dri2_id;

+    int rc;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	pPriv = DRI2AllocateDrawable(pDraw);

+    if (pPriv == NULL)

+	return BadAlloc;

+    

+    dri2_id = FakeClientID(client->index);

+    rc = DRI2AddDrawableRef(pPriv, id, dri2_id, invalidate, priv);

+    if (rc != Success)

+	return rc;

+

+    return Success;

+}

+

+static int DRI2DrawableGone(pointer p, XID id)

+{

+    DRI2DrawablePtr pPriv = p;

+    DRI2ScreenPtr   ds = pPriv->dri2_screen;

+    DRI2DrawableRefPtr ref, next;

+    WindowPtr pWin;

+    PixmapPtr pPixmap;

+    DrawablePtr pDraw;

+    int i;

+

+    list_for_each_entry_safe(ref, next, &pPriv->reference_list, link) {

+	if (ref->dri2_id == id) {

+	    list_del(&ref->link);

+	    /* If this was the last ref under this X drawable XID,

+	     * unregister the X drawable resource. */

+	    if (!DRI2LookupDrawableRef(pPriv, ref->id))

+		FreeResourceByType(ref->id, dri2DrawableRes, TRUE);

+	    free(ref);

+	    break;

+	}

+

+	if (ref->id == id) {

+	    list_del(&ref->link);

+	    FreeResourceByType(ref->dri2_id, dri2DrawableRes, TRUE);

+	    free(ref);

+	}

+    }

+

+    if (!list_is_empty(&pPriv->reference_list))

+	return Success;

+

+    pDraw = pPriv->drawable;

+    if (pDraw->type == DRAWABLE_WINDOW) {

+	pWin = (WindowPtr) pDraw;

+	dixSetPrivate(&pWin->devPrivates, dri2WindowPrivateKey, NULL);

+    } else {

+	pPixmap = (PixmapPtr) pDraw;

+	dixSetPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey, NULL);

+    }

+

+    if (pPriv->buffers != NULL) {

+	for (i = 0; i < pPriv->bufferCount; i++)

+	    (*ds->DestroyBuffer)(pDraw, pPriv->buffers[i]);

+

+	free(pPriv->buffers);

+    }

+

+    free(pPriv);

+

+    return Success;

+}

+

+static int

+find_attachment(DRI2DrawablePtr pPriv, unsigned attachment)

+{

+    int i;

+

+    if (pPriv->buffers == NULL) {

+	return -1;

+    }

+

+    for (i = 0; i < pPriv->bufferCount; i++) {

+	if ((pPriv->buffers[i] != NULL)

+	    && (pPriv->buffers[i]->attachment == attachment)) {

+	    return i;

+	}

+    }

+

+    return -1;

+}

+

+static Bool

+allocate_or_reuse_buffer(DrawablePtr pDraw, DRI2ScreenPtr ds,

+			 DRI2DrawablePtr pPriv,

+			 unsigned int attachment, unsigned int format,

+			 int dimensions_match, DRI2BufferPtr *buffer)

+{

+    int old_buf = find_attachment(pPriv, attachment);

+

+    if ((old_buf < 0)

+	|| !dimensions_match

+	|| (pPriv->buffers[old_buf]->format != format)) {

+	*buffer = (*ds->CreateBuffer)(pDraw, attachment, format);

+	return TRUE;

+

+    } else {

+	*buffer = pPriv->buffers[old_buf];

+	pPriv->buffers[old_buf] = NULL;

+	return FALSE;

+    }

+}

+

+static void

+update_dri2_drawable_buffers(DRI2DrawablePtr pPriv, DrawablePtr pDraw,

+			     DRI2BufferPtr *buffers, int *out_count, int *width, int *height)

+{

+    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);

+    int i;

+

+    if (pPriv->buffers != NULL) {

+	for (i = 0; i < pPriv->bufferCount; i++) {

+	    if (pPriv->buffers[i] != NULL) {

+		(*ds->DestroyBuffer)(pDraw, pPriv->buffers[i]);

+	    }

+	}

+

+	free(pPriv->buffers);

+    }

+

+    pPriv->buffers = buffers;

+    pPriv->bufferCount = *out_count;

+    pPriv->width = pDraw->width;

+    pPriv->height = pDraw->height;

+    *width = pPriv->width;

+    *height = pPriv->height;

+}

+

+static DRI2BufferPtr *

+do_get_buffers(DrawablePtr pDraw, int *width, int *height,

+	       unsigned int *attachments, int count, int *out_count,

+	       int has_format)

+{

+    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);

+    DRI2BufferPtr  *buffers;

+    int need_real_front = 0;

+    int need_fake_front = 0;

+    int have_fake_front = 0;

+    int front_format = 0;

+    int dimensions_match;

+    int buffers_changed = 0;

+    int i;

+

+    if (!pPriv) {

+	*width = pDraw->width;

+	*height = pDraw->height;

+	*out_count = 0;

+	return NULL;

+    }

+

+    dimensions_match = (pDraw->width == pPriv->width)

+	&& (pDraw->height == pPriv->height);

+

+    buffers = malloc((count + 1) * sizeof(buffers[0]));

+

+    for (i = 0; i < count; i++) {

+	const unsigned attachment = *(attachments++);

+	const unsigned format = (has_format) ? *(attachments++) : 0;

+

+	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, attachment,

+				     format, dimensions_match,

+				     &buffers[i]))

+		buffers_changed = 1;

+

+	if (buffers[i] == NULL)

+	    goto err_out;

+

+	/* If the drawable is a window and the front-buffer is requested,

+	 * silently add the fake front-buffer to the list of requested

+	 * attachments.  The counting logic in the loop accounts for the case

+	 * where the client requests both the fake and real front-buffer.

+	 */

+	if (attachment == DRI2BufferBackLeft) {

+	    need_real_front++;

+	    front_format = format;

+	}

+

+	if (attachment == DRI2BufferFrontLeft) {

+	    need_real_front--;

+	    front_format = format;

+

+	    if (pDraw->type == DRAWABLE_WINDOW) {

+		need_fake_front++;

+	    }

+	}

+

+	if (pDraw->type == DRAWABLE_WINDOW) {

+	    if (attachment == DRI2BufferFakeFrontLeft) {

+		need_fake_front--;

+		have_fake_front = 1;

+	    }

+	}

+    }

+

+    if (need_real_front > 0) {

+	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, DRI2BufferFrontLeft,

+				     front_format, dimensions_match,

+				     &buffers[i]))

+	    buffers_changed = 1;

+

+	if (buffers[i] == NULL)

+	    goto err_out;

+	i++;

+    }

+

+    if (need_fake_front > 0) {

+	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, DRI2BufferFakeFrontLeft,

+				     front_format, dimensions_match,

+				     &buffers[i]))

+	    buffers_changed = 1;

+

+	if (buffers[i] == NULL)

+	    goto err_out;

+

+	i++;

+	have_fake_front = 1;

+    }

+

+    *out_count = i;

+

+    update_dri2_drawable_buffers(pPriv, pDraw, buffers, out_count, width, height);

+

+    /* If the client is getting a fake front-buffer, pre-fill it with the

+     * contents of the real front-buffer.  This ensures correct operation of

+     * applications that call glXWaitX before calling glDrawBuffer.

+     */

+    if (have_fake_front && buffers_changed) {

+	BoxRec box;

+	RegionRec region;

+

+	box.x1 = 0;

+	box.y1 = 0;

+	box.x2 = pPriv->width;

+	box.y2 = pPriv->height;

+	RegionInit(&region, &box, 0);

+

+	DRI2CopyRegion(pDraw, &region, DRI2BufferFakeFrontLeft,

+		       DRI2BufferFrontLeft);

+    }

+

+    return pPriv->buffers;

+

+err_out:

+

+    *out_count = 0;

+

+    for (i = 0; i < count; i++) {

+	    if (buffers[i] != NULL)

+		    (*ds->DestroyBuffer)(pDraw, buffers[i]);

+    }

+

+    free(buffers);

+    buffers = NULL;

+

+    update_dri2_drawable_buffers(pPriv, pDraw, buffers, out_count, width, height);

+

+    return buffers;

+}

+

+DRI2BufferPtr *

+DRI2GetBuffers(DrawablePtr pDraw, int *width, int *height,

+	       unsigned int *attachments, int count, int *out_count)

+{

+    return do_get_buffers(pDraw, width, height, attachments, count,

+			  out_count, FALSE);

+}

+

+DRI2BufferPtr *

+DRI2GetBuffersWithFormat(DrawablePtr pDraw, int *width, int *height,

+			 unsigned int *attachments, int count, int *out_count)

+{

+    return do_get_buffers(pDraw, width, height, attachments, count,

+			  out_count, TRUE);

+}

+

+static void

+DRI2InvalidateDrawable(DrawablePtr pDraw)

+{

+    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);

+    DRI2DrawableRefPtr ref;

+

+    if (!pPriv)

+        return;

+

+    list_for_each_entry(ref, &pPriv->reference_list, link)

+	ref->invalidate(pDraw, ref->priv);

+}

+

+/*

+ * In the direct rendered case, we throttle the clients that have more

+ * than their share of outstanding swaps (and thus busy buffers) when a

+ * new GetBuffers request is received.  In the AIGLX case, we allow the

+ * client to get the new buffers, but throttle when the next GLX request

+ * comes in (see __glXDRIcontextWait()).

+ */

+Bool

+DRI2ThrottleClient(ClientPtr client, DrawablePtr pDraw)

+{

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return FALSE;

+

+    /* Throttle to swap limit */

+    if ((pPriv->swapsPending >= pPriv->swap_limit) &&

+	!pPriv->blockedClient) {

+	ResetCurrentRequest(client);

+	client->sequence--;

+	IgnoreClient(client);

+	pPriv->blockedClient = client;

+	return TRUE;

+    }

+

+    return FALSE;

+}

+

+static void

+__DRI2BlockClient(ClientPtr client, DRI2DrawablePtr pPriv)

+{

+    if (pPriv->blockedClient == NULL) {

+	IgnoreClient(client);

+	pPriv->blockedClient = client;

+    }

+}

+

+void

+DRI2BlockClient(ClientPtr client, DrawablePtr pDraw)

+{

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return;

+

+    __DRI2BlockClient(client, pPriv);

+    pPriv->blockedOnMsc = TRUE;

+}

+

+int

+DRI2CopyRegion(DrawablePtr pDraw, RegionPtr pRegion,

+	       unsigned int dest, unsigned int src)

+{

+    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    DRI2BufferPtr   pDestBuffer, pSrcBuffer;

+    int		    i;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return BadDrawable;

+

+    pDestBuffer = NULL;

+    pSrcBuffer = NULL;

+    for (i = 0; i < pPriv->bufferCount; i++)

+    {

+	if (pPriv->buffers[i]->attachment == dest)

+	    pDestBuffer = (DRI2BufferPtr) pPriv->buffers[i];

+	if (pPriv->buffers[i]->attachment == src)

+	    pSrcBuffer = (DRI2BufferPtr) pPriv->buffers[i];

+    }

+    if (pSrcBuffer == NULL || pDestBuffer == NULL)

+	return BadValue;

+

+    (*ds->CopyRegion)(pDraw, pRegion, pDestBuffer, pSrcBuffer);

+

+    return Success;

+}

+

+/* Can this drawable be page flipped? */

+Bool

+DRI2CanFlip(DrawablePtr pDraw)

+{

+    ScreenPtr pScreen = pDraw->pScreen;

+    WindowPtr pWin, pRoot;

+    PixmapPtr pWinPixmap, pRootPixmap;

+

+    if (pDraw->type == DRAWABLE_PIXMAP)

+	return TRUE;

+

+    pRoot = pScreen->root;

+    pRootPixmap = pScreen->GetWindowPixmap(pRoot);

+

+    pWin = (WindowPtr) pDraw;

+    pWinPixmap = pScreen->GetWindowPixmap(pWin);

+    if (pRootPixmap != pWinPixmap)

+	return FALSE;

+    if (!RegionEqual(&pWin->clipList, &pRoot->winSize))

+	return FALSE;

+

+    return TRUE;

+}

+

+/* Can we do a pixmap exchange instead of a blit? */

+Bool

+DRI2CanExchange(DrawablePtr pDraw)

+{

+    return FALSE;

+}

+

+void

+DRI2WaitMSCComplete(ClientPtr client, DrawablePtr pDraw, int frame,

+		    unsigned int tv_sec, unsigned int tv_usec)

+{

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return;

+

+    ProcDRI2WaitMSCReply(client, ((CARD64)tv_sec * 1000000) + tv_usec,

+			 frame, pPriv->swap_count);

+

+    if (pPriv->blockedClient)

+	AttendClient(pPriv->blockedClient);

+

+    pPriv->blockedClient = NULL;

+    pPriv->blockedOnMsc = FALSE;

+}

+

+static void

+DRI2WakeClient(ClientPtr client, DrawablePtr pDraw, int frame,

+	       unsigned int tv_sec, unsigned int tv_usec)

+{

+    ScreenPtr	    pScreen = pDraw->pScreen;

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return;

+    }

+

+    /*

+     * Swap completed.

+     * Wake the client iff:

+     *   - it was waiting on SBC

+     *   - was blocked due to GLX make current

+     *   - was blocked due to swap throttling

+     *   - is not blocked due to an MSC wait

+     */

+    if (pPriv->target_sbc != -1 &&

+	pPriv->target_sbc <= pPriv->swap_count) {

+	ProcDRI2WaitMSCReply(client, ((CARD64)tv_sec * 1000000) + tv_usec,

+			     frame, pPriv->swap_count);

+	pPriv->target_sbc = -1;

+

+	AttendClient(pPriv->blockedClient);

+	pPriv->blockedClient = NULL;

+    } else if (pPriv->target_sbc == -1 && !pPriv->blockedOnMsc) {

+	if (pPriv->blockedClient) {

+	    AttendClient(pPriv->blockedClient);

+	    pPriv->blockedClient = NULL;

+	}

+    }

+}

+

+void

+DRI2SwapComplete(ClientPtr client, DrawablePtr pDraw, int frame,

+		   unsigned int tv_sec, unsigned int tv_usec, int type,

+		   DRI2SwapEventPtr swap_complete, void *swap_data)

+{

+    ScreenPtr	    pScreen = pDraw->pScreen;

+    DRI2DrawablePtr pPriv;

+    CARD64          ust = 0;

+    BoxRec          box;

+    RegionRec       region;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return;

+    }

+

+    pPriv->swapsPending--;

+    pPriv->swap_count++;

+

+    box.x1 = 0;

+    box.y1 = 0;

+    box.x2 = pDraw->width;

+    box.y2 = pDraw->height;

+    RegionInit(&region, &box, 0);

+    DRI2CopyRegion(pDraw, &region, DRI2BufferFakeFrontLeft,

+		   DRI2BufferFrontLeft);

+

+    ust = ((CARD64)tv_sec * 1000000) + tv_usec;

+    if (swap_complete)

+	swap_complete(client, swap_data, type, ust, frame, pPriv->swap_count);

+

+    pPriv->last_swap_msc = frame;

+    pPriv->last_swap_ust = ust;

+

+    DRI2WakeClient(client, pDraw, frame, tv_sec, tv_usec);

+}

+

+Bool

+DRI2WaitSwap(ClientPtr client, DrawablePtr pDrawable)

+{

+    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDrawable);

+

+    /* If we're currently waiting for a swap on this drawable, reset

+     * the request and suspend the client.  We only support one

+     * blocked client per drawable. */

+    if ((pPriv->swapsPending) &&

+	pPriv->blockedClient == NULL) {

+	ResetCurrentRequest(client);

+	client->sequence--;

+	__DRI2BlockClient(client, pPriv);

+	return TRUE;

+    }

+

+    return FALSE;

+}

+

+int

+DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,

+		CARD64 divisor, CARD64 remainder, CARD64 *swap_target,

+		DRI2SwapEventPtr func, void *data)

+{

+    ScreenPtr       pScreen = pDraw->pScreen;

+    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    DRI2BufferPtr   pDestBuffer = NULL, pSrcBuffer = NULL;

+    int             ret, i;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return BadDrawable;

+    }

+

+    for (i = 0; i < pPriv->bufferCount; i++) {

+	if (pPriv->buffers[i]->attachment == DRI2BufferFrontLeft)

+	    pDestBuffer = (DRI2BufferPtr) pPriv->buffers[i];

+	if (pPriv->buffers[i]->attachment == DRI2BufferBackLeft)

+	    pSrcBuffer = (DRI2BufferPtr) pPriv->buffers[i];

+    }

+    if (pSrcBuffer == NULL || pDestBuffer == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: drawable has no back or front?\n", __func__);

+	return BadDrawable;

+    }

+

+    /* Old DDX or no swap interval, just blit */

+    if (!ds->ScheduleSwap || !pPriv->swap_interval) {

+	BoxRec box;

+	RegionRec region;

+

+	box.x1 = 0;

+	box.y1 = 0;

+	box.x2 = pDraw->width;

+	box.y2 = pDraw->height;

+	RegionInit(&region, &box, 0);

+

+	pPriv->swapsPending++;

+

+	(*ds->CopyRegion)(pDraw, &region, pDestBuffer, pSrcBuffer);

+	DRI2SwapComplete(client, pDraw, target_msc, 0, 0, DRI2_BLIT_COMPLETE,

+			 func, data);

+	return Success;

+    }

+

+    /*

+     * In the simple glXSwapBuffers case, all params will be 0, and we just

+     * need to schedule a swap for the last swap target + the swap interval.

+     */

+    if (target_msc == 0 && divisor == 0 && remainder == 0) {

+	/*

+	 * Swap target for this swap is last swap target + swap interval since

+	 * we have to account for the current swap count, interval, and the

+	 * number of pending swaps.

+	 */

+	*swap_target = pPriv->last_swap_target + pPriv->swap_interval;

+    } else {

+	/* glXSwapBuffersMscOML could have a 0 target_msc, honor it */

+	*swap_target = target_msc;

+    }

+

+    pPriv->swapsPending++;

+    ret = (*ds->ScheduleSwap)(client, pDraw, pDestBuffer, pSrcBuffer,

+			      swap_target, divisor, remainder, func, data);

+    if (!ret) {

+	pPriv->swapsPending--; /* didn't schedule */

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: driver failed to schedule swap\n", __func__);

+	return BadDrawable;

+    }

+

+    pPriv->last_swap_target = *swap_target;

+

+    /* According to spec, return expected swapbuffers count SBC after this swap

+     * will complete.

+     */

+    *swap_target = pPriv->swap_count + pPriv->swapsPending;

+

+    DRI2InvalidateDrawable(pDraw);

+

+    return Success;

+}

+

+void

+DRI2SwapInterval(DrawablePtr pDrawable, int interval)

+{

+    ScreenPtr       pScreen = pDrawable->pScreen;

+    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDrawable);

+

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return;

+    }

+

+    /* fixme: check against arbitrary max? */

+    pPriv->swap_interval = interval;

+}

+

+int

+DRI2GetMSC(DrawablePtr pDraw, CARD64 *ust, CARD64 *msc, CARD64 *sbc)

+{

+    ScreenPtr pScreen = pDraw->pScreen;

+    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    Bool ret;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return BadDrawable;

+    }

+

+    if (!ds->GetMSC) {

+	*ust = 0;

+	*msc = 0;

+	*sbc = pPriv->swap_count;

+	return Success;

+    }

+

+    /*

+     * Spec needs to be updated to include unmapped or redirected

+     * drawables

+     */

+

+    ret = (*ds->GetMSC)(pDraw, ust, msc);

+    if (!ret)

+	return BadDrawable;

+

+    *sbc = pPriv->swap_count;

+

+    return Success;

+}

+

+int

+DRI2WaitMSC(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,

+	    CARD64 divisor, CARD64 remainder)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    Bool ret;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return BadDrawable;

+

+    /* Old DDX just completes immediately */

+    if (!ds->ScheduleWaitMSC) {

+	DRI2WaitMSCComplete(client, pDraw, target_msc, 0, 0);

+

+	return Success;

+    }

+

+    ret = (*ds->ScheduleWaitMSC)(client, pDraw, target_msc, divisor, remainder);

+    if (!ret)

+	return BadDrawable;

+

+    return Success;

+}

+

+int

+DRI2WaitSBC(ClientPtr client, DrawablePtr pDraw, CARD64 target_sbc)

+{

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return BadDrawable;

+

+    /* target_sbc == 0 means to block until all pending swaps are

+     * finished. Recalculate target_sbc to get that behaviour.

+     */

+    if (target_sbc == 0)

+        target_sbc = pPriv->swap_count + pPriv->swapsPending;

+

+    /* If current swap count already >= target_sbc, reply and

+     * return immediately with (ust, msc, sbc) triplet of

+     * most recent completed swap.

+     */

+    if (pPriv->swap_count >= target_sbc) {

+        ProcDRI2WaitMSCReply(client, pPriv->last_swap_ust,

+                             pPriv->last_swap_msc, pPriv->swap_count);

+        return Success;

+    }

+

+    pPriv->target_sbc = target_sbc;

+    __DRI2BlockClient(client, pPriv);

+

+    return Success;

+}

+

+Bool

+DRI2HasSwapControl(ScreenPtr pScreen)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);

+

+    return ds->ScheduleSwap && ds->GetMSC;

+}

+

+Bool

+DRI2Connect(ScreenPtr pScreen, unsigned int driverType, int *fd,

+	    const char **driverName, const char **deviceName)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);

+

+    if (ds == NULL || driverType >= ds->numDrivers ||

+	    !ds->driverNames[driverType])

+	return FALSE;

+

+    *fd = ds->fd;

+    *driverName = ds->driverNames[driverType];

+    *deviceName = ds->deviceName;

+

+    return TRUE;

+}

+

+Bool

+DRI2Authenticate(ScreenPtr pScreen, uint32_t magic)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);

+

+    if (ds == NULL || (*ds->AuthMagic)(ds->fd, magic))

+        return FALSE;

+

+    return TRUE;

+}

+

+static int

+DRI2ConfigNotify(WindowPtr pWin, int x, int y, int w, int h, int bw,

+		 WindowPtr pSib)

+{

+    DrawablePtr pDraw = (DrawablePtr)pWin;

+    ScreenPtr pScreen = pDraw->pScreen;

+    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);

+    DRI2DrawablePtr dd = DRI2GetDrawable(pDraw);

+    int ret;

+

+    if (ds->ConfigNotify) {

+	pScreen->ConfigNotify = ds->ConfigNotify;

+

+	ret = (*pScreen->ConfigNotify)(pWin, x, y, w, h, bw, pSib);

+

+	ds->ConfigNotify = pScreen->ConfigNotify;

+	pScreen->ConfigNotify = DRI2ConfigNotify;

+	if (ret)

+	    return ret;

+    }

+

+    if (!dd || (dd->width == w && dd->height == h))

+	return Success;

+

+    DRI2InvalidateDrawable(pDraw);

+    return Success;

+}

+

+Bool

+DRI2ScreenInit(ScreenPtr pScreen, DRI2InfoPtr info)

+{

+    DRI2ScreenPtr ds;

+    const char* driverTypeNames[] = {

+	"DRI", /* DRI2DriverDRI */

+	"VDPAU", /* DRI2DriverVDPAU */

+    };

+    unsigned int i;

+    CARD8 cur_minor;

+

+    if (info->version < 3)

+	return FALSE;

+

+    if (!xf86VGAarbiterAllowDRI(pScreen)) {

+        xf86DrvMsg(pScreen->myNum, X_WARNING,

+                  "[DRI2] Direct rendering is not supported when VGA arb is necessary for the device\n");

+        return FALSE;

+    }

+

+    if (!dixRegisterPrivateKey(&dri2ScreenPrivateKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+

+    if (!dixRegisterPrivateKey(&dri2WindowPrivateKeyRec, PRIVATE_WINDOW, 0))

+	return FALSE;

+

+    if (!dixRegisterPrivateKey(&dri2PixmapPrivateKeyRec, PRIVATE_PIXMAP, 0))

+	return FALSE;

+

+    ds = calloc(1, sizeof *ds);

+    if (!ds)

+	return FALSE;

+

+    ds->screen         = pScreen;

+    ds->fd	       = info->fd;

+    ds->deviceName     = info->deviceName;

+    dri2_major         = 1;

+

+    ds->CreateBuffer   = info->CreateBuffer;

+    ds->DestroyBuffer  = info->DestroyBuffer;

+    ds->CopyRegion     = info->CopyRegion;

+

+    if (info->version >= 4) {

+	ds->ScheduleSwap = info->ScheduleSwap;

+	ds->ScheduleWaitMSC = info->ScheduleWaitMSC;

+	ds->GetMSC = info->GetMSC;

+	cur_minor = 3;

+    } else {

+	cur_minor = 1;

+    }

+

+    if (info->version >= 5) {

+        ds->AuthMagic = info->AuthMagic;

+    }

+

+    /*

+     * if the driver doesn't provide an AuthMagic function or the info struct

+     * version is too low, it relies on the old method (using libdrm) or fail

+     */

+    if (!ds->AuthMagic)

+#ifdef WITH_LIBDRM

+        ds->AuthMagic = drmAuthMagic;

+#else

+        goto err_out;

+#endif

+

+    /* Initialize minor if needed and set to minimum provied by DDX */

+    if (!dri2_minor || dri2_minor > cur_minor)

+	dri2_minor = cur_minor;

+

+    if (info->version == 3 || info->numDrivers == 0) {

+	/* Driver too old: use the old-style driverName field */

+	ds->numDrivers = 1;

+	ds->driverNames = malloc(sizeof(*ds->driverNames));

+	if (!ds->driverNames)

+	    goto err_out;

+	ds->driverNames[0] = info->driverName;

+    } else {

+	ds->numDrivers = info->numDrivers;

+	ds->driverNames = malloc(info->numDrivers * sizeof(*ds->driverNames));

+	if (!ds->driverNames)

+		goto err_out;

+	memcpy(ds->driverNames, info->driverNames,

+	       info->numDrivers * sizeof(*ds->driverNames));

+    }

+

+    dixSetPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey, ds);

+

+    ds->ConfigNotify = pScreen->ConfigNotify;

+    pScreen->ConfigNotify = DRI2ConfigNotify;

+

+    xf86DrvMsg(pScreen->myNum, X_INFO, "[DRI2] Setup complete\n");

+    for (i = 0; i < sizeof(driverTypeNames) / sizeof(driverTypeNames[0]); i++) {

+	if (i < ds->numDrivers && ds->driverNames[i]) {

+	    xf86DrvMsg(pScreen->myNum, X_INFO, "[DRI2]   %s driver: %s\n",

+		       driverTypeNames[i], ds->driverNames[i]);

+	}

+    }

+

+    return TRUE;

+

+err_out:

+    xf86DrvMsg(pScreen->myNum, X_WARNING,

+            "[DRI2] Initialization failed for info version %d.\n", info->version);

+    free(ds);

+    return FALSE;

+}

+

+void

+DRI2CloseScreen(ScreenPtr pScreen)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);

+

+    free(ds->driverNames);

+    free(ds);

+    dixSetPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey, NULL);

+}

+

+extern ExtensionModule dri2ExtensionModule;

+

+static pointer

+DRI2Setup(pointer module, pointer opts, int *errmaj, int *errmin)

+{

+    static Bool setupDone = FALSE;

+

+    dri2DrawableRes = CreateNewResourceType(DRI2DrawableGone, "DRI2Drawable");

+

+    if (!setupDone)

+    {

+	setupDone = TRUE;

+	LoadExtension(&dri2ExtensionModule, FALSE);

+    }

+    else

+    {

+	if (errmaj)

+	    *errmaj = LDR_ONCEONLY;

+    }

+

+    return (pointer) 1;

+}

+

+static XF86ModuleVersionInfo DRI2VersRec =

+{

+    "dri2",

+    MODULEVENDORSTRING,

+    MODINFOSTRING1,

+    MODINFOSTRING2,

+    XORG_VERSION_CURRENT,

+    1, 2, 0,

+    ABI_CLASS_EXTENSION,

+    ABI_EXTENSION_VERSION,

+    MOD_CLASS_NONE,

+    { 0, 0, 0, 0 }

+};

+

+_X_EXPORT XF86ModuleData dri2ModuleData = { &DRI2VersRec, DRI2Setup, NULL };

+

+void

+DRI2Version(int *major, int *minor)

+{

+    if (major != NULL)

+	*major = DRI2VersRec.majorversion;

+

+    if (minor != NULL)

+	*minor = DRI2VersRec.minorversion;

+}

diff --git a/xorg-server/hw/xfree86/dri2/dri2.h b/xorg-server/hw/xfree86/dri2/dri2.h
index c43aa6a04..afe2083de 100644
--- a/xorg-server/hw/xfree86/dri2/dri2.h
+++ b/xorg-server/hw/xfree86/dri2/dri2.h
@@ -66,6 +66,8 @@ typedef void		(*DRI2CopyRegionProcPtr)(DrawablePtr pDraw,
 						 DRI2BufferPtr pSrcBuffer);

 typedef void		(*DRI2WaitProcPtr)(WindowPtr pWin,

 					   unsigned int sequence);

+typedef int		(*DRI2AuthMagicProcPtr)(int fd, uint32_t magic);

+

 /**

  * Schedule a buffer swap

  *

@@ -159,7 +161,7 @@ typedef void		(*DRI2InvalidateProcPtr)(DrawablePtr pDraw,
 /**

  * Version of the DRI2InfoRec structure defined in this header

  */

-#define DRI2INFOREC_VERSION 4

+#define DRI2INFOREC_VERSION 5

 

 typedef struct {

     unsigned int version;	/**< Version of this struct */

@@ -183,6 +185,10 @@ typedef struct {
     /* array of driver names, indexed by DRI2Driver* driver types */

     /* a name of NULL means that driver is not supported */

     const char * const *driverNames;

+

+    /* added in version 5 */

+

+    DRI2AuthMagicProcPtr	AuthMagic;

 }  DRI2InfoRec, *DRI2InfoPtr;

 

 extern _X_EXPORT int DRI2EventBase;

@@ -200,7 +206,7 @@ extern _X_EXPORT Bool DRI2Connect(ScreenPtr pScreen,
 		 const char **driverName,

 		 const char **deviceName);

 

-extern _X_EXPORT Bool DRI2Authenticate(ScreenPtr pScreen, drm_magic_t magic);

+extern _X_EXPORT Bool DRI2Authenticate(ScreenPtr pScreen, uint32_t magic);

 

 extern _X_EXPORT int DRI2CreateDrawable(ClientPtr client,

 					DrawablePtr pDraw,

@@ -259,8 +265,7 @@ extern _X_EXPORT int DRI2WaitMSC(ClientPtr client, DrawablePtr pDrawable,
 extern _X_EXPORT int ProcDRI2WaitMSCReply(ClientPtr client, CARD64 ust,

 					  CARD64 msc, CARD64 sbc);

 extern _X_EXPORT int DRI2WaitSBC(ClientPtr client, DrawablePtr pDraw,

-				 CARD64 target_sbc, CARD64 *ust, CARD64 *msc,

-				 CARD64 *sbc);

+				 CARD64 target_sbc);

 extern _X_EXPORT Bool DRI2ThrottleClient(ClientPtr client, DrawablePtr pDraw);

 

 extern _X_EXPORT Bool DRI2CanFlip(DrawablePtr pDraw);

diff --git a/xorg-server/hw/xfree86/dri2/dri2ext.c b/xorg-server/hw/xfree86/dri2/dri2ext.c
index adbc9647b..6853fab9e 100644
--- a/xorg-server/hw/xfree86/dri2/dri2ext.c
+++ b/xorg-server/hw/xfree86/dri2/dri2ext.c
@@ -42,7 +42,6 @@
 #include "scrnintstr.h"

 #include "pixmapstr.h"

 #include "extnsionst.h"

-#include "xf86drm.h"

 #include "xfixes.h"

 #include "dri2.h"

 #include "protocol-versions.h"

@@ -56,7 +55,9 @@ static Bool
 validDrawable(ClientPtr client, XID drawable, Mask access_mode,

 	      DrawablePtr *pDrawable, int *status)

 {

-    *status = dixLookupDrawable(pDrawable, drawable, client, 0, access_mode);

+    *status = dixLookupDrawable(pDrawable, drawable, client,

+				M_DRAWABLE_WINDOW | M_DRAWABLE_PIXMAP,

+				access_mode);

     if (*status != Success) {

 	client->errorValue = drawable;

 	return FALSE;

@@ -521,9 +522,8 @@ static int
 ProcDRI2WaitSBC(ClientPtr client)

 {

     REQUEST(xDRI2WaitSBCReq);

-    xDRI2MSCReply rep;

     DrawablePtr pDrawable;

-    CARD64 target, ust, msc, sbc;

+    CARD64 target;

     int status;

 

     REQUEST_SIZE_MATCH(xDRI2WaitSBCReq);

@@ -533,18 +533,9 @@ ProcDRI2WaitSBC(ClientPtr client)
 	return status;

 

     target = vals_to_card64(stuff->target_sbc_lo, stuff->target_sbc_hi);

-    status = DRI2WaitSBC(client, pDrawable, target, &ust, &msc, &sbc);

-    if (status != Success)

-	return status;

+    status = DRI2WaitSBC(client, pDrawable, target);

 

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    load_msc_reply(&rep, ust, msc, sbc);

-

-    WriteToClient(client, sizeof(xDRI2MSCReply), &rep);

-

-    return Success;

+    return status;

 }

 

 static int

diff --git a/xorg-server/hw/xfree86/exa/examodule.c b/xorg-server/hw/xfree86/exa/examodule.c
index 6238582c0..356fd16ca 100644
--- a/xorg-server/hw/xfree86/exa/examodule.c
+++ b/xorg-server/hw/xfree86/exa/examodule.c
@@ -42,8 +42,8 @@ typedef struct _ExaXorgScreenPrivRec {
     OptionInfoPtr		 options;

 } ExaXorgScreenPrivRec, *ExaXorgScreenPrivPtr;

 

-static int exaXorgScreenPrivateKeyIndex;

-static DevPrivateKey exaXorgScreenPrivateKey = &exaXorgScreenPrivateKeyIndex;

+static DevPrivateKeyRec exaXorgScreenPrivateKeyRec;

+#define exaXorgScreenPrivateKey (&exaXorgScreenPrivateKeyRec)

 

 typedef enum {

     EXAOPT_MIGRATION_HEURISTIC,

@@ -114,6 +114,9 @@ exaDDXDriverInit(ScreenPtr pScreen)
     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];

     ExaXorgScreenPrivPtr pScreenPriv;

 

+    if (!dixRegisterPrivateKey(&exaXorgScreenPrivateKeyRec, PRIVATE_SCREEN, 0))

+	return;

+

     pScreenPriv = calloc(1, sizeof(ExaXorgScreenPrivRec));

     if (pScreenPriv == NULL)

 	return;

diff --git a/xorg-server/hw/xfree86/fbdevhw/Makefile.am b/xorg-server/hw/xfree86/fbdevhw/Makefile.am
index 066352556..076b9741f 100644
--- a/xorg-server/hw/xfree86/fbdevhw/Makefile.am
+++ b/xorg-server/hw/xfree86/fbdevhw/Makefile.am
@@ -1,28 +1,27 @@
-linuxmoduledir = $(moduledir)/linux
-linuxmodule_LTLIBRARIES = libfbdevhw.la
-
-libfbdevhw_la_LDFLAGS = -avoid-version
-
-if FBDEVHW
-libfbdevhw_la_SOURCES = fbdevhw.c
-else
-libfbdevhw_la_SOURCES = fbdevhwstub.c
-endif
-
-INCLUDES = $(XORG_INCS) -I$(srcdir)/../i2c
-
-AM_CFLAGS = $(DIX_CFLAGS) $(XORG_CFLAGS)
-
-sdk_HEADERS = fbdevhw.h
-
-include $(top_srcdir)/cpprules.in
-
-drivermandir = $(DRIVER_MAN_DIR)
-driverman_DATA = fbdevhw.$(DRIVER_MAN_SUFFIX)
-CLEANFILES = $(driverman_DATA) fbdevhw.man
-
-fbdevhw.$(DRIVER_MAN_SUFFIX): fbdevhw.man
-	-$(AM_V_at)rm -f fbdevhw.$(DRIVER_MAN_SUFFIX)
-	$(AM_V_at)$(LN_S) fbdevhw.man fbdevhw.$(DRIVER_MAN_SUFFIX)
-
-EXTRA_DIST = fbpriv.h fbdevhw.man.pre README
+module_LTLIBRARIES = libfbdevhw.la

+

+libfbdevhw_la_LDFLAGS = -avoid-version

+

+if FBDEVHW

+libfbdevhw_la_SOURCES = fbdevhw.c

+else

+libfbdevhw_la_SOURCES = fbdevhwstub.c

+endif

+

+INCLUDES = $(XORG_INCS) -I$(srcdir)/../i2c

+

+AM_CFLAGS = $(DIX_CFLAGS) $(XORG_CFLAGS)

+

+sdk_HEADERS = fbdevhw.h

+

+include $(top_srcdir)/cpprules.in

+

+drivermandir = $(DRIVER_MAN_DIR)

+driverman_DATA = fbdevhw.$(DRIVER_MAN_SUFFIX)

+CLEANFILES = $(driverman_DATA) fbdevhw.man

+

+fbdevhw.$(DRIVER_MAN_SUFFIX): fbdevhw.man

+	-$(AM_V_at)rm -f fbdevhw.$(DRIVER_MAN_SUFFIX)

+	$(AM_V_at)$(LN_S) fbdevhw.man fbdevhw.$(DRIVER_MAN_SUFFIX)

+

+EXTRA_DIST = fbpriv.h fbdevhw.man.pre README

diff --git a/xorg-server/hw/xfree86/int10/Makefile.am b/xorg-server/hw/xfree86/int10/Makefile.am
index 36d2ad0bb..58e1d0f25 100644
--- a/xorg-server/hw/xfree86/int10/Makefile.am
+++ b/xorg-server/hw/xfree86/int10/Makefile.am
@@ -1,45 +1,46 @@
-module_LTLIBRARIES = libint10.la
-
-sdk_HEADERS = xf86int10.h
-
-EXTRA_CFLAGS =
-
-libint10_la_LDFLAGS = -avoid-version
-
-COMMON_SOURCES = \
-	helper_exec.c \
-	helper_mem.c \
-	xf86int10.c \
-	xf86int10module.c
-
-if I386_VIDEO
-I386_VIDEO_CFLAGS = -D_PC
-endif
-
-if INT10_VM86
-AM_CFLAGS = $(I386_VIDEO_CFLAGS) -D_VM86_LINUX $(DIX_CFLAGS) $(XORG_CFLAGS) $(EXTRA_CFLAGS)
-INCLUDES = $(XORG_INCS)
-libint10_la_SOURCES = \
-	$(COMMON_SOURCES) \
-	$(srcdir)/../os-support/linux/int10/vm86/linux_vm86.c \
-	$(srcdir)/../os-support/linux/int10/linux.c
-endif
-
-if INT10_X86EMU
-AM_CFLAGS = $(I386_VIDEO_CFLAGS) -D_X86EMU -DNO_SYS_HEADERS \
-           $(XORG_CFLAGS) $(EXTRA_CFLAGS) $(DIX_CFLAGS)
-INCLUDES = $(XORG_INCS) -I$(srcdir)/../x86emu
-libint10_la_SOURCES = \
-	$(COMMON_SOURCES) \
-	xf86x86emu.c \
-	generic.c \
-	x86emu.c
-endif
-
-if INT10_STUB
-AM_CFLAGS = $(I386_VIDEO_CFLAGS) -D_VM86_LINUX $(DIX_CFLAGS) $(XORG_CFLAGS) $(EXTRA_CFLAGS)
-INCLUDES = $(XORG_INCS)
-libint10_la_SOURCES = stub.c xf86int10module.c
-endif
-
-EXTRA_DIST = xf86x86emu.h INT10.HOWTO
+module_LTLIBRARIES = libint10.la

+

+sdk_HEADERS = xf86int10.h

+

+EXTRA_CFLAGS =

+

+libint10_la_LDFLAGS = -avoid-version

+libint10_la_LIBADD = $(PCIACCESS_LIBS)

+

+COMMON_SOURCES = \

+	helper_exec.c \

+	helper_mem.c \

+	xf86int10.c \

+	xf86int10module.c

+

+if I386_VIDEO

+I386_VIDEO_CFLAGS = -D_PC

+endif

+

+if INT10_VM86

+AM_CFLAGS = $(I386_VIDEO_CFLAGS) -D_VM86_LINUX $(DIX_CFLAGS) $(XORG_CFLAGS) $(EXTRA_CFLAGS)

+INCLUDES = $(XORG_INCS)

+libint10_la_SOURCES = \

+	$(COMMON_SOURCES) \

+	$(srcdir)/../os-support/linux/int10/vm86/linux_vm86.c \

+	$(srcdir)/../os-support/linux/int10/linux.c

+endif

+

+if INT10_X86EMU

+AM_CFLAGS = $(I386_VIDEO_CFLAGS) -D_X86EMU -DNO_SYS_HEADERS \

+           $(XORG_CFLAGS) $(EXTRA_CFLAGS) $(DIX_CFLAGS)

+INCLUDES = $(XORG_INCS) -I$(srcdir)/../x86emu

+libint10_la_SOURCES = \

+	$(COMMON_SOURCES) \

+	xf86x86emu.c \

+	generic.c \

+	x86emu.c

+endif

+

+if INT10_STUB

+AM_CFLAGS = $(I386_VIDEO_CFLAGS) -D_VM86_LINUX $(DIX_CFLAGS) $(XORG_CFLAGS) $(EXTRA_CFLAGS)

+INCLUDES = $(XORG_INCS)

+libint10_la_SOURCES = stub.c xf86int10module.c

+endif

+

+EXTRA_DIST = xf86x86emu.h INT10.HOWTO

diff --git a/xorg-server/hw/xfree86/loader/loadext.c b/xorg-server/hw/xfree86/loader/loadext.c
index 26066856d..8380c300b 100644
--- a/xorg-server/hw/xfree86/loader/loadext.c
+++ b/xorg-server/hw/xfree86/loader/loadext.c
@@ -163,7 +163,7 @@ get_node(const char *name)
     for (n = graph; n && n->n_name && strcmp(n->n_name, name);

 	 n = n->n_next) ;

     if (n)

-	return (n);

+	return n;

 

     n = xnfalloc(sizeof(NODE));

 

@@ -180,7 +180,7 @@ get_node(const char *name)
     n->n_prevp = &graph;

     graph = n;

 

-    return (n);

+    return n;

 }

 

 /*

@@ -285,7 +285,7 @@ find_cycle(NODE * from, NODE * to, int longest_len, int depth)
      * to be acyclic

      */

     if (from->n_flags & (NF_NODEST | NF_MARK | NF_ACYCLIC))

-	return (0);

+	return 0;

     from->n_flags |= NF_MARK;

 

     for (np = from->n_arcs, i = from->n_narcs; --i >= 0; np++) {

@@ -317,7 +317,7 @@ find_cycle(NODE * from, NODE * to, int longest_len, int depth)
 	}

     }

     from->n_flags &= ~NF_MARK;

-    return (longest_len);

+    return longest_len;

 }

 

 /* do topological sort on graph */

@@ -378,10 +378,8 @@ tsort(void)
 	if (n == NULL)

 	    ErrorF("tsort: internal error -- could not find cycle");

     }

-    if (cycle_buf)

-	free(cycle_buf);

-    if (longest_cycle)

-	free(longest_cycle);

+    free(cycle_buf);

+    free(longest_cycle);

     if (graph)

 	free_nodes(graph);

 }

diff --git a/xorg-server/hw/xfree86/loader/loadmod.c b/xorg-server/hw/xfree86/loader/loadmod.c
index e75ec8f69..171f0521e 100644
--- a/xorg-server/hw/xfree86/loader/loadmod.c
+++ b/xorg-server/hw/xfree86/loader/loadmod.c
@@ -114,7 +114,7 @@ static char **defaultPathList = NULL;
 static Bool

 PathIsAbsolute(const char *path)

 {

-    return (*path == '/');

+    return *path == '/';

 }	

 

 /*

@@ -315,16 +315,14 @@ InitSubdirs(const char **subdirlist)
 		if (**s == '/' || **s == '\\' || strchr(*s, ':') ||

 		    strstr(*s, "..")) {

 		    xf86Msg(X_ERROR, "InitSubdirs: Bad subdir: \"%s\"\n", *s);

-		    if (tmp_subdirlist)

-			free(tmp_subdirlist);

+		    free(tmp_subdirlist);

 		    return NULL;

 		}

 	    }

 	}

 	subdirs = malloc((i * 2 + 1) * sizeof(char *));

 	if (!subdirs) {

-	    if (tmp_subdirlist)

-		free(tmp_subdirlist);

+	    free(tmp_subdirlist);

 	    return NULL;

 	}

 	i = 0;

@@ -348,8 +346,7 @@ InitSubdirs(const char **subdirlist)
 		while (--i >= 0)

 		    free(subdirs[i]);

 		free(subdirs);

-		if (tmp_subdirlist)

-		    free(tmp_subdirlist);

+		free(tmp_subdirlist);

 		return NULL;

 	    }

 	    /* tack on the OS name */

@@ -367,8 +364,7 @@ InitSubdirs(const char **subdirlist)
 	}

 	subdirs[i] = NULL;

     }

-    if (tmp_subdirlist)

-	free(tmp_subdirlist);

+    free(tmp_subdirlist);

     return (const char **)subdirs;

 }

 

@@ -743,7 +739,7 @@ static ModuleDescPtr
 AddSibling(ModuleDescPtr head, ModuleDescPtr new)

 {

     new->sib = head;

-    return (new);

+    return new;

 }

 

 pointer

@@ -793,7 +789,7 @@ NewModuleDesc(const char *name)
 	mdp->TearDownData = NULL;

     }

 

-    return (mdp);

+    return mdp;

 }

 

 ModuleDescPtr

diff --git a/xorg-server/hw/xfree86/modes/xf86Crtc.c b/xorg-server/hw/xfree86/modes/xf86Crtc.c
index 5705d7da3..9c5b3c1ad 100644
--- a/xorg-server/hw/xfree86/modes/xf86Crtc.c
+++ b/xorg-server/hw/xfree86/modes/xf86Crtc.c
@@ -157,8 +157,7 @@ xf86CrtcDestroy (xf86CrtcPtr crtc)
 	    xf86_config->num_crtc--;

 	    break;

 	}

-    if (crtc->params)

-	free(crtc->params);

+    free(crtc->params);

     free(crtc->gamma_red);

     free(crtc);

 }

@@ -382,8 +381,7 @@ done:
 	crtc->transformPresent = saved_transform_present;

     }

 

-    if (adjusted_mode->name)

-	    free(adjusted_mode->name);

+    free(adjusted_mode->name);

     free(adjusted_mode);

 

     if (didLock)

@@ -482,8 +480,7 @@ xf86OutputSetMonitor (xf86OutputPtr output)
     if (!output->name)

 	return;

 

-    if (output->options)

-	free(output->options);

+    free(output->options);

 

     output->options = xnfalloc (sizeof (xf86OutputOptions));

     memcpy (output->options, xf86OutputOptions, sizeof (xf86OutputOptions));

@@ -580,7 +577,7 @@ xf86OutputInitialRotation (xf86OutputPtr output)
     

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

 	if (xf86nameCompare (direction[i], rotate_name) == 0)

-	    return (1 << i);

+	    return 1 << i;

     return RR_Rotate_0;

 }

 

@@ -1041,8 +1038,8 @@ xf86DefaultScreenLimits (ScrnInfoPtr scrn, int *widthp, int *heightp,
 

 	if (crtc->enabled)

 	{

-	    crtc_width = crtc->x + xf86ModeWidth (&crtc->desiredMode, crtc->desiredRotation);

-	    crtc_height = crtc->y + xf86ModeHeight (&crtc->desiredMode, crtc->desiredRotation);

+	    crtc_width = crtc->desiredX + xf86ModeWidth (&crtc->desiredMode, crtc->desiredRotation);

+	    crtc_height = crtc->desiredY + xf86ModeHeight (&crtc->desiredMode, crtc->desiredRotation);

 	}

 	if (!canGrow) {

 	    for (o = 0; o < config->num_output; o++)

@@ -2204,7 +2201,7 @@ xf86TargetFallback(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
 				       target_rotation, width, height);

     }

 

-    return (target_mode != NULL);

+    return target_mode != NULL;

 }

 

 static Bool

@@ -3155,9 +3152,9 @@ xf86_crtc_clip_video_helper(ScrnInfoPtr pScrn,
 						  &crtc_box);

 

 	if (crtc) {

-	    REGION_INIT (pScreen, &crtc_region_local, &crtc_box, 1);

+	    RegionInit(&crtc_region_local, &crtc_box, 1);

 	    crtc_region = &crtc_region_local;

-	    REGION_INTERSECT (pScreen, crtc_region, crtc_region, reg);

+	    RegionIntersect(crtc_region, crtc_region, reg);

 	}

 	*crtc_ret = crtc;

     }

@@ -3166,7 +3163,7 @@ xf86_crtc_clip_video_helper(ScrnInfoPtr pScrn,
 				crtc_region, width, height);

 

     if (crtc_region != reg)

-	REGION_UNINIT (pScreen, &crtc_region_local);

+	RegionUninit(&crtc_region_local);

 

     return ret;

 }

@@ -3223,7 +3220,7 @@ xf86_crtc_supports_gamma(ScrnInfoPtr pScrn)
 	    return FALSE;

 	crtc = xf86_config->crtc[0];

 

-	return (crtc->funcs->gamma_set != NULL);

+	return crtc->funcs->gamma_set != NULL;

     }

 

     return FALSE;

diff --git a/xorg-server/hw/xfree86/modes/xf86DiDGA.c b/xorg-server/hw/xfree86/modes/xf86DiDGA.c
index 61c779edc..b2bbefa62 100644
--- a/xorg-server/hw/xfree86/modes/xf86DiDGA.c
+++ b/xorg-server/hw/xfree86/modes/xf86DiDGA.c
@@ -103,8 +103,7 @@ xf86_dga_get_modes (ScreenPtr pScreen)
 	if (display_mode == scrn->modes)

 	    break;

     }

-    if (xf86_config->dga_modes)

-	free(xf86_config->dga_modes);

+    free(xf86_config->dga_modes);

     xf86_config->dga_nmode = num;

     xf86_config->dga_modes = modes;

     return TRUE;

diff --git a/xorg-server/hw/xfree86/modes/xf86RandR12.c b/xorg-server/hw/xfree86/modes/xf86RandR12.c
index 8a4d72bd6..e49387317 100644
--- a/xorg-server/hw/xfree86/modes/xf86RandR12.c
+++ b/xorg-server/hw/xfree86/modes/xf86RandR12.c
@@ -71,7 +71,7 @@ static Bool xf86RandR12CreateScreenResources12 (ScreenPtr pScreen);
 static int xf86RandR12Generation;

 #if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)

 

-static int xf86RandR12KeyIndex;

+static DevPrivateKeyRec xf86RandR12KeyRec;

 static DevPrivateKey xf86RandR12Key;

 #define XF86RANDRINFO(p) ((XF86RandRInfoPtr) \

     dixLookupPrivate(&(p)->devPrivates, xf86RandR12Key))

@@ -517,7 +517,7 @@ xf86RandR12SetMode (ScreenPtr	    pScreen,
     int			oldHeight = pScreen->height;

     int			oldmmWidth = pScreen->mmWidth;

     int			oldmmHeight = pScreen->mmHeight;

-    WindowPtr		pRoot = WindowTable[pScreen->myNum];

+    WindowPtr		pRoot = pScreen->root;

     DisplayModePtr      currentMode = NULL;

     Bool 		ret = TRUE;

     PixmapPtr 		pspix = NULL;

@@ -685,7 +685,7 @@ xf86RandR12ScreenSetSize (ScreenPtr	pScreen,
     XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);

     ScrnInfoPtr		pScrn = XF86SCRNINFO(pScreen);

     xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(pScrn);

-    WindowPtr		pRoot = WindowTable[pScreen->myNum];

+    WindowPtr		pRoot = pScreen->root;

     PixmapPtr		pScrnPix = (*pScreen->GetScreenPixmap)(pScreen);

     Bool		ret = FALSE;

     int                 c;

@@ -739,7 +739,7 @@ finish:
     if (pRoot && pScrn->vtSema)

 	(*pScrn->EnableDisableFBAccess) (pScreen->myNum, TRUE);

 #if RANDR_12_INTERFACE

-    if (xf86RandR12Key && WindowTable[pScreen->myNum] && ret)

+    if (xf86RandR12Key && pScreen->root && ret)

 	RRScreenSizeNotify (pScreen);

 #endif

     return ret;

@@ -883,7 +883,9 @@ xf86RandR12Init (ScreenPtr pScreen)
 	xf86RandR12Generation = serverGeneration;

 

 #if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)

-    xf86RandR12Key = &xf86RandR12KeyIndex;

+    xf86RandR12Key = &xf86RandR12KeyRec;

+    if (!dixRegisterPrivateKey(&xf86RandR12KeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

 #else

     xf86RandR12Index = AllocateScreenPrivateIndex();

 #endif

diff --git a/xorg-server/hw/xfree86/modes/xf86Rotate.c b/xorg-server/hw/xfree86/modes/xf86Rotate.c
index e15c61476..f846d60ea 100644
--- a/xorg-server/hw/xfree86/modes/xf86Rotate.c
+++ b/xorg-server/hw/xfree86/modes/xf86Rotate.c
@@ -76,13 +76,13 @@ xf86RotateCrtcRedisplay (xf86CrtcPtr crtc, RegionPtr region)
 {

     ScrnInfoPtr		scrn = crtc->scrn;

     ScreenPtr		screen = scrn->pScreen;

-    WindowPtr		root = WindowTable[screen->myNum];

+    WindowPtr		root = screen->root;

     PixmapPtr		dst_pixmap = crtc->rotatedPixmap;

-    PictFormatPtr	format = compWindowFormat (WindowTable[screen->myNum]);

+    PictFormatPtr	format = compWindowFormat (screen->root);

     int			error;

     PicturePtr		src, dst;

-    int			n = REGION_NUM_RECTS(region);

-    BoxPtr		b = REGION_RECTS(region);

+    int			n = RegionNumRects(region);

+    BoxPtr		b = RegionRects(region);

     XID			include_inferiors = IncludeInferiors;

     

     src = CreatePicture (None,

@@ -167,10 +167,10 @@ xf86CrtcDamageShadow (xf86CrtcPtr crtc)
     if (damage_box.y1 < 0) damage_box.y1 = 0;

     if (damage_box.x2 > pScreen->width) damage_box.x2 = pScreen->width;

     if (damage_box.y2 > pScreen->height) damage_box.y2 = pScreen->height;

-    REGION_INIT (pScreen, &damage_region, &damage_box, 1);

+    RegionInit(&damage_region, &damage_box, 1);

     DamageRegionAppend (&(*pScreen->GetScreenPixmap)(pScreen)->drawable,

 			&damage_region);

-    REGION_UNINIT (pScreen, &damage_region);

+    RegionUninit(&damage_region);

     crtc->shadowClear = TRUE;

 }

 

@@ -217,7 +217,7 @@ xf86RotateRedisplay(ScreenPtr pScreen)
 	return FALSE;

     xf86RotatePrepare (pScreen);

     region = DamageRegion(damage);

-    if (REGION_NOTEMPTY(pScreen, region)) 

+    if (RegionNotEmpty(region))

     {

 	int			c;

 	SourceValidateProcPtr	SourceValidate;

@@ -240,14 +240,14 @@ xf86RotateRedisplay(ScreenPtr pScreen)
 		RegionRec   crtc_damage;

 

 		/* compute portion of damage that overlaps crtc */

-		REGION_INIT(pScreen, &crtc_damage, &crtc->bounds, 1);

-		REGION_INTERSECT (pScreen, &crtc_damage, &crtc_damage, region);

+		RegionInit(&crtc_damage, &crtc->bounds, 1);

+		RegionIntersect(&crtc_damage, &crtc_damage, region);

 		

 		/* update damaged region */

-		if (REGION_NOTEMPTY(pScreen, &crtc_damage))

+		if (RegionNotEmpty(&crtc_damage))

     		    xf86RotateCrtcRedisplay (crtc, &crtc_damage);

 		

-		REGION_UNINIT (pScreen, &crtc_damage);

+		RegionUninit(&crtc_damage);

 	    }

 	}

 	pScreen->SourceValidate = SourceValidate;

@@ -405,8 +405,7 @@ xf86CrtcRotate (xf86CrtcPtr crtc)
 	 */

 	xf86RotateDestroy (crtc);

 	crtc->transform_in_use = FALSE;

-	if (new_params)

-	    free(new_params);

+	free(new_params);

 	new_params = NULL;

 	new_nparams = 0;

 	new_filter = NULL;

@@ -506,8 +505,7 @@ xf86CrtcRotate (xf86CrtcPtr crtc)
     crtc->crtc_to_framebuffer = crtc_to_fb;

     crtc->f_crtc_to_framebuffer = f_crtc_to_fb;

     crtc->f_framebuffer_to_crtc = f_fb_to_crtc;

-    if (crtc->params)

-	free(crtc->params);

+    free(crtc->params);

     crtc->params = new_params;

     crtc->nparams = new_nparams;

     crtc->filter = new_filter;

diff --git a/xorg-server/hw/xfree86/os-support/bsd/alpha_video.c b/xorg-server/hw/xfree86/os-support/bsd/alpha_video.c
index 18e1e0b67..7b5d2c7a4 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/alpha_video.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/alpha_video.c
@@ -1,719 +1,719 @@
-/*
- * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
- * Copyright 1993 by David Wexelblat <dwex@goblin.org>
- *
- * 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 names of Rich Murphey and David Wexelblat 
- * not be used in advertising or publicity pertaining to distribution of 
- * the software without specific, written prior permission.  Rich Murphey and
- * David Wexelblat make no representations about the suitability of this 
- * software for any purpose.  It is provided "as is" without express or 
- * implied warranty.
- *
- * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 
- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
- * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT 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_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include "xf86.h"
-#include "xf86Priv.h"
-
-#include <sys/param.h>
-#ifndef __NetBSD__
-#  include <sys/sysctl.h>
-#  if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-#      include <machine/sysarch.h>
-#   endif
-# else
-#  include <machine/sysarch.h>
-#endif
-
-#include "xf86Axp.h"
-
-#include "xf86_OSlib.h"
-#include "xf86OSpriv.h"
-
-#if defined(__NetBSD__) && !defined(MAP_FILE)
-#define MAP_FLAGS MAP_SHARED
-#else
-#define MAP_FLAGS (MAP_FILE | MAP_SHARED)
-#endif
-
-#ifndef MAP_FAILED
-#define MAP_FAILED ((caddr_t)-1)
-#endif
-
-axpDevice bsdGetAXP(void);
-
-#ifndef __NetBSD__
-extern unsigned long dense_base(void);
-
-static int axpSystem = -1;
-static unsigned long hae_thresh;
-static unsigned long hae_mask;
-static unsigned long bus_base;
-static unsigned long sparse_size;
-
-static unsigned long
-memory_base(void)
-{
-    static unsigned long base = 0;
-
-    if (base == 0) {
-	size_t len = sizeof(base);
-	int error;
-#ifdef __OpenBSD__
-       int mib[3];
-
-       mib[0] = CTL_MACHDEP;
-       mib[1] = CPU_CHIPSET;
-       mib[2] = CPU_CHIPSET_MEM;
-
-       if ((error = sysctl(mib, 3, &base, &len, NULL, 0)) < 0)
-#else
-	if ((error = sysctlbyname("hw.chipset.memory", &base, &len,
-				  0, 0)) < 0)
-#endif
-	    FatalError("xf86MapVidMem: can't find memory\n");
-    }
-
-    return base;
-}
-
-static int
-has_bwx(void)
-{
-    static int bwx = 0;
-    size_t len = sizeof(bwx);
-    int error;
-#ifdef __OpenBSD__
-    int mib[3];
-
-    mib[0] = CTL_MACHDEP;
-    mib[1] = CPU_CHIPSET;
-    mib[2] = CPU_CHIPSET_BWX;
-
-    if ((error = sysctl(mib, 3, &bwx, &len, NULL, 0)) < 0)
-	return FALSE;
-    else
-	return bwx;
-#else
-    if ((error = sysctlbyname("hw.chipset.bwx", &bwx, &len, 0, 0)) < 0)
-	return FALSE;
-    else
-	return bwx;
-#endif
-}
-#else /* __NetBSD__ */
-static unsigned long hae_thresh = (1UL << 24);
-static unsigned long hae_mask = 0xf8000000UL; /* XXX - should use xf86AXP.c */
-static struct alpha_bus_window *abw;
-static int abw_count = -1;
-
-static void
-init_abw(void)
-{
-	if (abw_count < 0) {
-		abw_count = alpha_bus_getwindows(ALPHA_BUS_TYPE_PCI_MEM, &abw);
-		if (abw_count <= 0)
-			FatalError("init_abw: alpha_bus_getwindows failed\n");
-	}
-}
-
-static int
-has_bwx(void)
-{
-	if (abw_count < 0)
-		init_abw();
-
-	xf86Msg(X_INFO, "has_bwx = %d\n", 
-		abw[0].abw_abst.abst_flags & ABST_BWX ? 1 : 0);	/* XXXX */
-	return abw[0].abw_abst.abst_flags & ABST_BWX;
-}
-
-static unsigned long
-dense_base(void)
-{
-	if (abw_count < 0)
-		init_abw();
-
-	/* XXX check abst_flags for ABST_DENSE just to be safe? */
-	xf86Msg(X_INFO, "dense base = %#lx\n", 
-		abw[0].abw_abst.abst_sys_start); /* XXXX */
-	return abw[0].abw_abst.abst_sys_start;
-}
-
-static unsigned long
-memory_base(void)
-{
-	if (abw_count < 0)
-		init_abw();
-	
-	if (abw_count > 1) {
-		xf86Msg(X_INFO, "memory base = %#lx\n", 
-			abw[1].abw_abst.abst_sys_start); /* XXXX */
-		return abw[1].abw_abst.abst_sys_start;
-	} else if (abw_count == 1) {
-		/* assume memory_base == dense_base */
-		xf86Msg(X_INFO, "memory base = %#lx\n",
-			abw[0].abw_abst.abst_sys_start); /* XXXX */
-		return abw[0].abw_abst.abst_sys_start;
-	} else {
-		xf86Msg(X_INFO, "no memory base\n"); /* XXXX */
-		return 0;
-	}
-}
-#endif /* __NetBSD__ */
-
-#define BUS_BASE	dense_base()
-#define BUS_BASE_BWX	memory_base()
-
-/***************************************************************************/
-/* Video Memory Mapping section                                            */
-/***************************************************************************/
-
-#ifdef __OpenBSD__
-#define SYSCTL_MSG "\tCheck that you have set 'machdep.allowaperture=1'\n"\
-                  "\tin /etc/sysctl.conf and reboot your machine\n" \
-                  "\trefer to xf86(4) for details"
-#endif
-
-static Bool useDevMem = FALSE;
-static int  devMemFd = -1;
-
-#ifdef HAS_APERTURE_DRV
-#define DEV_APERTURE "/dev/xf86"
-#endif
-#define DEV_MEM "/dev/mem"
-
-static pointer mapVidMem(int, unsigned long, unsigned long, int);
-static void unmapVidMem(int, pointer, unsigned long);
-static pointer mapVidMemSparse(int, unsigned long, unsigned long, int);
-static void unmapVidMemSparse(int, pointer, unsigned long);
-
-/*
- * Check if /dev/mem can be mmap'd.  If it can't print a warning when
- * "warn" is TRUE.
- */
-static void
-checkDevMem(Bool warn)
-{
-	static Bool devMemChecked = FALSE;
-	int fd;
-	pointer base;
-
-	if (devMemChecked)
-	    return;
-	devMemChecked = TRUE;
-
-#ifdef HAS_APERTURE_DRV
-       /* Try the aperture driver first */
-       if ((fd = open(DEV_APERTURE, O_RDWR)) >= 0) {
-           /* Try to map a page at the VGA address */
-           base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,
-                            MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);
-       
-           if (base != MAP_FAILED) {
-               munmap((caddr_t)base, 4096);
-               devMemFd = fd;
-               useDevMem = TRUE;
-               xf86Msg(X_INFO, "checkDevMem: using aperture driver %s\n",
-                       DEV_APERTURE);
-               return;
-           } else {
-               if (warn) {
-                   xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",
-                           DEV_APERTURE, strerror(errno));
-               }
-           }
-       } 
-#endif
-       if ((fd = open(DEV_MEM, O_RDWR)) >= 0) {
-	    /* Try to map a page at the VGA address */
-	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,
-				 MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);
-	
-	    if (base != MAP_FAILED) {
-		munmap((caddr_t)base, 4096);
-		devMemFd = fd;
-		useDevMem = TRUE;
-		return;
-	    } else {
-		if (warn) {
-		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",
-			    DEV_MEM, strerror(errno));
-		}
-	    }
-	}
-	if (warn) { 
-#ifndef HAS_APERTURE_DRV
-           xf86Msg(X_WARNING, "checkDevMem: failed to open/mmap %s (%s)\n",
-                   DEV_MEM, strerror(errno));
-#else
-#ifndef __OpenBSD__
-           xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"
-               "\t(%s)\n", DEV_APERTURE, DEV_MEM, strerror(errno));
-#else /* __OpenBSD__ */
-           xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"
-                   "\t(%s)\n%s", DEV_APERTURE, DEV_MEM, strerror(errno),
-                   SYSCTL_MSG);
-#endif /* __OpenBSD__ */
-#endif
-           xf86ErrorF("\tlinear framebuffer access unavailable\n");
-	}
-	useDevMem = FALSE;
-	return;
-}
-
-void
-xf86OSInitVidMem(VidMemInfoPtr pVidMem)
-{
-	checkDevMem(TRUE);
-	pVidMem->linearSupported = useDevMem;
-
-	if (has_bwx()) {
-	    xf86Msg(X_PROBED,"Machine type has 8/16 bit access\n");
-	    pVidMem->mapMem = mapVidMem;
-	    pVidMem->unmapMem = unmapVidMem;
-	} else {
-	    xf86Msg(X_PROBED,"Machine needs sparse mapping\n");
-	    pVidMem->mapMem = mapVidMemSparse;
-	    pVidMem->unmapMem = unmapVidMemSparse;
-#ifndef __NetBSD__
-	    if (axpSystem == -1)
-                axpSystem = bsdGetAXP(); 
-	    hae_thresh = xf86AXPParams[axpSystem].hae_thresh;
-            hae_mask = xf86AXPParams[axpSystem].hae_mask;
-            sparse_size = xf86AXPParams[axpSystem].size;
-#endif /* __NetBSD__ */
-	}
-	pVidMem->initialised = TRUE;
-}
-
-static pointer
-mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
-{
-	pointer base;
-
-	checkDevMem(FALSE);
-	Base = Base & ((1L<<32) - 1);
-
-	if (useDevMem)
-	{
-	    if (devMemFd < 0) 
-	    {
-		FatalError("xf86MapVidMem: failed to open %s (%s)\n",
-			   DEV_MEM, strerror(errno));
-	    }
-	    base = mmap((caddr_t)0, Size,
-			(flags & VIDMEM_READONLY) ?
-			 PROT_READ : (PROT_READ | PROT_WRITE),
-			 MAP_FLAGS, devMemFd, (off_t)Base + BUS_BASE_BWX);
-	    if (base == MAP_FAILED)
-	    {
-		FatalError("%s: could not mmap %s [s=%lx,a=%lx] (%s)\n",
-			   "xf86MapVidMem", DEV_MEM, Size, Base, 
-			   strerror(errno));
-	    }
-	    return(base);
-	}
-		
-	/* else, mmap /dev/vga */
-	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)
-	{
-		FatalError("%s: Address 0x%lx outside allowable range\n",
-			   "xf86MapVidMem", Base);
-	}
-	base = mmap(0, Size,
-		    (flags & VIDMEM_READONLY) ?
-		     PROT_READ : (PROT_READ | PROT_WRITE),
-		    MAP_FLAGS, xf86Info.screenFd,
-		    (unsigned long)Base + BUS_BASE);
-	if (base == MAP_FAILED)
-	{
-	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)\n",
-		       strerror(errno));
-	}
-	return(base);
-}
-
-static void
-unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
-{
-	munmap((caddr_t)Base, Size);
-}
-
-/*
- * Read BIOS via mmap()ing DEV_MEM
- */
-
-int
-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
-	     int Len)
-{
-	unsigned char *ptr;
-	int psize;
-	int mlen;
-
-	checkDevMem(TRUE);
-	if (devMemFd == -1) {
-	    return(-1);
-	}
-
-	psize = getpagesize();
-	Offset += Base & (psize - 1);
-	Base &= ~(psize - 1);
-	mlen = (Offset + Len + psize - 1) & ~(psize - 1);
-	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,
-					MAP_SHARED, devMemFd, (off_t)Base+BUS_BASE);
-	if ((long)ptr == -1)
-	{
-		xf86Msg(X_WARNING, 
-			"xf86ReadBIOS: %s mmap[s=%x,a=%lx,o=%lx] failed (%s)\n",
-			DEV_MEM, Len, Base, Offset, strerror(errno));
-		return(-1);
-	}
-#ifdef DEBUG
-	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",
-		Base, ptr[0] | (ptr[1] << 8));
-#endif
-	(void)memcpy(Buf, (void *)(ptr + Offset), Len);
-	(void)munmap((caddr_t)ptr, mlen);
-#ifdef DEBUG
-	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"
-		"-> %02x %02x %02x %02x...\n",
-		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);
-#endif
-	return(Len);
-}
-
-
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)
-
-extern int ioperm(unsigned long from, unsigned long num, int on);
-
-Bool
-xf86EnableIO()
-{
-    if (!ioperm(0, 65536, TRUE))
-	return TRUE;
-    return FALSE;
-}
-
-void
-xf86DisableIO()
-{
-	return;
-}
-
-#endif /* __FreeBSD_kernel__ || __OpenBSD__ */
-
-#ifdef USE_ALPHA_PIO
-
-Bool
-xf86EnableIO()
-{
-	alpha_pci_io_enable(1);
-	return TRUE;
-}
-
-void
-xf86DisableIO()
-{
-	alpha_pci_io_enable(0);
-}
-
-#endif /* USE_ALPHA_PIO */
-
-#define vuip    volatile unsigned int *
-
-static unsigned long msb_set = 0;
-static pointer memSBase = 0;
-static pointer memBase = 0;
-
-extern int readDense8(pointer Base, register unsigned long Offset);
-extern int readDense16(pointer Base, register unsigned long Offset);
-extern int readDense32(pointer Base, register unsigned long Offset);
-extern void
-writeDenseNB8(int Value, pointer Base, register unsigned long Offset);
-extern void
-writeDenseNB16(int Value, pointer Base, register unsigned long Offset);
-extern void
-writeDenseNB32(int Value, pointer Base, register unsigned long Offset);
-extern void
-writeDense8(int Value, pointer Base, register unsigned long Offset);
-extern void
-writeDense16(int Value, pointer Base, register unsigned long Offset);
-extern void
-writeDense32(int Value, pointer Base, register unsigned long Offset);
-
-static int readSparse8(pointer Base, register unsigned long Offset);
-static int readSparse16(pointer Base, register unsigned long Offset);
-static int readSparse32(pointer Base, register unsigned long Offset);
-static void
-writeSparseNB8(int Value, pointer Base, register unsigned long Offset);
-static void
-writeSparseNB16(int Value, pointer Base, register unsigned long Offset);
-static void
-writeSparseNB32(int Value, pointer Base, register unsigned long Offset);
-static void
-writeSparse8(int Value, pointer Base, register unsigned long Offset);
-static void
-writeSparse16(int Value, pointer Base, register unsigned long Offset);
-static void
-writeSparse32(int Value, pointer Base, register unsigned long Offset);
-
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-extern int sysarch(int, void *);
-#endif
-
-struct parms {
-	u_int64_t hae;
-};
-
-#ifndef __NetBSD__
-static int
-sethae(u_int64_t hae)
-{
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-#ifndef ALPHA_SETHAE
-#define ALPHA_SETHAE 0
-#endif
-	struct parms p;
-	p.hae = hae;
-	return (sysarch(ALPHA_SETHAE, (char *)&p));
-#endif
-#ifdef __OpenBSD__
-	return -1;
-#endif
-}
-#endif /* __NetBSD__ */
-
-static pointer
-mapVidMemSparse(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
-{
-    static Bool was_here = FALSE;
-
-    if (!was_here) {
-      was_here = TRUE;
-
-      checkDevMem(FALSE);
-
-      xf86WriteMmio8 = writeSparse8;
-      xf86WriteMmio16 = writeSparse16;
-      xf86WriteMmio32 = writeSparse32;
-      xf86WriteMmioNB8 = writeSparseNB8;
-      xf86WriteMmioNB16 = writeSparseNB16;
-      xf86WriteMmioNB32 = writeSparseNB32;
-      xf86ReadMmio8 = readSparse8;
-      xf86ReadMmio16 = readSparse16;
-      xf86ReadMmio32 = readSparse32;
-	
-      memBase = mmap((caddr_t)0, 0x100000000,
-		     PROT_READ | PROT_WRITE,
-		     MAP_SHARED, devMemFd,
-		     (off_t) BUS_BASE);
-      memSBase = mmap((caddr_t)0, 0x100000000,
-		      PROT_READ | PROT_WRITE,
-		      MAP_SHARED, devMemFd,
-		      (off_t) BUS_BASE_BWX);
-      
-      if (memSBase == MAP_FAILED || memBase == MAP_FAILED)	{
-	FatalError("xf86MapVidMem: Could not mmap framebuffer (%s)\n",
-		   strerror(errno));
-      }
-    }
-    return (pointer)((unsigned long)memBase + Base);
-}
-
-static void
-unmapVidMemSparse(int ScreenNum, pointer Base, unsigned long Size)
-{
-}
-
-static int
-readSparse8(pointer Base, register unsigned long Offset)
-{
-    register unsigned long result, shift;
-    register unsigned long msb;
-    mem_barrier();
-    Offset += (unsigned long)Base - (unsigned long)memBase;
-    shift = (Offset & 0x3) << 3;
-      if (Offset >= (hae_thresh)) {
-        msb = Offset & hae_mask;
-        Offset -= msb;
-	if (msb_set != msb) {
-#ifndef __NetBSD__
-	sethae(msb);
-#endif
-	msb_set = msb;
-	}
-      }
-    result = *(vuip) ((unsigned long)memSBase + (Offset << 5));
-    result >>= shift;
-    return 0xffUL & result;
-}
-
-static int
-readSparse16(pointer Base, register unsigned long Offset)
-{
-    register unsigned long result, shift;
-    register unsigned long msb;
-
-    mem_barrier();
-    Offset += (unsigned long)Base - (unsigned long)memBase;
-    shift = (Offset & 0x2) << 3;
-    if (Offset >= (hae_thresh)) {
-        msb = Offset & hae_mask;
-        Offset -= msb;
-      if (msb_set != msb) {
-#ifndef __NetBSD__
-	sethae(msb);
-#endif
-	msb_set = msb;
-      }
-    }
-    result = *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2)));
-    result >>= shift;
-    return 0xffffUL & result;
-}
-
-static int
-readSparse32(pointer Base, register unsigned long Offset)
-{
-    mem_barrier();
-    return *(vuip)((unsigned long)Base+(Offset));
-}
-
-static void
-writeSparse8(int Value, pointer Base, register unsigned long Offset)
-{
-    register unsigned long msb;
-    register unsigned int b = Value & 0xffU;
-
-    write_mem_barrier();
-    Offset += (unsigned long)Base - (unsigned long)memBase;
-    if (Offset >= (hae_thresh)) {
-      msb = Offset & hae_mask;
-      Offset -= msb;
-      if (msb_set != msb) {
-#ifndef __NetBSD__
-	sethae(msb);
-#endif
-	msb_set = msb;
-      }
-    }
-    *(vuip) ((unsigned long)memSBase + (Offset << 5)) = b * 0x01010101;
-}
-
-static void
-writeSparse16(int Value, pointer Base, register unsigned long Offset)
-{
-    register unsigned long msb;
-    register unsigned int w = Value & 0xffffU;
-
-    write_mem_barrier();
-    Offset += (unsigned long)Base - (unsigned long)memBase;
-    if (Offset >= (hae_thresh)) {
-      msb = Offset & hae_mask;
-      Offset -= msb;
-      if (msb_set != msb) {
-#ifndef __NetBSD__
-	sethae(msb);
-#endif
-	msb_set = msb;
-      }
-    }
-    *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2))) =
-      w * 0x00010001;
-
-}
-
-static void
-writeSparse32(int Value, pointer Base, register unsigned long Offset)
-{
-    write_mem_barrier();
-    *(vuip)((unsigned long)Base + (Offset)) = Value;
-    return;
-}
-
-static void
-writeSparseNB8(int Value, pointer Base, register unsigned long Offset)
-{
-    register unsigned long msb;
-    register unsigned int b = Value & 0xffU;
-
-    Offset += (unsigned long)Base - (unsigned long)memBase;
-    if (Offset >= (hae_thresh)) {
-      msb = Offset & hae_mask;
-      Offset -= msb;
-      if (msb_set != msb) {
-#ifndef __NetBSD__
-	sethae(msb);
-#endif
-	msb_set = msb;
-      }
-    }
-    *(vuip) ((unsigned long)memSBase + (Offset << 5)) = b * 0x01010101;
-}
-
-static void
-writeSparseNB16(int Value, pointer Base, register unsigned long Offset)
-{
-    register unsigned long msb;
-    register unsigned int w = Value & 0xffffU;
-
-    Offset += (unsigned long)Base - (unsigned long)memBase;
-    if (Offset >= (hae_thresh)) {
-      msb = Offset & hae_mask ;
-      Offset -= msb;
-      if (msb_set != msb) {
-#ifndef __NetBSD__
-	sethae(msb);
-#endif
-	msb_set = msb;
-      }
-    }
-    *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2))) =
-      w * 0x00010001;
-}
-
-static void
-writeSparseNB32(int Value, pointer Base, register unsigned long Offset)
-{
-    *(vuip)((unsigned long)Base + (Offset)) = Value;
-    return;
-}
-
-void (*xf86WriteMmio8)(int Value, pointer Base, unsigned long Offset)
-     = writeDense8;
-void (*xf86WriteMmio16)(int Value, pointer Base, unsigned long Offset)
-     = writeDense16;
-void (*xf86WriteMmio32)(int Value, pointer Base, unsigned long Offset)
-     = writeDense32;
-void (*xf86WriteMmioNB8)(int Value, pointer Base, unsigned long Offset)
-     = writeDenseNB8;
-void (*xf86WriteMmioNB16)(int Value, pointer Base, unsigned long Offset)
-     = writeDenseNB16;
-void (*xf86WriteMmioNB32)(int Value, pointer Base, unsigned long Offset)
-     = writeDenseNB32;
-int  (*xf86ReadMmio8)(pointer Base, unsigned long Offset)
-     = readDense8;
-int  (*xf86ReadMmio16)(pointer Base, unsigned long Offset)
-     = readDense16;
-int  (*xf86ReadMmio32)(pointer Base, unsigned long Offset)
-     = readDense32;
-
+/*

+ * Copyright 1992 by Rich Murphey <Rich@Rice.edu>

+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>

+ *

+ * 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 names of Rich Murphey and David Wexelblat 

+ * not be used in advertising or publicity pertaining to distribution of 

+ * the software without specific, written prior permission.  Rich Murphey and

+ * David Wexelblat make no representations about the suitability of this 

+ * software for any purpose.  It is provided "as is" without express or 

+ * implied warranty.

+ *

+ * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 

+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

+ * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT 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_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+#include "xf86.h"

+#include "xf86Priv.h"

+

+#include <sys/param.h>

+#ifndef __NetBSD__

+#  include <sys/sysctl.h>

+#  if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

+#      include <machine/sysarch.h>

+#   endif

+# else

+#  include <machine/sysarch.h>

+#endif

+

+#include "xf86Axp.h"

+

+#include "xf86_OSlib.h"

+#include "xf86OSpriv.h"

+

+#if defined(__NetBSD__) && !defined(MAP_FILE)

+#define MAP_FLAGS MAP_SHARED

+#else

+#define MAP_FLAGS (MAP_FILE | MAP_SHARED)

+#endif

+

+#ifndef MAP_FAILED

+#define MAP_FAILED ((caddr_t)-1)

+#endif

+

+axpDevice bsdGetAXP(void);

+

+#ifndef __NetBSD__

+extern unsigned long dense_base(void);

+

+static int axpSystem = -1;

+static unsigned long hae_thresh;

+static unsigned long hae_mask;

+static unsigned long bus_base;

+static unsigned long sparse_size;

+

+static unsigned long

+memory_base(void)

+{

+    static unsigned long base = 0;

+

+    if (base == 0) {

+	size_t len = sizeof(base);

+	int error;

+#ifdef __OpenBSD__

+       int mib[3];

+

+       mib[0] = CTL_MACHDEP;

+       mib[1] = CPU_CHIPSET;

+       mib[2] = CPU_CHIPSET_MEM;

+

+       if ((error = sysctl(mib, 3, &base, &len, NULL, 0)) < 0)

+#else

+	if ((error = sysctlbyname("hw.chipset.memory", &base, &len,

+				  0, 0)) < 0)

+#endif

+	    FatalError("xf86MapVidMem: can't find memory\n");

+    }

+

+    return base;

+}

+

+static int

+has_bwx(void)

+{

+    static int bwx = 0;

+    size_t len = sizeof(bwx);

+    int error;

+#ifdef __OpenBSD__

+    int mib[3];

+

+    mib[0] = CTL_MACHDEP;

+    mib[1] = CPU_CHIPSET;

+    mib[2] = CPU_CHIPSET_BWX;

+

+    if ((error = sysctl(mib, 3, &bwx, &len, NULL, 0)) < 0)

+	return FALSE;

+    else

+	return bwx;

+#else

+    if ((error = sysctlbyname("hw.chipset.bwx", &bwx, &len, 0, 0)) < 0)

+	return FALSE;

+    else

+	return bwx;

+#endif

+}

+#else /* __NetBSD__ */

+static unsigned long hae_thresh = (1UL << 24);

+static unsigned long hae_mask = 0xf8000000UL; /* XXX - should use xf86AXP.c */

+static struct alpha_bus_window *abw;

+static int abw_count = -1;

+

+static void

+init_abw(void)

+{

+	if (abw_count < 0) {

+		abw_count = alpha_bus_getwindows(ALPHA_BUS_TYPE_PCI_MEM, &abw);

+		if (abw_count <= 0)

+			FatalError("init_abw: alpha_bus_getwindows failed\n");

+	}

+}

+

+static int

+has_bwx(void)

+{

+	if (abw_count < 0)

+		init_abw();

+

+	xf86Msg(X_INFO, "has_bwx = %d\n", 

+		abw[0].abw_abst.abst_flags & ABST_BWX ? 1 : 0);	/* XXXX */

+	return abw[0].abw_abst.abst_flags & ABST_BWX;

+}

+

+static unsigned long

+dense_base(void)

+{

+	if (abw_count < 0)

+		init_abw();

+

+	/* XXX check abst_flags for ABST_DENSE just to be safe? */

+	xf86Msg(X_INFO, "dense base = %#lx\n", 

+		abw[0].abw_abst.abst_sys_start); /* XXXX */

+	return abw[0].abw_abst.abst_sys_start;

+}

+

+static unsigned long

+memory_base(void)

+{

+	if (abw_count < 0)

+		init_abw();

+	

+	if (abw_count > 1) {

+		xf86Msg(X_INFO, "memory base = %#lx\n", 

+			abw[1].abw_abst.abst_sys_start); /* XXXX */

+		return abw[1].abw_abst.abst_sys_start;

+	} else if (abw_count == 1) {

+		/* assume memory_base == dense_base */

+		xf86Msg(X_INFO, "memory base = %#lx\n",

+			abw[0].abw_abst.abst_sys_start); /* XXXX */

+		return abw[0].abw_abst.abst_sys_start;

+	} else {

+		xf86Msg(X_INFO, "no memory base\n"); /* XXXX */

+		return 0;

+	}

+}

+#endif /* __NetBSD__ */

+

+#define BUS_BASE	dense_base()

+#define BUS_BASE_BWX	memory_base()

+

+/***************************************************************************/

+/* Video Memory Mapping section                                            */

+/***************************************************************************/

+

+#ifdef __OpenBSD__

+#define SYSCTL_MSG "\tCheck that you have set 'machdep.allowaperture=1'\n"\

+                  "\tin /etc/sysctl.conf and reboot your machine\n" \

+                  "\trefer to xf86(4) for details"

+#endif

+

+static Bool useDevMem = FALSE;

+static int  devMemFd = -1;

+

+#ifdef HAS_APERTURE_DRV

+#define DEV_APERTURE "/dev/xf86"

+#endif

+#define DEV_MEM "/dev/mem"

+

+static pointer mapVidMem(int, unsigned long, unsigned long, int);

+static void unmapVidMem(int, pointer, unsigned long);

+static pointer mapVidMemSparse(int, unsigned long, unsigned long, int);

+static void unmapVidMemSparse(int, pointer, unsigned long);

+

+/*

+ * Check if /dev/mem can be mmap'd.  If it can't print a warning when

+ * "warn" is TRUE.

+ */

+static void

+checkDevMem(Bool warn)

+{

+	static Bool devMemChecked = FALSE;

+	int fd;

+	pointer base;

+

+	if (devMemChecked)

+	    return;

+	devMemChecked = TRUE;

+

+#ifdef HAS_APERTURE_DRV

+       /* Try the aperture driver first */

+       if ((fd = open(DEV_APERTURE, O_RDWR)) >= 0) {

+           /* Try to map a page at the VGA address */

+           base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,

+                            MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);

+       

+           if (base != MAP_FAILED) {

+               munmap((caddr_t)base, 4096);

+               devMemFd = fd;

+               useDevMem = TRUE;

+               xf86Msg(X_INFO, "checkDevMem: using aperture driver %s\n",

+                       DEV_APERTURE);

+               return;

+           } else {

+               if (warn) {

+                   xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",

+                           DEV_APERTURE, strerror(errno));

+               }

+           }

+       } 

+#endif

+       if ((fd = open(DEV_MEM, O_RDWR)) >= 0) {

+	    /* Try to map a page at the VGA address */

+	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,

+				 MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);

+	

+	    if (base != MAP_FAILED) {

+		munmap((caddr_t)base, 4096);

+		devMemFd = fd;

+		useDevMem = TRUE;

+		return;

+	    } else {

+		if (warn) {

+		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",

+			    DEV_MEM, strerror(errno));

+		}

+	    }

+	}

+	if (warn) { 

+#ifndef HAS_APERTURE_DRV

+           xf86Msg(X_WARNING, "checkDevMem: failed to open/mmap %s (%s)\n",

+                   DEV_MEM, strerror(errno));

+#else

+#ifndef __OpenBSD__

+           xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"

+               "\t(%s)\n", DEV_APERTURE, DEV_MEM, strerror(errno));

+#else /* __OpenBSD__ */

+           xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"

+                   "\t(%s)\n%s", DEV_APERTURE, DEV_MEM, strerror(errno),

+                   SYSCTL_MSG);

+#endif /* __OpenBSD__ */

+#endif

+           xf86ErrorF("\tlinear framebuffer access unavailable\n");

+	}

+	useDevMem = FALSE;

+	return;

+}

+

+void

+xf86OSInitVidMem(VidMemInfoPtr pVidMem)

+{

+	checkDevMem(TRUE);

+	pVidMem->linearSupported = useDevMem;

+

+	if (has_bwx()) {

+	    xf86Msg(X_PROBED,"Machine type has 8/16 bit access\n");

+	    pVidMem->mapMem = mapVidMem;

+	    pVidMem->unmapMem = unmapVidMem;

+	} else {

+	    xf86Msg(X_PROBED,"Machine needs sparse mapping\n");

+	    pVidMem->mapMem = mapVidMemSparse;

+	    pVidMem->unmapMem = unmapVidMemSparse;

+#ifndef __NetBSD__

+	    if (axpSystem == -1)

+                axpSystem = bsdGetAXP(); 

+	    hae_thresh = xf86AXPParams[axpSystem].hae_thresh;

+            hae_mask = xf86AXPParams[axpSystem].hae_mask;

+            sparse_size = xf86AXPParams[axpSystem].size;

+#endif /* __NetBSD__ */

+	}

+	pVidMem->initialised = TRUE;

+}

+

+static pointer

+mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

+{

+	pointer base;

+

+	checkDevMem(FALSE);

+	Base = Base & ((1L<<32) - 1);

+

+	if (useDevMem)

+	{

+	    if (devMemFd < 0) 

+	    {

+		FatalError("xf86MapVidMem: failed to open %s (%s)\n",

+			   DEV_MEM, strerror(errno));

+	    }

+	    base = mmap((caddr_t)0, Size,

+			(flags & VIDMEM_READONLY) ?

+			 PROT_READ : (PROT_READ | PROT_WRITE),

+			 MAP_FLAGS, devMemFd, (off_t)Base + BUS_BASE_BWX);

+	    if (base == MAP_FAILED)

+	    {

+		FatalError("%s: could not mmap %s [s=%lx,a=%lx] (%s)\n",

+			   "xf86MapVidMem", DEV_MEM, Size, Base, 

+			   strerror(errno));

+	    }

+	    return base;

+	}

+		

+	/* else, mmap /dev/vga */

+	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)

+	{

+		FatalError("%s: Address 0x%lx outside allowable range\n",

+			   "xf86MapVidMem", Base);

+	}

+	base = mmap(0, Size,

+		    (flags & VIDMEM_READONLY) ?

+		     PROT_READ : (PROT_READ | PROT_WRITE),

+		    MAP_FLAGS, xf86Info.screenFd,

+		    (unsigned long)Base + BUS_BASE);

+	if (base == MAP_FAILED)

+	{

+	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)\n",

+		       strerror(errno));

+	}

+	return base;

+}

+

+static void

+unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

+{

+	munmap((caddr_t)Base, Size);

+}

+

+/*

+ * Read BIOS via mmap()ing DEV_MEM

+ */

+

+int

+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

+	     int Len)

+{

+	unsigned char *ptr;

+	int psize;

+	int mlen;

+

+	checkDevMem(TRUE);

+	if (devMemFd == -1) {

+	    return -1;

+	}

+

+	psize = getpagesize();

+	Offset += Base & (psize - 1);

+	Base &= ~(psize - 1);

+	mlen = (Offset + Len + psize - 1) & ~(psize - 1);

+	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,

+					MAP_SHARED, devMemFd, (off_t)Base+BUS_BASE);

+	if ((long)ptr == -1)

+	{

+		xf86Msg(X_WARNING, 

+			"xf86ReadBIOS: %s mmap[s=%x,a=%lx,o=%lx] failed (%s)\n",

+			DEV_MEM, Len, Base, Offset, strerror(errno));

+		return -1;

+	}

+#ifdef DEBUG

+	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",

+		Base, ptr[0] | (ptr[1] << 8));

+#endif

+	(void)memcpy(Buf, (void *)(ptr + Offset), Len);

+	(void)munmap((caddr_t)ptr, mlen);

+#ifdef DEBUG

+	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"

+		"-> %02x %02x %02x %02x...\n",

+		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);

+#endif

+	return Len;

+}

+

+

+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)

+

+extern int ioperm(unsigned long from, unsigned long num, int on);

+

+Bool

+xf86EnableIO()

+{

+    if (!ioperm(0, 65536, TRUE))

+	return TRUE;

+    return FALSE;

+}

+

+void

+xf86DisableIO()

+{

+	return;

+}

+

+#endif /* __FreeBSD_kernel__ || __OpenBSD__ */

+

+#ifdef USE_ALPHA_PIO

+

+Bool

+xf86EnableIO()

+{

+	alpha_pci_io_enable(1);

+	return TRUE;

+}

+

+void

+xf86DisableIO()

+{

+	alpha_pci_io_enable(0);

+}

+

+#endif /* USE_ALPHA_PIO */

+

+#define vuip    volatile unsigned int *

+

+static unsigned long msb_set = 0;

+static pointer memSBase = 0;

+static pointer memBase = 0;

+

+extern int readDense8(pointer Base, register unsigned long Offset);

+extern int readDense16(pointer Base, register unsigned long Offset);

+extern int readDense32(pointer Base, register unsigned long Offset);

+extern void

+writeDenseNB8(int Value, pointer Base, register unsigned long Offset);

+extern void

+writeDenseNB16(int Value, pointer Base, register unsigned long Offset);

+extern void

+writeDenseNB32(int Value, pointer Base, register unsigned long Offset);

+extern void

+writeDense8(int Value, pointer Base, register unsigned long Offset);

+extern void

+writeDense16(int Value, pointer Base, register unsigned long Offset);

+extern void

+writeDense32(int Value, pointer Base, register unsigned long Offset);

+

+static int readSparse8(pointer Base, register unsigned long Offset);

+static int readSparse16(pointer Base, register unsigned long Offset);

+static int readSparse32(pointer Base, register unsigned long Offset);

+static void

+writeSparseNB8(int Value, pointer Base, register unsigned long Offset);

+static void

+writeSparseNB16(int Value, pointer Base, register unsigned long Offset);

+static void

+writeSparseNB32(int Value, pointer Base, register unsigned long Offset);

+static void

+writeSparse8(int Value, pointer Base, register unsigned long Offset);

+static void

+writeSparse16(int Value, pointer Base, register unsigned long Offset);

+static void

+writeSparse32(int Value, pointer Base, register unsigned long Offset);

+

+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

+extern int sysarch(int, void *);

+#endif

+

+struct parms {

+	u_int64_t hae;

+};

+

+#ifndef __NetBSD__

+static int

+sethae(u_int64_t hae)

+{

+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

+#ifndef ALPHA_SETHAE

+#define ALPHA_SETHAE 0

+#endif

+	struct parms p;

+	p.hae = hae;

+	return (sysarch(ALPHA_SETHAE, (char *)&p));

+#endif

+#ifdef __OpenBSD__

+	return -1;

+#endif

+}

+#endif /* __NetBSD__ */

+

+static pointer

+mapVidMemSparse(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

+{

+    static Bool was_here = FALSE;

+

+    if (!was_here) {

+      was_here = TRUE;

+

+      checkDevMem(FALSE);

+

+      xf86WriteMmio8 = writeSparse8;

+      xf86WriteMmio16 = writeSparse16;

+      xf86WriteMmio32 = writeSparse32;

+      xf86WriteMmioNB8 = writeSparseNB8;

+      xf86WriteMmioNB16 = writeSparseNB16;

+      xf86WriteMmioNB32 = writeSparseNB32;

+      xf86ReadMmio8 = readSparse8;

+      xf86ReadMmio16 = readSparse16;

+      xf86ReadMmio32 = readSparse32;

+	

+      memBase = mmap((caddr_t)0, 0x100000000,

+		     PROT_READ | PROT_WRITE,

+		     MAP_SHARED, devMemFd,

+		     (off_t) BUS_BASE);

+      memSBase = mmap((caddr_t)0, 0x100000000,

+		      PROT_READ | PROT_WRITE,

+		      MAP_SHARED, devMemFd,

+		      (off_t) BUS_BASE_BWX);

+      

+      if (memSBase == MAP_FAILED || memBase == MAP_FAILED)	{

+	FatalError("xf86MapVidMem: Could not mmap framebuffer (%s)\n",

+		   strerror(errno));

+      }

+    }

+    return (pointer)((unsigned long)memBase + Base);

+}

+

+static void

+unmapVidMemSparse(int ScreenNum, pointer Base, unsigned long Size)

+{

+}

+

+static int

+readSparse8(pointer Base, register unsigned long Offset)

+{

+    register unsigned long result, shift;

+    register unsigned long msb;

+    mem_barrier();

+    Offset += (unsigned long)Base - (unsigned long)memBase;

+    shift = (Offset & 0x3) << 3;

+      if (Offset >= (hae_thresh)) {

+        msb = Offset & hae_mask;

+        Offset -= msb;

+	if (msb_set != msb) {

+#ifndef __NetBSD__

+	sethae(msb);

+#endif

+	msb_set = msb;

+	}

+      }

+    result = *(vuip) ((unsigned long)memSBase + (Offset << 5));

+    result >>= shift;

+    return 0xffUL & result;

+}

+

+static int

+readSparse16(pointer Base, register unsigned long Offset)

+{

+    register unsigned long result, shift;

+    register unsigned long msb;

+

+    mem_barrier();

+    Offset += (unsigned long)Base - (unsigned long)memBase;

+    shift = (Offset & 0x2) << 3;

+    if (Offset >= (hae_thresh)) {

+        msb = Offset & hae_mask;

+        Offset -= msb;

+      if (msb_set != msb) {

+#ifndef __NetBSD__

+	sethae(msb);

+#endif

+	msb_set = msb;

+      }

+    }

+    result = *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2)));

+    result >>= shift;

+    return 0xffffUL & result;

+}

+

+static int

+readSparse32(pointer Base, register unsigned long Offset)

+{

+    mem_barrier();

+    return *(vuip)((unsigned long)Base+(Offset));

+}

+

+static void

+writeSparse8(int Value, pointer Base, register unsigned long Offset)

+{

+    register unsigned long msb;

+    register unsigned int b = Value & 0xffU;

+

+    write_mem_barrier();

+    Offset += (unsigned long)Base - (unsigned long)memBase;

+    if (Offset >= (hae_thresh)) {

+      msb = Offset & hae_mask;

+      Offset -= msb;

+      if (msb_set != msb) {

+#ifndef __NetBSD__

+	sethae(msb);

+#endif

+	msb_set = msb;

+      }

+    }

+    *(vuip) ((unsigned long)memSBase + (Offset << 5)) = b * 0x01010101;

+}

+

+static void

+writeSparse16(int Value, pointer Base, register unsigned long Offset)

+{

+    register unsigned long msb;

+    register unsigned int w = Value & 0xffffU;

+

+    write_mem_barrier();

+    Offset += (unsigned long)Base - (unsigned long)memBase;

+    if (Offset >= (hae_thresh)) {

+      msb = Offset & hae_mask;

+      Offset -= msb;

+      if (msb_set != msb) {

+#ifndef __NetBSD__

+	sethae(msb);

+#endif

+	msb_set = msb;

+      }

+    }

+    *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2))) =

+      w * 0x00010001;

+

+}

+

+static void

+writeSparse32(int Value, pointer Base, register unsigned long Offset)

+{

+    write_mem_barrier();

+    *(vuip)((unsigned long)Base + (Offset)) = Value;

+    return;

+}

+

+static void

+writeSparseNB8(int Value, pointer Base, register unsigned long Offset)

+{

+    register unsigned long msb;

+    register unsigned int b = Value & 0xffU;

+

+    Offset += (unsigned long)Base - (unsigned long)memBase;

+    if (Offset >= (hae_thresh)) {

+      msb = Offset & hae_mask;

+      Offset -= msb;

+      if (msb_set != msb) {

+#ifndef __NetBSD__

+	sethae(msb);

+#endif

+	msb_set = msb;

+      }

+    }

+    *(vuip) ((unsigned long)memSBase + (Offset << 5)) = b * 0x01010101;

+}

+

+static void

+writeSparseNB16(int Value, pointer Base, register unsigned long Offset)

+{

+    register unsigned long msb;

+    register unsigned int w = Value & 0xffffU;

+

+    Offset += (unsigned long)Base - (unsigned long)memBase;

+    if (Offset >= (hae_thresh)) {

+      msb = Offset & hae_mask ;

+      Offset -= msb;

+      if (msb_set != msb) {

+#ifndef __NetBSD__

+	sethae(msb);

+#endif

+	msb_set = msb;

+      }

+    }

+    *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2))) =

+      w * 0x00010001;

+}

+

+static void

+writeSparseNB32(int Value, pointer Base, register unsigned long Offset)

+{

+    *(vuip)((unsigned long)Base + (Offset)) = Value;

+    return;

+}

+

+void (*xf86WriteMmio8)(int Value, pointer Base, unsigned long Offset)

+     = writeDense8;

+void (*xf86WriteMmio16)(int Value, pointer Base, unsigned long Offset)

+     = writeDense16;

+void (*xf86WriteMmio32)(int Value, pointer Base, unsigned long Offset)

+     = writeDense32;

+void (*xf86WriteMmioNB8)(int Value, pointer Base, unsigned long Offset)

+     = writeDenseNB8;

+void (*xf86WriteMmioNB16)(int Value, pointer Base, unsigned long Offset)

+     = writeDenseNB16;

+void (*xf86WriteMmioNB32)(int Value, pointer Base, unsigned long Offset)

+     = writeDenseNB32;

+int  (*xf86ReadMmio8)(pointer Base, unsigned long Offset)

+     = readDense8;

+int  (*xf86ReadMmio16)(pointer Base, unsigned long Offset)

+     = readDense16;

+int  (*xf86ReadMmio32)(pointer Base, unsigned long Offset)

+     = readDense32;

+

diff --git a/xorg-server/hw/xfree86/os-support/bsd/arm_video.c b/xorg-server/hw/xfree86/os-support/bsd/arm_video.c
index 466a8a0db..10cfee764 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/arm_video.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/arm_video.c
@@ -1,666 +1,666 @@
-/*
- * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
- * Copyright 1993 by David Wexelblat <dwex@goblin.org>
- *
- * 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 names of Rich Murphey and David Wexelblat 
- * not be used in advertising or publicity pertaining to distribution of 
- * the software without specific, written prior permission.  Rich Murphey and
- * David Wexelblat make no representations about the suitability of this 
- * software for any purpose.  It is provided "as is" without express or 
- * implied warranty.
- *
- * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 
- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
- * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT 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.
- *
- */
-
-/*
- * The ARM32 code here carries the following copyright:
- *
- * Copyright 1997
- * Digital Equipment Corporation. All rights reserved.
- * This software is furnished under license and may be used and copied only in 
- * accordance with the following terms and conditions.  Subject to these
- * conditions, you may download, copy, install, use, modify and distribute
- * this software in source and/or binary form. No title or ownership is
- * transferred hereby.
- *
- * 1) Any source code used, modified or distributed must reproduce and retain
- *    this copyright notice and list of conditions as they appear in the
- *    source file.
- *
- * 2) No right is granted to use any trade name, trademark, or logo of Digital 
- *    Equipment Corporation. Neither the "Digital Equipment Corporation"
- *    name nor any trademark or logo of Digital Equipment Corporation may be
- *    used to endorse or promote products derived from this software without
- *    the prior written permission of Digital Equipment Corporation.
- *
- * 3) This software is provided "AS-IS" and any express or implied warranties,
- *    including but not limited to, any implied warranties of merchantability,
- *    fitness for a particular purpose, or non-infringement are disclaimed.
- *    In no event shall DIGITAL be liable for any damages whatsoever, and in
- *    particular, DIGITAL shall not be liable for special, indirect,
- *    consequential, or incidental damages or damages for lost profits, loss
- *    of revenue or loss of use, whether such damages arise in contract, 
- *    negligence, tort, under statute, in equity, at law or otherwise, even
- *    if advised of the possibility of such damage. 
- *
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-#include "xf86OSpriv.h"
-
-#ifdef __arm32__
-#include "machine/devmap.h"
-struct memAccess
-{
-    int ioctl;
-    struct map_info memInfo;
-    pointer regionVirtBase;
-    Bool Checked;
-    Bool OK;
-};
-
-static pointer xf86MapInfoMap();
-static void xf86MapInfoUnmap();
-static struct memAccess *checkMapInfo();
-extern int vgaPhysLinearBase;
-
-/* A memAccess structure is needed for each possible region */ 
-struct memAccess vgaMemInfo = { CONSOLE_GET_MEM_INFO, NULL, NULL, 
-				    FALSE, FALSE };
-struct memAccess linearMemInfo = { CONSOLE_GET_LINEAR_INFO, NULL, NULL, 
-				       FALSE, FALSE };
-struct memAccess ioMemInfo = { CONSOLE_GET_IO_INFO, NULL, NULL,
-				   FALSE, FALSE };
-#endif /* __arm32__ */
-
-#if defined(__NetBSD__) && !defined(MAP_FILE)
-#define MAP_FLAGS MAP_SHARED
-#else
-#define MAP_FLAGS (MAP_FILE | MAP_SHARED)
-#endif
-
-#ifndef MAP_FAILED
-#define MAP_FAILED ((caddr_t)-1)
-#endif
-
-
-#define BUS_BASE	0L
-#define BUS_BASE_BWX	0L
-
-
-/***************************************************************************/
-/* Video Memory Mapping section                                            */
-/***************************************************************************/
-
-static Bool useDevMem = FALSE;
-static int  devMemFd = -1;
-
-#define DEV_MEM "/dev/mem"
-
-static pointer mapVidMem(int, unsigned long, unsigned long, int);
-static void unmapVidMem(int, pointer, unsigned long);
-
-/*
- * Check if /dev/mem can be mmap'd.  If it can't print a warning when
- * "warn" is TRUE.
- */
-static void
-checkDevMem(Bool warn)
-{
-	static Bool devMemChecked = FALSE;
-	int fd;
-	pointer base;
-
-	if (devMemChecked)
-	    return;
-	devMemChecked = TRUE;
-
-	if ((fd = open(DEV_MEM, O_RDWR)) >= 0)
-	{
-	    /* Try to map a page at the VGA address */
-	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,
-				 MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);
-	
-	    if (base != MAP_FAILED)
-	    {
-		munmap((caddr_t)base, 4096);
-		devMemFd = fd;
-		useDevMem = TRUE;
-		return;
-	    } else {
-		/* This should not happen */
-		if (warn)
-		{
-		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",
-			    DEV_MEM, strerror(errno));
-		}
-		useDevMem = FALSE;
-		return;
-	    }
-	}
-	if (warn)
-	{ 
-	    xf86Msg(X_WARNING, "checkDevMem: failed to open %s (%s)\n",
-		    DEV_MEM, strerror(errno));
-	} 
-	useDevMem = FALSE;
-	return;
-}
-
-void
-xf86OSInitVidMem(VidMemInfoPtr pVidMem)
-{
-
-	checkDevMem(TRUE);
-	pVidMem->linearSupported = useDevMem;
-	pVidMem->mapMem = armMapVidMem;
-	pVidMem->unmapVidMem = armUnmapVidMem;
-
-	pVidMem->initialised = TRUE;
-}
-
-static pointer
-mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
-{
-	pointer base;
-
-	checkDevMem(FALSE);
-
-	if (useDevMem)
-	{
-	    if (devMemFd < 0) 
-	    {
-		FatalError("xf86MapVidMem: failed to open %s (%s)\n",
-			   DEV_MEM, strerror(errno));
-	    }
-	    base = mmap((caddr_t)0, Size,
-			(flags & VIDMEM_READONLY) ?
-			 PROT_READ : (PROT_READ | PROT_WRITE),
-			MAP_FLAGS, devMemFd, (off_t)Base + BUS_BASE_BWX);
-	    if (base == MAP_FAILED)
-	    {
-		FatalError("%s: could not mmap %s [s=%x,a=%x] (%s)\n",
-			   "xf86MapVidMem", DEV_MEM, Size, Base, 
-			   strerror(errno));
-	    }
-	    return(base);
-	}
-		
-	/* else, mmap /dev/vga */
-	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)
-	{
-		FatalError("%s: Address 0x%x outside allowable range\n",
-			   "xf86MapVidMem", Base);
-	}
-	base = mmap(0, Size,
-		    (flags & VIDMEM_READONLY) ?
-		     PROT_READ : (PROT_READ | PROT_WRITE),
-		    MAP_FLAGS, xf86Info.screenFd,
-		    (unsigned long)Base - 0xA0000);
-	if (base == MAP_FAILED)
-	{
-	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)\n",
-		       strerror(errno));
-	}
-	return(base);
-}
-
-static void
-unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
-{
-	munmap((caddr_t)Base, Size);
-}
-
-/*
- * Read BIOS via mmap()ing DEV_MEM
- */
-
-int
-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
-	     int Len)
-{
-	unsigned char *ptr;
-	int psize;
-	int mlen;
-
-	checkDevMem(TRUE);
-	if (devMemFd == -1) {
-	    return(-1);
-	}
-
-	psize = getpagesize();
-	Offset += Base & (psize - 1);
-	Base &= ~(psize - 1);
-	mlen = (Offset + Len + psize - 1) & ~(psize - 1);
-	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,
-					MAP_SHARED, devMemFd, (off_t)Base+BUS_BASE);
-	if ((long)ptr == -1)
-	{
-		xf86Msg(X_WARNING, 
-			"xf86ReadBIOS: %s mmap[s=%x,a=%x,o=%x] failed (%s)\n",
-			DEV_MEM, Len, Base, Offset, strerror(errno));
-		return(-1);
-	}
-#ifdef DEBUG
-	ErrorF("xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",
-		Base, ptr[0] | (ptr[1] << 8));
-#endif
-	(void)memcpy(Buf, (void *)(ptr + Offset), Len);
-	(void)munmap((caddr_t)ptr, mlen);
-#ifdef DEBUG
-	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"
-		"-> %02x %02x %02x %02x...\n",
-		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);
-#endif
-	return(Len);
-}
-
-
-/* XXX This needs to be updated for the ND */
-
-/*
-** Find out whether the console driver provides memory mapping information 
-** for the specified region and return the map_info pointer. Print a warning if required.
-*/
-static struct memAccess *
-checkMapInfo(Bool warn, int Region)
-{
-    struct memAccess *memAccP;
-        
-    switch (Region)
-    {
-	case VGA_REGION:
-	    memAccP = &vgaMemInfo;
-	    break;
-	    	    
-	case LINEAR_REGION:
-	    memAccP = &linearMemInfo;
-	    break;
-	    
-	case MMIO_REGION:
-	    memAccP = &ioMemInfo;
-	    break;
-	
-	default:
-	    return NULL;
-	    break;
-    }
-    
-    if(!memAccP->Checked)
-    {	
-	if(ioctl(xf86Info.screenFd, memAccP->ioctl, &(memAccP->memInfo)) == -1)
-	{
-	    if(warn)
-	    {
-		xf86Msg(X_WARNING,
-		 "checkMapInfo: failed to get map info for region %d\n\t(%s)\n",
-		       Region, strerror(errno));
-	    }
-	}
-	else
-	{
-	    if(memAccP->memInfo.u.map_info_mmap.map_offset 
-	       != MAP_INFO_UNKNOWN)
-		memAccP->OK = TRUE;
-	}
-	memAccP->Checked = TRUE;
-    }
-    if (memAccP->OK)
-    {
-	return memAccP;
-    }
-    else
-    {
-	return NULL;
-    }
-}
-
-static pointer
-xf86MapInfoMap(struct memAccess *memInfoP, pointer Base, unsigned long Size)
-{
-    struct map_info *mapInfoP = &(memInfoP->memInfo);
-
-    if (mapInfoP->u.map_info_mmap.map_size == MAP_INFO_UNKNOWN)
-    {	
-	Size = (unsigned long)Base + Size;
-    }
-    else
-    {
-	Size = mapInfoP->u.map_info_mmap.map_size;
-    }
-    
-    switch(mapInfoP->method)
-    {
-	case MAP_MMAP:
-	    /* Need to remap if size is unknown because we may not have
-	       mapped the whole region initially */
-	    if(memInfoP->regionVirtBase == NULL ||
-	       mapInfoP->u.map_info_mmap.map_size == MAP_INFO_UNKNOWN)
-	    {
-		if((memInfoP->regionVirtBase = 
-		    mmap((caddr_t)0,
-			 Size,
-			 PROT_READ | PROT_WRITE,
-			 MAP_SHARED,
-			 xf86Info.screenFd,
-			 (unsigned long)mapInfoP->u.map_info_mmap.map_offset))
-		   == (pointer)-1)
-		{
-		    FatalError("xf86MapInfoMap: Failed to map memory at 0x%x\n\t%s\n", 
-			       mapInfoP->u.map_info_mmap.map_offset, strerror(errno));
-		}
-		if(mapInfoP->u.map_info_mmap.internal_offset > 0)
-		    memInfoP->regionVirtBase += 
-			mapInfoP->u.map_info_mmap.internal_offset;
-	    }
-	    break;
-	    
-	default:
-	    FatalError("xf86MapInfoMap: Unsuported mapping method\n");
-	    break;
-    }
-	    
-    return (pointer)((int)memInfoP->regionVirtBase + (int)Base);
-}
-
-static void
-xf86MapInfoUnmap(struct memAccess *memInfoP, unsigned long Size)
-{
-    struct map_info *mapInfoP = &(memInfoP->memInfo);
-    
-    switch(mapInfoP->method)
-    {
-	case MAP_MMAP:
-	    if(memInfoP->regionVirtBase != NULL)
-	    {
-		if(mapInfoP->u.map_info_mmap.map_size != MAP_INFO_UNKNOWN)
-		    Size = mapInfoP->u.map_info_mmap.map_size;
-		munmap((caddr_t)memInfoP->regionVirtBase, Size);
-		memInfoP->regionVirtBase = NULL;
-	    }
-	    break;
-	 default:
-	    FatalError("xf86MapInfoMap: Unsuported mapping method\n");
-	    break;
-    }
-}
-
-static pointer
-armMapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
-{
-	struct memAccess *memInfoP;
-	
-	if((memInfoP = checkMapInfo(FALSE, Region)) != NULL)
-	{
-	    /*
-	     ** xf86 passes in a physical address offset from the start
-	     ** of physical memory, but xf86MapInfoMap expects an 
-	     ** offset from the start of the specified region - it gets 
-	     ** the physical address of the region from the display driver.
-	     */
-	    switch(Region)
-	    {
-	        case LINEAR_REGION:
-		    if (vgaPhysLinearBase)
-		    {
-			Base -= vgaPhysLinearBase;
-		    }
-		    break;
-		case VGA_REGION:
-		    Base -= 0xA0000;
-		    break;
-	    }
-	    
-	    base = xf86MapInfoMap(memInfoP, Base, Size);
-	    return (base);
-	}
-	return mapVidMem(ScreenNum, Base, Size, flags);
-}
-
-static void
-armUnmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
-{
-        struct memAccess *memInfoP;
-	
-	if((memInfoP = checkMapInfo(FALSE, Region)) != NULL)
-	{
-	    xf86MapInfoUnmap(memInfoP, Base, Size);
-	}
-	unmapVidMem(ScreenNum, Base, Size);
-}
-
-#ifdef USE_DEV_IO
-static int IoFd = -1;
-
-Bool
-xf86EnableIO()
-{
-	if (IoFd >= 0)
-		return TRUE;
-
-	if ((IoFd = open("/dev/io", O_RDWR)) == -1)
-	{
-		xf86Msg(X_WARNING,"xf86EnableIO: "
-				"Failed to open /dev/io for extended I/O\n");
-		return FALSE;
-	}
-	return TRUE;
-}
-
-void
-xf86DisableIO()
-{
-	if (IoFd < 0)
-		return;
-
-	close(IoFd);
-	IoFd = -1;
-	return;
-}
-
-#endif
-
-#if defined(USE_ARC_MMAP) || defined(__arm32__)
-
-Bool
-xf86EnableIO()
-{
-	int fd;
-	pointer base;
-
-	if (ExtendedEnabled)
-		return TRUE;
-
-	if ((fd = open("/dev/ttyC0", O_RDWR)) >= 0) {
-		/* Try to map a page at the pccons I/O space */
-		base = (pointer)mmap((caddr_t)0, 65536, PROT_READ | PROT_WRITE,
-				MAP_FLAGS, fd, (off_t)0x0000);
-
-		if (base != (pointer)-1) {
-			IOPortBase = base;
-		}
-		else {
-			xf86Msg(X_WARNING,"EnableIO: failed to mmap %s (%s)\n",
-				"/dev/ttyC0", strerror(errno));
-			return FALSE;
-		}
-	}
-	else {
-		xf86Msg("EnableIO: failed to open %s (%s)\n",
-			"/dev/ttyC0", strerror(errno));
-		return FALSE;
-	}
-	
-	ExtendedEnabled = TRUE;
-
-	return TRUE;
-}
-
-void
-xf86DisableIO()
-{
-	return;
-}
-
-#endif /* USE_ARC_MMAP */
-
-#if 0
-/*
- * XXX This is here for reference.  It needs to be handled differently for the
- * ND.
- */
-#if defined(USE_ARC_MMAP) || defined(__arm32__)
-
-#ifdef USE_ARM32_MMAP
-#define	DEV_MEM_IOBASE	0x43000000
-#endif
-
-static Bool ScreenEnabled[MAXSCREENS];
-static Bool ExtendedEnabled = FALSE;
-static Bool InitDone = FALSE;
-
-Bool
-xf86EnableIOPorts(ScreenNum)
-int ScreenNum;
-{
-	int i;
-	int fd;
-	pointer base;
-
-#ifdef __arm32__
-	struct memAccess *memInfoP;
-	int *Size;
-#endif
-
-	ScreenEnabled[ScreenNum] = TRUE;
-
-	if (ExtendedEnabled)
-		return TRUE;
-
-#ifdef USE_ARC_MMAP
-	if ((fd = open("/dev/ttyC0", O_RDWR)) >= 0) {
-		/* Try to map a page at the pccons I/O space */
-		base = (pointer)mmap((caddr_t)0, 65536, PROT_READ | PROT_WRITE,
-				MAP_FLAGS, fd, (off_t)0x0000);
-
-		if (base != (pointer)-1) {
-			IOPortBase = base;
-		}
-		else {
-			xf86Msg(X_ERROR,
-				"EnableIOPorts: failed to mmap %s (%s)\n",
-				"/dev/ttyC0", strerror(errno));
-		}
-	}
-	else {
-		xf86Msg(X_ERROR, "EnableIOPorts: failed to open %s (%s)\n",
-			"/dev/ttyC0", strerror(errno));
-	}
-#endif
-
-#ifdef __arm32__
-	IOPortBase = (unsigned int)-1;
-
-	if((memInfoP = checkMapInfo(TRUE, MMIO_REGION)) != NULL)
-	{
-	    /* 
-	     * xf86MapInfoMap maps an offset from the start of video IO
-	     * space (e.g. 0x3B0), but IOPortBase is expected to map to
-	     * physical address 0x000, so subtract the start of video I/O
-	     * space from the result.  This is safe for now becase we
-	     * actually mmap the start of the page, then the start of video
-	     * I/O space is added as an internal offset.
-	     */
-	    IOPortBase = (unsigned int)xf86MapInfoMap(memInfoP,
-						      (caddr_t)0x0, 0L) 
-		- memInfoP->memInfo.u.map_info_mmap.internal_offset;
-	    ExtendedEnabled = TRUE;
-	    return TRUE;
-	}
-#ifdef USE_ARM32_MMAP
-	checkDevMem(TRUE);
-
-	if (devMemFd >= 0 && useDevMem)
-	{
-	    base = (pointer)mmap((caddr_t)0, 0x400, PROT_READ | PROT_WRITE,
-				 MAP_FLAGS, devMemFd, (off_t)DEV_MEM_IOBASE);
-
-	    if (base != (pointer)-1)
-		IOPortBase = (unsigned int)base;
-	}
-
-        if (IOPortBase == (unsigned int)-1)
-	{	
-	    xf86Msg(X_WARNING,"xf86EnableIOPorts: failed to open mem device or map IO base. \n\
-Make sure you have the Aperture Driver installed, or a kernel built with the INSECURE option\n");
-	    return FALSE;
-	}
-#else
-	/* We don't have the IOBASE, so we can't map the address */
-	xf86Msg(X_WARNING,"xf86EnableIOPorts: failed to open mem device or map IO base. \n\
-Try building the server with USE_ARM32_MMAP defined\n");
-	return FALSE;
-#endif
-#endif
-	
-	ExtendedEnabled = TRUE;
-
-	return TRUE;
-}
-
-void
-xf86DisableIOPorts(ScreenNum)
-int ScreenNum;
-{
-	int i;
-#ifdef __arm32__
-        struct memAccess *memInfoP;
-#endif
-
-	ScreenEnabled[ScreenNum] = FALSE;
-
-#ifdef __arm32__
-	if((memInfoP = checkMapInfo(FALSE, MMIO_REGION)) != NULL)
-	{
-	    xf86MapInfoUnmap(memInfoP, 0);
-	}
-#endif
-
-#ifdef USE_ARM32_MMAP
-	if (!ExtendedEnabled)
-	return;
-
-	for (i = 0; i < MAXSCREENS; i++)
-		if (ScreenEnabled[i])
-			return;
-
-	munmap((caddr_t)IOPortBase, 0x400);
-	IOPortBase = (unsigned int)-1;
-	ExtendedEnabled = FALSE;
-#endif
-
-	return;
-}
-
-#endif /* USE_ARC_MMAP || USE_ARM32_MMAP */
-#endif
-
-
+/*

+ * Copyright 1992 by Rich Murphey <Rich@Rice.edu>

+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>

+ *

+ * 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 names of Rich Murphey and David Wexelblat 

+ * not be used in advertising or publicity pertaining to distribution of 

+ * the software without specific, written prior permission.  Rich Murphey and

+ * David Wexelblat make no representations about the suitability of this 

+ * software for any purpose.  It is provided "as is" without express or 

+ * implied warranty.

+ *

+ * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 

+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

+ * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT 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.

+ *

+ */

+

+/*

+ * The ARM32 code here carries the following copyright:

+ *

+ * Copyright 1997

+ * Digital Equipment Corporation. All rights reserved.

+ * This software is furnished under license and may be used and copied only in 

+ * accordance with the following terms and conditions.  Subject to these

+ * conditions, you may download, copy, install, use, modify and distribute

+ * this software in source and/or binary form. No title or ownership is

+ * transferred hereby.

+ *

+ * 1) Any source code used, modified or distributed must reproduce and retain

+ *    this copyright notice and list of conditions as they appear in the

+ *    source file.

+ *

+ * 2) No right is granted to use any trade name, trademark, or logo of Digital 

+ *    Equipment Corporation. Neither the "Digital Equipment Corporation"

+ *    name nor any trademark or logo of Digital Equipment Corporation may be

+ *    used to endorse or promote products derived from this software without

+ *    the prior written permission of Digital Equipment Corporation.

+ *

+ * 3) This software is provided "AS-IS" and any express or implied warranties,

+ *    including but not limited to, any implied warranties of merchantability,

+ *    fitness for a particular purpose, or non-infringement are disclaimed.

+ *    In no event shall DIGITAL be liable for any damages whatsoever, and in

+ *    particular, DIGITAL shall not be liable for special, indirect,

+ *    consequential, or incidental damages or damages for lost profits, loss

+ *    of revenue or loss of use, whether such damages arise in contract, 

+ *    negligence, tort, under statute, in equity, at law or otherwise, even

+ *    if advised of the possibility of such damage. 

+ *

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86_OSlib.h"

+#include "xf86OSpriv.h"

+

+#ifdef __arm32__

+#include "machine/devmap.h"

+struct memAccess

+{

+    int ioctl;

+    struct map_info memInfo;

+    pointer regionVirtBase;

+    Bool Checked;

+    Bool OK;

+};

+

+static pointer xf86MapInfoMap();

+static void xf86MapInfoUnmap();

+static struct memAccess *checkMapInfo();

+extern int vgaPhysLinearBase;

+

+/* A memAccess structure is needed for each possible region */ 

+struct memAccess vgaMemInfo = { CONSOLE_GET_MEM_INFO, NULL, NULL, 

+				    FALSE, FALSE };

+struct memAccess linearMemInfo = { CONSOLE_GET_LINEAR_INFO, NULL, NULL, 

+				       FALSE, FALSE };

+struct memAccess ioMemInfo = { CONSOLE_GET_IO_INFO, NULL, NULL,

+				   FALSE, FALSE };

+#endif /* __arm32__ */

+

+#if defined(__NetBSD__) && !defined(MAP_FILE)

+#define MAP_FLAGS MAP_SHARED

+#else

+#define MAP_FLAGS (MAP_FILE | MAP_SHARED)

+#endif

+

+#ifndef MAP_FAILED

+#define MAP_FAILED ((caddr_t)-1)

+#endif

+

+

+#define BUS_BASE	0L

+#define BUS_BASE_BWX	0L

+

+

+/***************************************************************************/

+/* Video Memory Mapping section                                            */

+/***************************************************************************/

+

+static Bool useDevMem = FALSE;

+static int  devMemFd = -1;

+

+#define DEV_MEM "/dev/mem"

+

+static pointer mapVidMem(int, unsigned long, unsigned long, int);

+static void unmapVidMem(int, pointer, unsigned long);

+

+/*

+ * Check if /dev/mem can be mmap'd.  If it can't print a warning when

+ * "warn" is TRUE.

+ */

+static void

+checkDevMem(Bool warn)

+{

+	static Bool devMemChecked = FALSE;

+	int fd;

+	pointer base;

+

+	if (devMemChecked)

+	    return;

+	devMemChecked = TRUE;

+

+	if ((fd = open(DEV_MEM, O_RDWR)) >= 0)

+	{

+	    /* Try to map a page at the VGA address */

+	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,

+				 MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);

+	

+	    if (base != MAP_FAILED)

+	    {

+		munmap((caddr_t)base, 4096);

+		devMemFd = fd;

+		useDevMem = TRUE;

+		return;

+	    } else {

+		/* This should not happen */

+		if (warn)

+		{

+		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",

+			    DEV_MEM, strerror(errno));

+		}

+		useDevMem = FALSE;

+		return;

+	    }

+	}

+	if (warn)

+	{ 

+	    xf86Msg(X_WARNING, "checkDevMem: failed to open %s (%s)\n",

+		    DEV_MEM, strerror(errno));

+	} 

+	useDevMem = FALSE;

+	return;

+}

+

+void

+xf86OSInitVidMem(VidMemInfoPtr pVidMem)

+{

+

+	checkDevMem(TRUE);

+	pVidMem->linearSupported = useDevMem;

+	pVidMem->mapMem = armMapVidMem;

+	pVidMem->unmapVidMem = armUnmapVidMem;

+

+	pVidMem->initialised = TRUE;

+}

+

+static pointer

+mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

+{

+	pointer base;

+

+	checkDevMem(FALSE);

+

+	if (useDevMem)

+	{

+	    if (devMemFd < 0) 

+	    {

+		FatalError("xf86MapVidMem: failed to open %s (%s)\n",

+			   DEV_MEM, strerror(errno));

+	    }

+	    base = mmap((caddr_t)0, Size,

+			(flags & VIDMEM_READONLY) ?

+			 PROT_READ : (PROT_READ | PROT_WRITE),

+			MAP_FLAGS, devMemFd, (off_t)Base + BUS_BASE_BWX);

+	    if (base == MAP_FAILED)

+	    {

+		FatalError("%s: could not mmap %s [s=%x,a=%x] (%s)\n",

+			   "xf86MapVidMem", DEV_MEM, Size, Base, 

+			   strerror(errno));

+	    }

+	    return base;

+	}

+		

+	/* else, mmap /dev/vga */

+	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)

+	{

+		FatalError("%s: Address 0x%x outside allowable range\n",

+			   "xf86MapVidMem", Base);

+	}

+	base = mmap(0, Size,

+		    (flags & VIDMEM_READONLY) ?

+		     PROT_READ : (PROT_READ | PROT_WRITE),

+		    MAP_FLAGS, xf86Info.screenFd,

+		    (unsigned long)Base - 0xA0000);

+	if (base == MAP_FAILED)

+	{

+	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)\n",

+		       strerror(errno));

+	}

+	return base;

+}

+

+static void

+unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

+{

+	munmap((caddr_t)Base, Size);

+}

+

+/*

+ * Read BIOS via mmap()ing DEV_MEM

+ */

+

+int

+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

+	     int Len)

+{

+	unsigned char *ptr;

+	int psize;

+	int mlen;

+

+	checkDevMem(TRUE);

+	if (devMemFd == -1) {

+	    return -1;

+	}

+

+	psize = getpagesize();

+	Offset += Base & (psize - 1);

+	Base &= ~(psize - 1);

+	mlen = (Offset + Len + psize - 1) & ~(psize - 1);

+	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,

+					MAP_SHARED, devMemFd, (off_t)Base+BUS_BASE);

+	if ((long)ptr == -1)

+	{

+		xf86Msg(X_WARNING, 

+			"xf86ReadBIOS: %s mmap[s=%x,a=%x,o=%x] failed (%s)\n",

+			DEV_MEM, Len, Base, Offset, strerror(errno));

+		return -1;

+	}

+#ifdef DEBUG

+	ErrorF("xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",

+		Base, ptr[0] | (ptr[1] << 8));

+#endif

+	(void)memcpy(Buf, (void *)(ptr + Offset), Len);

+	(void)munmap((caddr_t)ptr, mlen);

+#ifdef DEBUG

+	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"

+		"-> %02x %02x %02x %02x...\n",

+		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);

+#endif

+	return Len;

+}

+

+

+/* XXX This needs to be updated for the ND */

+

+/*

+** Find out whether the console driver provides memory mapping information 

+** for the specified region and return the map_info pointer. Print a warning if required.

+*/

+static struct memAccess *

+checkMapInfo(Bool warn, int Region)

+{

+    struct memAccess *memAccP;

+        

+    switch (Region)

+    {

+	case VGA_REGION:

+	    memAccP = &vgaMemInfo;

+	    break;

+	    	    

+	case LINEAR_REGION:

+	    memAccP = &linearMemInfo;

+	    break;

+	    

+	case MMIO_REGION:

+	    memAccP = &ioMemInfo;

+	    break;

+	

+	default:

+	    return NULL;

+	    break;

+    }

+    

+    if(!memAccP->Checked)

+    {	

+	if(ioctl(xf86Info.screenFd, memAccP->ioctl, &(memAccP->memInfo)) == -1)

+	{

+	    if(warn)

+	    {

+		xf86Msg(X_WARNING,

+		 "checkMapInfo: failed to get map info for region %d\n\t(%s)\n",

+		       Region, strerror(errno));

+	    }

+	}

+	else

+	{

+	    if(memAccP->memInfo.u.map_info_mmap.map_offset 

+	       != MAP_INFO_UNKNOWN)

+		memAccP->OK = TRUE;

+	}

+	memAccP->Checked = TRUE;

+    }

+    if (memAccP->OK)

+    {

+	return memAccP;

+    }

+    else

+    {

+	return NULL;

+    }

+}

+

+static pointer

+xf86MapInfoMap(struct memAccess *memInfoP, pointer Base, unsigned long Size)

+{

+    struct map_info *mapInfoP = &(memInfoP->memInfo);

+

+    if (mapInfoP->u.map_info_mmap.map_size == MAP_INFO_UNKNOWN)

+    {	

+	Size = (unsigned long)Base + Size;

+    }

+    else

+    {

+	Size = mapInfoP->u.map_info_mmap.map_size;

+    }

+    

+    switch(mapInfoP->method)

+    {

+	case MAP_MMAP:

+	    /* Need to remap if size is unknown because we may not have

+	       mapped the whole region initially */

+	    if(memInfoP->regionVirtBase == NULL ||

+	       mapInfoP->u.map_info_mmap.map_size == MAP_INFO_UNKNOWN)

+	    {

+		if((memInfoP->regionVirtBase = 

+		    mmap((caddr_t)0,

+			 Size,

+			 PROT_READ | PROT_WRITE,

+			 MAP_SHARED,

+			 xf86Info.screenFd,

+			 (unsigned long)mapInfoP->u.map_info_mmap.map_offset))

+		   == (pointer)-1)

+		{

+		    FatalError("xf86MapInfoMap: Failed to map memory at 0x%x\n\t%s\n", 

+			       mapInfoP->u.map_info_mmap.map_offset, strerror(errno));

+		}

+		if(mapInfoP->u.map_info_mmap.internal_offset > 0)

+		    memInfoP->regionVirtBase += 

+			mapInfoP->u.map_info_mmap.internal_offset;

+	    }

+	    break;

+	    

+	default:

+	    FatalError("xf86MapInfoMap: Unsuported mapping method\n");

+	    break;

+    }

+	    

+    return (pointer)((int)memInfoP->regionVirtBase + (int)Base);

+}

+

+static void

+xf86MapInfoUnmap(struct memAccess *memInfoP, unsigned long Size)

+{

+    struct map_info *mapInfoP = &(memInfoP->memInfo);

+    

+    switch(mapInfoP->method)

+    {

+	case MAP_MMAP:

+	    if(memInfoP->regionVirtBase != NULL)

+	    {

+		if(mapInfoP->u.map_info_mmap.map_size != MAP_INFO_UNKNOWN)

+		    Size = mapInfoP->u.map_info_mmap.map_size;

+		munmap((caddr_t)memInfoP->regionVirtBase, Size);

+		memInfoP->regionVirtBase = NULL;

+	    }

+	    break;

+	 default:

+	    FatalError("xf86MapInfoMap: Unsuported mapping method\n");

+	    break;

+    }

+}

+

+static pointer

+armMapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

+{

+	struct memAccess *memInfoP;

+	

+	if((memInfoP = checkMapInfo(FALSE, Region)) != NULL)

+	{

+	    /*

+	     ** xf86 passes in a physical address offset from the start

+	     ** of physical memory, but xf86MapInfoMap expects an 

+	     ** offset from the start of the specified region - it gets 

+	     ** the physical address of the region from the display driver.

+	     */

+	    switch(Region)

+	    {

+	        case LINEAR_REGION:

+		    if (vgaPhysLinearBase)

+		    {

+			Base -= vgaPhysLinearBase;

+		    }

+		    break;

+		case VGA_REGION:

+		    Base -= 0xA0000;

+		    break;

+	    }

+	    

+	    base = xf86MapInfoMap(memInfoP, Base, Size);

+	    return base;

+	}

+	return mapVidMem(ScreenNum, Base, Size, flags);

+}

+

+static void

+armUnmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

+{

+        struct memAccess *memInfoP;

+	

+	if((memInfoP = checkMapInfo(FALSE, Region)) != NULL)

+	{

+	    xf86MapInfoUnmap(memInfoP, Base, Size);

+	}

+	unmapVidMem(ScreenNum, Base, Size);

+}

+

+#ifdef USE_DEV_IO

+static int IoFd = -1;

+

+Bool

+xf86EnableIO()

+{

+	if (IoFd >= 0)

+		return TRUE;

+

+	if ((IoFd = open("/dev/io", O_RDWR)) == -1)

+	{

+		xf86Msg(X_WARNING,"xf86EnableIO: "

+				"Failed to open /dev/io for extended I/O\n");

+		return FALSE;

+	}

+	return TRUE;

+}

+

+void

+xf86DisableIO()

+{

+	if (IoFd < 0)

+		return;

+

+	close(IoFd);

+	IoFd = -1;

+	return;

+}

+

+#endif

+

+#if defined(USE_ARC_MMAP) || defined(__arm32__)

+

+Bool

+xf86EnableIO()

+{

+	int fd;

+	pointer base;

+

+	if (ExtendedEnabled)

+		return TRUE;

+

+	if ((fd = open("/dev/ttyC0", O_RDWR)) >= 0) {

+		/* Try to map a page at the pccons I/O space */

+		base = (pointer)mmap((caddr_t)0, 65536, PROT_READ | PROT_WRITE,

+				MAP_FLAGS, fd, (off_t)0x0000);

+

+		if (base != (pointer)-1) {

+			IOPortBase = base;

+		}

+		else {

+			xf86Msg(X_WARNING,"EnableIO: failed to mmap %s (%s)\n",

+				"/dev/ttyC0", strerror(errno));

+			return FALSE;

+		}

+	}

+	else {

+		xf86Msg("EnableIO: failed to open %s (%s)\n",

+			"/dev/ttyC0", strerror(errno));

+		return FALSE;

+	}

+	

+	ExtendedEnabled = TRUE;

+

+	return TRUE;

+}

+

+void

+xf86DisableIO()

+{

+	return;

+}

+

+#endif /* USE_ARC_MMAP */

+

+#if 0

+/*

+ * XXX This is here for reference.  It needs to be handled differently for the

+ * ND.

+ */

+#if defined(USE_ARC_MMAP) || defined(__arm32__)

+

+#ifdef USE_ARM32_MMAP

+#define	DEV_MEM_IOBASE	0x43000000

+#endif

+

+static Bool ScreenEnabled[MAXSCREENS];

+static Bool ExtendedEnabled = FALSE;

+static Bool InitDone = FALSE;

+

+Bool

+xf86EnableIOPorts(ScreenNum)

+int ScreenNum;

+{

+	int i;

+	int fd;

+	pointer base;

+

+#ifdef __arm32__

+	struct memAccess *memInfoP;

+	int *Size;

+#endif

+

+	ScreenEnabled[ScreenNum] = TRUE;

+

+	if (ExtendedEnabled)

+		return TRUE;

+

+#ifdef USE_ARC_MMAP

+	if ((fd = open("/dev/ttyC0", O_RDWR)) >= 0) {

+		/* Try to map a page at the pccons I/O space */

+		base = (pointer)mmap((caddr_t)0, 65536, PROT_READ | PROT_WRITE,

+				MAP_FLAGS, fd, (off_t)0x0000);

+

+		if (base != (pointer)-1) {

+			IOPortBase = base;

+		}

+		else {

+			xf86Msg(X_ERROR,

+				"EnableIOPorts: failed to mmap %s (%s)\n",

+				"/dev/ttyC0", strerror(errno));

+		}

+	}

+	else {

+		xf86Msg(X_ERROR, "EnableIOPorts: failed to open %s (%s)\n",

+			"/dev/ttyC0", strerror(errno));

+	}

+#endif

+

+#ifdef __arm32__

+	IOPortBase = (unsigned int)-1;

+

+	if((memInfoP = checkMapInfo(TRUE, MMIO_REGION)) != NULL)

+	{

+	    /* 

+	     * xf86MapInfoMap maps an offset from the start of video IO

+	     * space (e.g. 0x3B0), but IOPortBase is expected to map to

+	     * physical address 0x000, so subtract the start of video I/O

+	     * space from the result.  This is safe for now becase we

+	     * actually mmap the start of the page, then the start of video

+	     * I/O space is added as an internal offset.

+	     */

+	    IOPortBase = (unsigned int)xf86MapInfoMap(memInfoP,

+						      (caddr_t)0x0, 0L) 

+		- memInfoP->memInfo.u.map_info_mmap.internal_offset;

+	    ExtendedEnabled = TRUE;

+	    return TRUE;

+	}

+#ifdef USE_ARM32_MMAP

+	checkDevMem(TRUE);

+

+	if (devMemFd >= 0 && useDevMem)

+	{

+	    base = (pointer)mmap((caddr_t)0, 0x400, PROT_READ | PROT_WRITE,

+				 MAP_FLAGS, devMemFd, (off_t)DEV_MEM_IOBASE);

+

+	    if (base != (pointer)-1)

+		IOPortBase = (unsigned int)base;

+	}

+

+        if (IOPortBase == (unsigned int)-1)

+	{	

+	    xf86Msg(X_WARNING,"xf86EnableIOPorts: failed to open mem device or map IO base. \n\

+Make sure you have the Aperture Driver installed, or a kernel built with the INSECURE option\n");

+	    return FALSE;

+	}

+#else

+	/* We don't have the IOBASE, so we can't map the address */

+	xf86Msg(X_WARNING,"xf86EnableIOPorts: failed to open mem device or map IO base. \n\

+Try building the server with USE_ARM32_MMAP defined\n");

+	return FALSE;

+#endif

+#endif

+	

+	ExtendedEnabled = TRUE;

+

+	return TRUE;

+}

+

+void

+xf86DisableIOPorts(ScreenNum)

+int ScreenNum;

+{

+	int i;

+#ifdef __arm32__

+        struct memAccess *memInfoP;

+#endif

+

+	ScreenEnabled[ScreenNum] = FALSE;

+

+#ifdef __arm32__

+	if((memInfoP = checkMapInfo(FALSE, MMIO_REGION)) != NULL)

+	{

+	    xf86MapInfoUnmap(memInfoP, 0);

+	}

+#endif

+

+#ifdef USE_ARM32_MMAP

+	if (!ExtendedEnabled)

+	return;

+

+	for (i = 0; i < MAXSCREENS; i++)

+		if (ScreenEnabled[i])

+			return;

+

+	munmap((caddr_t)IOPortBase, 0x400);

+	IOPortBase = (unsigned int)-1;

+	ExtendedEnabled = FALSE;

+#endif

+

+	return;

+}

+

+#endif /* USE_ARC_MMAP || USE_ARM32_MMAP */

+#endif

+

+

diff --git a/xorg-server/hw/xfree86/os-support/bsd/bsd_VTsw.c b/xorg-server/hw/xfree86/os-support/bsd/bsd_VTsw.c
index 90c9c30b1..15220d743 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/bsd_VTsw.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/bsd_VTsw.c
@@ -57,7 +57,7 @@ xf86VTSwitchPending()
 {

 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)

 	if (xf86Info.consType == SYSCONS || xf86Info.consType == PCVT) {

-		return(xf86Info.vtRequestsPending ? TRUE : FALSE);

+		return xf86Info.vtRequestsPending ? TRUE : FALSE;

 	}

 #endif

 	return FALSE;

@@ -70,9 +70,9 @@ xf86VTSwitchAway()
 	if (xf86Info.consType == SYSCONS || xf86Info.consType == PCVT) {

 		xf86Info.vtRequestsPending = FALSE;

 		if (ioctl(xf86Info.consoleFd, VT_RELDISP, 1) < 0)

-			return(FALSE);

+			return FALSE;

 		else

-			return(TRUE);

+			return TRUE;

 	}

 #endif

 	return FALSE;

@@ -85,19 +85,19 @@ xf86VTSwitchTo()
 	if (xf86Info.consType == SYSCONS || xf86Info.consType == PCVT) {

 		xf86Info.vtRequestsPending = FALSE;

 		if (ioctl(xf86Info.consoleFd, VT_RELDISP, VT_ACKACQ) < 0)

-			return(FALSE);

+			return FALSE;

 		else

-			return(TRUE);

+			return TRUE;

 	}

 #endif

-	return(TRUE);

+	return TRUE;

 }

 

 Bool

 xf86VTActivate(int vtno)

 {

 	if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, vtno) < 0) {

-		return(FALSE);

+		return FALSE;

 	}

-	return(TRUE);

+	return TRUE;

 }

diff --git a/xorg-server/hw/xfree86/os-support/bsd/bsd_init.c b/xorg-server/hw/xfree86/os-support/bsd/bsd_init.c
index 7698084ee..62618afd8 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/bsd_init.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/bsd_init.c
@@ -1,760 +1,760 @@
-/*
- * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
- * Copyright 1993 by David Wexelblat <dwex@goblin.org>
- *
- * 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 names of Rich Murphey and David Wexelblat 
- * not be used in advertising or publicity pertaining to distribution of 
- * the software without specific, written prior permission.  Rich Murphey and
- * David Wexelblat make no representations about the suitability of this 
- * software for any purpose.  It is provided "as is" without express or 
- * implied warranty.
- *
- * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 
- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
- * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT 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_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-
-#include "compiler.h"
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-
-#include <sys/utsname.h>
-#include <sys/ioctl.h>
-#include <stdlib.h>
-#include <errno.h>
-
-static Bool KeepTty = FALSE;
-static int devConsoleFd = -1;
-#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
-static int VTnum = -1;
-static int initialVT = -1;
-static Bool ShareVTs = FALSE;
-#endif
-
-#ifdef PCCONS_SUPPORT
-/* Stock 0.1 386bsd pccons console driver interface */
-#ifndef __OpenBSD__
-#  define PCCONS_CONSOLE_DEV1 "/dev/ttyv0"
-#else
-#  define PCCONS_CONSOLE_DEV1 "/dev/ttyC0"
-#endif
-#define PCCONS_CONSOLE_DEV2 "/dev/vga"
-#define PCCONS_CONSOLE_MODE O_RDWR|O_NDELAY
-#endif
-
-#ifdef SYSCONS_SUPPORT
-/* The FreeBSD 1.1 version syscons driver uses /dev/ttyv0 */
-#define SYSCONS_CONSOLE_DEV1 "/dev/ttyv0"
-#define SYSCONS_CONSOLE_DEV2 "/dev/vga"
-#define SYSCONS_CONSOLE_MODE O_RDWR|O_NDELAY
-#endif
-
-#ifdef PCVT_SUPPORT
-/* Hellmuth Michaelis' pcvt driver */
-#ifndef __OpenBSD__
-#  define PCVT_CONSOLE_DEV "/dev/ttyv0"
-#else
-#  define PCVT_CONSOLE_DEV "/dev/ttyC0"
-#endif
-#define PCVT_CONSOLE_MODE O_RDWR|O_NDELAY
-#endif
-
-#if defined(WSCONS_SUPPORT) && defined(__NetBSD__)
-/* NetBSD's new console driver */
-#define WSCONS_PCVT_COMPAT_CONSOLE_DEV "/dev/ttyE0"
-#endif
-
-#ifdef __GLIBC__
-#define setpgrp setpgid
-#endif
-
-#define CHECK_DRIVER_MSG \
-  "Check your kernel's console driver configuration and /dev entries"
-
-static char *supported_drivers[] = {
-#ifdef PCCONS_SUPPORT
-	"pccons (with X support)",
-#endif
-#ifdef SYSCONS_SUPPORT
-	"syscons",
-#endif
-#ifdef PCVT_SUPPORT
-	"pcvt",
-#endif
-#ifdef WSCONS_SUPPORT
-	"wscons",
-#endif
-};
-
-
-/*
- * Functions to probe for the existance of a supported console driver.
- * Any function returns either a valid file descriptor (driver probed
- * succesfully), -1 (driver not found), or uses FatalError() if the
- * driver was found but proved to not support the required mode to run
- * an X server.
- */
-
-typedef int (*xf86ConsOpen_t)(void);
-
-#ifdef PCCONS_SUPPORT
-static int xf86OpenPccons(void);
-#endif /* PCCONS_SUPPORT */
-
-#ifdef SYSCONS_SUPPORT
-static int xf86OpenSyscons(void);
-#endif /* SYSCONS_SUPPORT */
-
-#ifdef PCVT_SUPPORT
-static int xf86OpenPcvt(void);
-#endif /* PCVT_SUPPORT */
-
-#ifdef WSCONS_SUPPORT
-static int xf86OpenWScons(void);
-#endif
-
-/*
- * The sequence of the driver probes is important; start with the
- * driver that is best distinguishable, and end with the most generic
- * driver.  (Otherwise, pcvt would also probe as syscons, and either
- * pcvt or syscons might succesfully probe as pccons.)
- */
-static xf86ConsOpen_t xf86ConsTab[] = {
-#ifdef PCVT_SUPPORT
-    xf86OpenPcvt,
-#endif
-#ifdef SYSCONS_SUPPORT
-    xf86OpenSyscons,
-#endif
-#ifdef PCCONS_SUPPORT
-    xf86OpenPccons,
-#endif
-#ifdef WSCONS_SUPPORT
-    xf86OpenWScons,
-#endif
-    (xf86ConsOpen_t)NULL
-};
-
-
-void
-xf86OpenConsole()
-{
-    int i, fd = -1;
-    xf86ConsOpen_t *driver;
-#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
-    int result;
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-    struct utsname uts;
-#endif
-    vtmode_t vtmode;
-#endif
-    
-    if (serverGeneration == 1)
-    {
-	/* check if we are run with euid==0 */
-	if (geteuid() != 0)
-	{
-	    FatalError("xf86OpenConsole: Server must be suid root");
-	}
-
-	if (!KeepTty)
-	{
-	    /*
-	     * detaching the controlling tty solves problems of kbd character
-	     * loss.  This is not interesting for CO driver, because it is 
-	     * exclusive.
-	     */
-	    setpgrp(0, getpid());
-	    if ((i = open("/dev/tty",O_RDWR)) >= 0)
-	    {
-		ioctl(i,TIOCNOTTY,(char *)0);
-		close(i);
-	    }
-	}
-
-	/* detect which driver we are running on */
-	for (driver = xf86ConsTab; *driver; driver++)
-	{
-	    if ((fd = (*driver)()) >= 0)
-		break;
-	}
-
-	/* Check that a supported console driver was found */
-	if (fd < 0)
-	{
-	    char cons_drivers[80] = {0, };
-	    for (i = 0; i < sizeof(supported_drivers) / sizeof(char *); i++)
-	    {
-		if (i)
-		{
-		    strcat(cons_drivers, ", ");
-		}
-		strcat(cons_drivers, supported_drivers[i]);
-	    }
-	    FatalError(
-		"%s: No console driver found\n\tSupported drivers: %s\n\t%s",
-		"xf86OpenConsole", cons_drivers, CHECK_DRIVER_MSG);
-	}
-#if 0 /* stdin is already closed in OsInit() */
-	fclose(stdin);
-#endif
-	xf86Info.consoleFd = fd;
-	xf86Info.screenFd = fd;
-
-	switch (xf86Info.consType)
-	{
-#ifdef PCCONS_SUPPORT
-	case PCCONS:
-	    if (ioctl (xf86Info.consoleFd, CONSOLE_X_MODE_ON, 0) < 0)
-	    {
-		FatalError("%s: CONSOLE_X_MODE_ON failed (%s)\n%s",
-			   "xf86OpenConsole", strerror(errno),
-			   CHECK_DRIVER_MSG);
-	    }
-	    /*
-	     * Hack to prevent keyboard hanging when syslogd closes
-	     * /dev/console
-	     */
-	    if ((devConsoleFd = open("/dev/console", O_WRONLY,0)) < 0)
-	    {
-		xf86Msg(X_WARNING,
-			"xf86OpenConsole: couldn't open /dev/console (%s)\n",
-			strerror(errno));
-	    }
-	    break;
-#endif
-#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
-	case SYSCONS:
-	    /* as of FreeBSD 2.2.8, syscons driver does not need the #1 vt
-	     * switching anymore. Here we check for FreeBSD 3.1 and up.
-	     * Add cases for other *BSD that behave the same.
-	    */
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-	    uname (&uts);
-	    i = atof(uts.release) * 100;
-	    if (i >= 310) goto acquire_vt;
-#endif
-	    /* otherwise fall through */
-	case PCVT:
-#if !(defined(__NetBSD__) && (__NetBSD_Version__ >= 200000000))
-	    /*
-	     * First activate the #1 VT.  This is a hack to allow a server
-	     * to be started while another one is active.  There should be
-	     * a better way.
-	     */
-	    if (initialVT != 1) {
-
-		if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, 1) != 0)
-		{
-		    xf86Msg(X_WARNING,
-				"xf86OpenConsole: VT_ACTIVATE failed\n");
-		}
-		sleep(1);
-	    }
-#endif
-acquire_vt:
-	    if (!ShareVTs) {
-		    /*
-		     * now get the VT
-		     */
-		    SYSCALL(result =
-			    ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno));
-		    if (result != 0)
-		    {
-			xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");
-		    }
-		    SYSCALL(result =
-		    ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno));
-		    if (result != 0)
-		    {
-			xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed\n");
-		    }
-
-		    signal(SIGUSR1, xf86VTRequest);
-
-		    vtmode.mode = VT_PROCESS;
-		    vtmode.relsig = SIGUSR1;
-		    vtmode.acqsig = SIGUSR1;
-		    vtmode.frsig = SIGUSR1;
-		    if (ioctl(xf86Info.consoleFd, VT_SETMODE, &vtmode) < 0) 
-		    {
-			FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed");
-		    }
-	#if !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)
-		    if (ioctl(xf86Info.consoleFd, KDENABIO, 0) < 0)
-		    {
-			FatalError("xf86OpenConsole: KDENABIO failed (%s)",
-				   strerror(errno));
-		    }
-	#endif
-		    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0)
-		    {
-			FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed");
-		    }
-	    } else { /* ShareVTs */
-		    close(xf86Info.consoleFd);
-	    }	
-  	    break; 
-#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
-#ifdef WSCONS_SUPPORT
-	case WSCONS:
-	    /* Nothing to do */
-   	    break; 
-#endif
-        }
-    }
-    else 
-    {
-	/* serverGeneration != 1 */
-#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
-    	if (!ShareVTs) if (xf86Info.consType == SYSCONS || xf86Info.consType == PCVT)
-    	{
-	    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0)
-	    {
-	        xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");
-	    }
-        }
-#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
-    }
-    return;
-}
-
-
-#ifdef PCCONS_SUPPORT
-
-static int
-xf86OpenPccons()
-{
-    int fd = -1;
-
-    if ((fd = open(PCCONS_CONSOLE_DEV1, PCCONS_CONSOLE_MODE, 0))
-	>= 0 ||
-	(fd = open(PCCONS_CONSOLE_DEV2, PCCONS_CONSOLE_MODE, 0))
-	>= 0)
-    {
-	if (ioctl(fd, CONSOLE_X_MODE_OFF, 0) < 0)
-	{
-	    FatalError(
-		"%s: CONSOLE_X_MODE_OFF failed (%s)\n%s\n%s",
-		"xf86OpenPccons",
-		strerror(errno),
-		"Was expecting pccons driver with X support",
-		CHECK_DRIVER_MSG);
-	}
-	xf86Info.consType = PCCONS;
-	xf86Msg(X_PROBED, "Using pccons driver with X support\n");
-    }
-    return fd;
-}
-
-#endif /* PCCONS_SUPPORT */
-
-#ifdef SYSCONS_SUPPORT
-
-static int
-xf86OpenSyscons()
-{
-    int fd = -1;
-    vtmode_t vtmode;
-    char vtname[12];
-    struct stat status;
-    long syscons_version;
-    MessageType from;
-
-    /* Check for syscons */
-    if ((fd = open(SYSCONS_CONSOLE_DEV1, SYSCONS_CONSOLE_MODE, 0)) >= 0
-	|| (fd = open(SYSCONS_CONSOLE_DEV2, SYSCONS_CONSOLE_MODE, 0)) >= 0)
-    {
-	if (ioctl(fd, VT_GETMODE, &vtmode) >= 0)
-	{
-	    /* Get syscons version */
-	    if (ioctl(fd, CONS_GETVERS, &syscons_version) < 0)
-	    {
-		syscons_version = 0;
-	    }
-
-	    xf86Info.vtno = VTnum;
-	    from = X_CMDLINE;
-
-#ifdef VT_GETACTIVE
-	    if (ioctl(fd, VT_GETACTIVE, &initialVT) < 0)
-		initialVT = -1;
-#endif
-            if (ShareVTs)
-		xf86Info.vtno = initialVT;
-
-	    if (xf86Info.vtno == -1)
-	    {
-		/*
-		 * For old syscons versions (<0x100), VT_OPENQRY returns
-		 * the current VT rather than the next free VT.  In this
-		 * case, the server gets started on the current VT instead
-		 * of the next free VT.
-		 */
-
-#if 0
-		/* check for the fixed VT_OPENQRY */
-		if (syscons_version >= 0x100)
-		{
-#endif
-		    if (ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0)
-		    {
-			/* No free VTs */
-			xf86Info.vtno = -1;
-		    }
-#if 0
-		}
-#endif
-
-		if (xf86Info.vtno == -1)
-		{
-		    /*
-		     * All VTs are in use.  If initialVT was found, use it.
-		     * Otherwise, if stdin is a VT, use that one.
-		     * XXX stdin is already closed, so this won't work.
-		     */
-		    if (initialVT != -1)
-		    {
-			xf86Info.vtno = initialVT;
-		    }
-		    else if ((fstat(0, &status) >= 0)
-			     && S_ISCHR(status.st_mode)
-			     && (ioctl(0, VT_GETMODE, &vtmode) >= 0))
-		    {
-			/* stdin is a VT */
-			xf86Info.vtno = minor(status.st_rdev) + 1;
-		    }
-		    else
-		    {
-			if (syscons_version >= 0x100)
-			{
-			    FatalError("%s: Cannot find a free VT",
-				       "xf86OpenSyscons");
-			}
-			/* Should no longer reach here */
-			FatalError("%s: %s %s\n\t%s %s",
-				   "xf86OpenSyscons",
-				   "syscons versions prior to 1.0 require",
-				   "either the",
-				   "server's stdin be a VT",
-				   "or the use of the vtxx server option");
-		    }
-		}
-		from = X_PROBED;
-	    }
-
-	    close(fd);
-#ifndef __OpenBSD__
-	    sprintf(vtname, "/dev/ttyv%01x", xf86Info.vtno - 1);
-#else 
-	    sprintf(vtname, "/dev/ttyC%01x", xf86Info.vtno - 1);
-#endif	    
-	    if ((fd = open(vtname, SYSCONS_CONSOLE_MODE, 0)) < 0)
-	    {
-		FatalError("xf86OpenSyscons: Cannot open %s (%s)",
-			   vtname, strerror(errno));
-	    }
-	    if (ioctl(fd, VT_GETMODE, &vtmode) < 0)
-	    {
-		FatalError("xf86OpenSyscons: VT_GETMODE failed");
-	    }
-	    xf86Info.consType = SYSCONS;
-	    xf86Msg(X_PROBED, "Using syscons driver with X support");
-	    if (syscons_version >= 0x100)
-	    {
-		xf86ErrorF(" (version %ld.%ld)\n", syscons_version >> 8,
-			   syscons_version & 0xFF);
-	    }
-	    else
-	    {
-		xf86ErrorF(" (version 0.x)\n");
-	    }
-	    xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno);
-	}
-	else
-	{
-	    /* VT_GETMODE failed, probably not syscons */
-	    close(fd);
-	    fd = -1;
-	}
-    }
-    return fd;
-}
-
-#endif /* SYSCONS_SUPPORT */
-
-
-#ifdef PCVT_SUPPORT
-
-static int
-xf86OpenPcvt()
-{
-    /* This looks much like syscons, since pcvt is API compatible */
-    int fd = -1;
-    vtmode_t vtmode;
-    char vtname[12], *vtprefix;
-    struct stat status;
-    struct pcvtid pcvt_version;
-
-#ifndef __OpenBSD__
-    vtprefix = "/dev/ttyv";
-#else
-    vtprefix = "/dev/ttyC";
-#endif
-
-    fd = open(PCVT_CONSOLE_DEV, PCVT_CONSOLE_MODE, 0);
-#ifdef WSCONS_PCVT_COMPAT_CONSOLE_DEV
-    if (fd < 0)
-    {
-	fd = open(WSCONS_PCVT_COMPAT_CONSOLE_DEV, PCVT_CONSOLE_MODE, 0);
-	vtprefix = "/dev/ttyE";
-    }
-#endif
-    if (fd >= 0) 
-    {
-	if (ioctl(fd, VGAPCVTID, &pcvt_version) >= 0)
-	{
-	    if(ioctl(fd, VT_GETMODE, &vtmode) < 0)
-	    {
-		FatalError("%s: VT_GETMODE failed\n%s%s\n%s",
-			   "xf86OpenPcvt",
-			   "Found pcvt driver but X11 seems to be",
-			   " not supported.", CHECK_DRIVER_MSG);
-	    }
-
-	    xf86Info.vtno = VTnum;
-		
-	    if (ioctl(fd, VT_GETACTIVE, &initialVT) < 0)
-		initialVT = -1;
-
-	    if (xf86Info.vtno == -1)
-	    {
-		if (ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0)
-		{
-		    /* No free VTs */
-		    xf86Info.vtno = -1;
-		}
-
-		if (xf86Info.vtno == -1)
-		{
-		    /*
-		     * All VTs are in use.  If initialVT was found, use it.
-		     * Otherwise, if stdin is a VT, use that one.
-		     * XXX stdin is already closed, so this won't work.
-		     */
-		    if (initialVT != -1)
-		    {
-			xf86Info.vtno = initialVT;
-		    }
-		    else if ((fstat(0, &status) >= 0)
-			     && S_ISCHR(status.st_mode)
-			     && (ioctl(0, VT_GETMODE, &vtmode) >= 0))
-		    {
-			/* stdin is a VT */
-			xf86Info.vtno = minor(status.st_rdev) + 1;
-		    }
-		    else
-		    {
-			FatalError("%s: Cannot find a free VT",
-				   "xf86OpenPcvt");
-		    }
-		}
-	    }
-
-	    close(fd);
-            sprintf(vtname, "%s%01x", vtprefix, xf86Info.vtno - 1);
-	    if ((fd = open(vtname, PCVT_CONSOLE_MODE, 0)) < 0)
-	    {
-		ErrorF("xf86OpenPcvt: Cannot open %s (%s)",
-			   vtname, strerror(errno));
-		xf86Info.vtno = initialVT;
-	        sprintf(vtname, "%s%01x", vtprefix, xf86Info.vtno - 1);
-		if ((fd = open(vtname, PCVT_CONSOLE_MODE, 0)) < 0) {
-			FatalError("xf86OpenPcvt: Cannot open %s (%s)",
-			   	vtname, strerror(errno));
-		}
-	    }
-	    if (ioctl(fd, VT_GETMODE, &vtmode) < 0)
-	    {
-		FatalError("xf86OpenPcvt: VT_GETMODE failed");
-	    }
-	    xf86Info.consType = PCVT;
-#ifdef WSCONS_SUPPORT
-	    xf86Msg(X_PROBED,
-		    "Using wscons driver on %s in pcvt compatibility mode "
-		    "(version %d.%d)\n", vtname,
-		    pcvt_version.rmajor, pcvt_version.rminor);
-#else
-	    xf86Msg(X_PROBED, "Using pcvt driver (version %d.%d)\n",
-		    pcvt_version.rmajor, pcvt_version.rminor);
-#endif
-	}
-	else
-	{
-	    /* Not pcvt */
-	    close(fd);
-	    fd = -1;
-	}
-    }
-    return fd;
-}
-
-#endif /* PCVT_SUPPORT */
-
-#ifdef WSCONS_SUPPORT
-
-static int
-xf86OpenWScons()
-{
-    int fd = -1;
-    int mode = WSDISPLAYIO_MODE_MAPPED;
-    int i;
-    char ttyname[16];
-
-    /* XXX Is this ok? */
-    for (i = 0; i < 8; i++) {
-#if defined(__NetBSD__)
-	sprintf(ttyname, "/dev/ttyE%d", i);
-#elif defined(__OpenBSD__)
-	sprintf(ttyname, "/dev/ttyC%x", i);
-#endif
-	if ((fd = open(ttyname, 2)) != -1)
-	    break;
-    }
-    if (fd != -1) {
-	if (ioctl(fd, WSDISPLAYIO_SMODE, &mode) < 0) {
-	    FatalError("%s: WSDISPLAYIO_MODE_MAPPED failed (%s)\n%s",
-		       "xf86OpenConsole", strerror(errno),
-		       CHECK_DRIVER_MSG);
-	}
-	xf86Info.consType = WSCONS;
-	xf86Msg(X_PROBED, "Using wscons driver\n");
-    }
-    return fd;
-}
-
-#endif /* WSCONS_SUPPORT */
-
-void
-xf86CloseConsole()
-{
-#if defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT)
-    struct vt_mode   VT;
-#endif
-
-    if (ShareVTs) return;
-
-    switch (xf86Info.consType)
-    {
-#ifdef PCCONS_SUPPORT
-    case PCCONS:
-	ioctl (xf86Info.consoleFd, CONSOLE_X_MODE_OFF, 0);
-	break;
-#endif /* PCCONS_SUPPORT */
-#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
-    case SYSCONS:
-    case PCVT:
-        ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT);  /* Back to text mode */
-        if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) != -1)
-        {
-	    VT.mode = VT_AUTO;
-	    ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* dflt vt handling */
-        }
-#if !defined(OpenBSD) && !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)
-        if (ioctl(xf86Info.consoleFd, KDDISABIO, 0) < 0)
-        {
-            xf86FatalError("xf86CloseConsole: KDDISABIO failed (%s)",
-	                   strerror(errno));
-        }
-#endif
-	if (initialVT != -1)
-		ioctl(xf86Info.consoleFd, VT_ACTIVATE, initialVT);
-        break;
-#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
-#ifdef WSCONS_SUPPORT
-    case WSCONS:
-      {
-	int mode = WSDISPLAYIO_MODE_EMUL;
-	ioctl(xf86Info.screenFd, WSDISPLAYIO_SMODE, &mode);
-	break;
-      }
-#endif
-    }
-
-    if (xf86Info.screenFd != xf86Info.consoleFd)
-    {
-	close(xf86Info.screenFd);
-	close(xf86Info.consoleFd);
-	if ((xf86Info.consoleFd = open("/dev/console",O_RDONLY,0)) <0)
-	{
-	    xf86FatalError("xf86CloseConsole: Cannot open /dev/console (%s)",
-			   strerror(errno));
-	}
-    }
-    close(xf86Info.consoleFd);
-    if (devConsoleFd >= 0)
-	close(devConsoleFd);
-    return;
-}
-
-int
-xf86ProcessArgument(int argc, char *argv[], int i)
-{
-	/*
-	 * Keep server from detaching from controlling tty.  This is useful 
-	 * when debugging (so the server can receive keyboard signals.
-	 */
-	if (!strcmp(argv[i], "-keeptty"))
-	{
-		KeepTty = TRUE;
-		return(1);
-	}
-#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
-	if (!strcmp(argv[i], "-sharevts"))
-	{	
-		ShareVTs = TRUE;
-		return(1);
-	}
-	if ((argv[i][0] == 'v') && (argv[i][1] == 't'))
-	{
-		if (sscanf(argv[i], "vt%2d", &VTnum) == 0 ||
-		    VTnum < 1 || VTnum > 12)
-		{
-			UseMsg();
-			VTnum = -1;
-			return(0);
-		}
-		return(1);
-	}
-#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
-	return(0);
-}
-
-void
-xf86UseMsg()
-{
-#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
-	ErrorF("vtXX                   use the specified VT number (1-12)\n");
-	ErrorF("-sharevts              share VTs with another X server\n");
-#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
-	ErrorF("-keeptty               ");
-	ErrorF("don't detach controlling tty (for debugging only)\n");
-	return;
-}
+/*

+ * Copyright 1992 by Rich Murphey <Rich@Rice.edu>

+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>

+ *

+ * 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 names of Rich Murphey and David Wexelblat 

+ * not be used in advertising or publicity pertaining to distribution of 

+ * the software without specific, written prior permission.  Rich Murphey and

+ * David Wexelblat make no representations about the suitability of this 

+ * software for any purpose.  It is provided "as is" without express or 

+ * implied warranty.

+ *

+ * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 

+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

+ * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT 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_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+

+#include "compiler.h"

+

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86_OSlib.h"

+

+#include <sys/utsname.h>

+#include <sys/ioctl.h>

+#include <stdlib.h>

+#include <errno.h>

+

+static Bool KeepTty = FALSE;

+static int devConsoleFd = -1;

+#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)

+static int VTnum = -1;

+static int initialVT = -1;

+static Bool ShareVTs = FALSE;

+#endif

+

+#ifdef PCCONS_SUPPORT

+/* Stock 0.1 386bsd pccons console driver interface */

+#ifndef __OpenBSD__

+#  define PCCONS_CONSOLE_DEV1 "/dev/ttyv0"

+#else

+#  define PCCONS_CONSOLE_DEV1 "/dev/ttyC0"

+#endif

+#define PCCONS_CONSOLE_DEV2 "/dev/vga"

+#define PCCONS_CONSOLE_MODE O_RDWR|O_NDELAY

+#endif

+

+#ifdef SYSCONS_SUPPORT

+/* The FreeBSD 1.1 version syscons driver uses /dev/ttyv0 */

+#define SYSCONS_CONSOLE_DEV1 "/dev/ttyv0"

+#define SYSCONS_CONSOLE_DEV2 "/dev/vga"

+#define SYSCONS_CONSOLE_MODE O_RDWR|O_NDELAY

+#endif

+

+#ifdef PCVT_SUPPORT

+/* Hellmuth Michaelis' pcvt driver */

+#ifndef __OpenBSD__

+#  define PCVT_CONSOLE_DEV "/dev/ttyv0"

+#else

+#  define PCVT_CONSOLE_DEV "/dev/ttyC0"

+#endif

+#define PCVT_CONSOLE_MODE O_RDWR|O_NDELAY

+#endif

+

+#if defined(WSCONS_SUPPORT) && defined(__NetBSD__)

+/* NetBSD's new console driver */

+#define WSCONS_PCVT_COMPAT_CONSOLE_DEV "/dev/ttyE0"

+#endif

+

+#ifdef __GLIBC__

+#define setpgrp setpgid

+#endif

+

+#define CHECK_DRIVER_MSG \

+  "Check your kernel's console driver configuration and /dev entries"

+

+static char *supported_drivers[] = {

+#ifdef PCCONS_SUPPORT

+	"pccons (with X support)",

+#endif

+#ifdef SYSCONS_SUPPORT

+	"syscons",

+#endif

+#ifdef PCVT_SUPPORT

+	"pcvt",

+#endif

+#ifdef WSCONS_SUPPORT

+	"wscons",

+#endif

+};

+

+

+/*

+ * Functions to probe for the existance of a supported console driver.

+ * Any function returns either a valid file descriptor (driver probed

+ * succesfully), -1 (driver not found), or uses FatalError() if the

+ * driver was found but proved to not support the required mode to run

+ * an X server.

+ */

+

+typedef int (*xf86ConsOpen_t)(void);

+

+#ifdef PCCONS_SUPPORT

+static int xf86OpenPccons(void);

+#endif /* PCCONS_SUPPORT */

+

+#ifdef SYSCONS_SUPPORT

+static int xf86OpenSyscons(void);

+#endif /* SYSCONS_SUPPORT */

+

+#ifdef PCVT_SUPPORT

+static int xf86OpenPcvt(void);

+#endif /* PCVT_SUPPORT */

+

+#ifdef WSCONS_SUPPORT

+static int xf86OpenWScons(void);

+#endif

+

+/*

+ * The sequence of the driver probes is important; start with the

+ * driver that is best distinguishable, and end with the most generic

+ * driver.  (Otherwise, pcvt would also probe as syscons, and either

+ * pcvt or syscons might succesfully probe as pccons.)

+ */

+static xf86ConsOpen_t xf86ConsTab[] = {

+#ifdef PCVT_SUPPORT

+    xf86OpenPcvt,

+#endif

+#ifdef SYSCONS_SUPPORT

+    xf86OpenSyscons,

+#endif

+#ifdef PCCONS_SUPPORT

+    xf86OpenPccons,

+#endif

+#ifdef WSCONS_SUPPORT

+    xf86OpenWScons,

+#endif

+    (xf86ConsOpen_t)NULL

+};

+

+

+void

+xf86OpenConsole()

+{

+    int i, fd = -1;

+    xf86ConsOpen_t *driver;

+#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)

+    int result;

+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

+    struct utsname uts;

+#endif

+    vtmode_t vtmode;

+#endif

+    

+    if (serverGeneration == 1)

+    {

+	/* check if we are run with euid==0 */

+	if (geteuid() != 0)

+	{

+	    FatalError("xf86OpenConsole: Server must be suid root");

+	}

+

+	if (!KeepTty)

+	{

+	    /*

+	     * detaching the controlling tty solves problems of kbd character

+	     * loss.  This is not interesting for CO driver, because it is 

+	     * exclusive.

+	     */

+	    setpgrp(0, getpid());

+	    if ((i = open("/dev/tty",O_RDWR)) >= 0)

+	    {

+		ioctl(i,TIOCNOTTY,(char *)0);

+		close(i);

+	    }

+	}

+

+	/* detect which driver we are running on */

+	for (driver = xf86ConsTab; *driver; driver++)

+	{

+	    if ((fd = (*driver)()) >= 0)

+		break;

+	}

+

+	/* Check that a supported console driver was found */

+	if (fd < 0)

+	{

+	    char cons_drivers[80] = {0, };

+	    for (i = 0; i < sizeof(supported_drivers) / sizeof(char *); i++)

+	    {

+		if (i)

+		{

+		    strcat(cons_drivers, ", ");

+		}

+		strcat(cons_drivers, supported_drivers[i]);

+	    }

+	    FatalError(

+		"%s: No console driver found\n\tSupported drivers: %s\n\t%s",

+		"xf86OpenConsole", cons_drivers, CHECK_DRIVER_MSG);

+	}

+#if 0 /* stdin is already closed in OsInit() */

+	fclose(stdin);

+#endif

+	xf86Info.consoleFd = fd;

+	xf86Info.screenFd = fd;

+

+	switch (xf86Info.consType)

+	{

+#ifdef PCCONS_SUPPORT

+	case PCCONS:

+	    if (ioctl (xf86Info.consoleFd, CONSOLE_X_MODE_ON, 0) < 0)

+	    {

+		FatalError("%s: CONSOLE_X_MODE_ON failed (%s)\n%s",

+			   "xf86OpenConsole", strerror(errno),

+			   CHECK_DRIVER_MSG);

+	    }

+	    /*

+	     * Hack to prevent keyboard hanging when syslogd closes

+	     * /dev/console

+	     */

+	    if ((devConsoleFd = open("/dev/console", O_WRONLY,0)) < 0)

+	    {

+		xf86Msg(X_WARNING,

+			"xf86OpenConsole: couldn't open /dev/console (%s)\n",

+			strerror(errno));

+	    }

+	    break;

+#endif

+#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)

+	case SYSCONS:

+	    /* as of FreeBSD 2.2.8, syscons driver does not need the #1 vt

+	     * switching anymore. Here we check for FreeBSD 3.1 and up.

+	     * Add cases for other *BSD that behave the same.

+	    */

+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

+	    uname (&uts);

+	    i = atof(uts.release) * 100;

+	    if (i >= 310) goto acquire_vt;

+#endif

+	    /* otherwise fall through */

+	case PCVT:

+#if !(defined(__NetBSD__) && (__NetBSD_Version__ >= 200000000))

+	    /*

+	     * First activate the #1 VT.  This is a hack to allow a server

+	     * to be started while another one is active.  There should be

+	     * a better way.

+	     */

+	    if (initialVT != 1) {

+

+		if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, 1) != 0)

+		{

+		    xf86Msg(X_WARNING,

+				"xf86OpenConsole: VT_ACTIVATE failed\n");

+		}

+		sleep(1);

+	    }

+#endif

+acquire_vt:

+	    if (!ShareVTs) {

+		    /*

+		     * now get the VT

+		     */

+		    SYSCALL(result =

+			    ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno));

+		    if (result != 0)

+		    {

+			xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");

+		    }

+		    SYSCALL(result =

+		    ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno));

+		    if (result != 0)

+		    {

+			xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed\n");

+		    }

+

+		    signal(SIGUSR1, xf86VTRequest);

+

+		    vtmode.mode = VT_PROCESS;

+		    vtmode.relsig = SIGUSR1;

+		    vtmode.acqsig = SIGUSR1;

+		    vtmode.frsig = SIGUSR1;

+		    if (ioctl(xf86Info.consoleFd, VT_SETMODE, &vtmode) < 0) 

+		    {

+			FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed");

+		    }

+	#if !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)

+		    if (ioctl(xf86Info.consoleFd, KDENABIO, 0) < 0)

+		    {

+			FatalError("xf86OpenConsole: KDENABIO failed (%s)",

+				   strerror(errno));

+		    }

+	#endif

+		    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0)

+		    {

+			FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed");

+		    }

+	    } else { /* ShareVTs */

+		    close(xf86Info.consoleFd);

+	    }	

+  	    break; 

+#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */

+#ifdef WSCONS_SUPPORT

+	case WSCONS:

+	    /* Nothing to do */

+   	    break; 

+#endif

+        }

+    }

+    else 

+    {

+	/* serverGeneration != 1 */

+#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)

+    	if (!ShareVTs) if (xf86Info.consType == SYSCONS || xf86Info.consType == PCVT)

+    	{

+	    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0)

+	    {

+	        xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");

+	    }

+        }

+#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */

+    }

+    return;

+}

+

+

+#ifdef PCCONS_SUPPORT

+

+static int

+xf86OpenPccons()

+{

+    int fd = -1;

+

+    if ((fd = open(PCCONS_CONSOLE_DEV1, PCCONS_CONSOLE_MODE, 0))

+	>= 0 ||

+	(fd = open(PCCONS_CONSOLE_DEV2, PCCONS_CONSOLE_MODE, 0))

+	>= 0)

+    {

+	if (ioctl(fd, CONSOLE_X_MODE_OFF, 0) < 0)

+	{

+	    FatalError(

+		"%s: CONSOLE_X_MODE_OFF failed (%s)\n%s\n%s",

+		"xf86OpenPccons",

+		strerror(errno),

+		"Was expecting pccons driver with X support",

+		CHECK_DRIVER_MSG);

+	}

+	xf86Info.consType = PCCONS;

+	xf86Msg(X_PROBED, "Using pccons driver with X support\n");

+    }

+    return fd;

+}

+

+#endif /* PCCONS_SUPPORT */

+

+#ifdef SYSCONS_SUPPORT

+

+static int

+xf86OpenSyscons()

+{

+    int fd = -1;

+    vtmode_t vtmode;

+    char vtname[12];

+    struct stat status;

+    long syscons_version;

+    MessageType from;

+

+    /* Check for syscons */

+    if ((fd = open(SYSCONS_CONSOLE_DEV1, SYSCONS_CONSOLE_MODE, 0)) >= 0

+	|| (fd = open(SYSCONS_CONSOLE_DEV2, SYSCONS_CONSOLE_MODE, 0)) >= 0)

+    {

+	if (ioctl(fd, VT_GETMODE, &vtmode) >= 0)

+	{

+	    /* Get syscons version */

+	    if (ioctl(fd, CONS_GETVERS, &syscons_version) < 0)

+	    {

+		syscons_version = 0;

+	    }

+

+	    xf86Info.vtno = VTnum;

+	    from = X_CMDLINE;

+

+#ifdef VT_GETACTIVE

+	    if (ioctl(fd, VT_GETACTIVE, &initialVT) < 0)

+		initialVT = -1;

+#endif

+            if (ShareVTs)

+		xf86Info.vtno = initialVT;

+

+	    if (xf86Info.vtno == -1)

+	    {

+		/*

+		 * For old syscons versions (<0x100), VT_OPENQRY returns

+		 * the current VT rather than the next free VT.  In this

+		 * case, the server gets started on the current VT instead

+		 * of the next free VT.

+		 */

+

+#if 0

+		/* check for the fixed VT_OPENQRY */

+		if (syscons_version >= 0x100)

+		{

+#endif

+		    if (ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0)

+		    {

+			/* No free VTs */

+			xf86Info.vtno = -1;

+		    }

+#if 0

+		}

+#endif

+

+		if (xf86Info.vtno == -1)

+		{

+		    /*

+		     * All VTs are in use.  If initialVT was found, use it.

+		     * Otherwise, if stdin is a VT, use that one.

+		     * XXX stdin is already closed, so this won't work.

+		     */

+		    if (initialVT != -1)

+		    {

+			xf86Info.vtno = initialVT;

+		    }

+		    else if ((fstat(0, &status) >= 0)

+			     && S_ISCHR(status.st_mode)

+			     && (ioctl(0, VT_GETMODE, &vtmode) >= 0))

+		    {

+			/* stdin is a VT */

+			xf86Info.vtno = minor(status.st_rdev) + 1;

+		    }

+		    else

+		    {

+			if (syscons_version >= 0x100)

+			{

+			    FatalError("%s: Cannot find a free VT",

+				       "xf86OpenSyscons");

+			}

+			/* Should no longer reach here */

+			FatalError("%s: %s %s\n\t%s %s",

+				   "xf86OpenSyscons",

+				   "syscons versions prior to 1.0 require",

+				   "either the",

+				   "server's stdin be a VT",

+				   "or the use of the vtxx server option");

+		    }

+		}

+		from = X_PROBED;

+	    }

+

+	    close(fd);

+#ifndef __OpenBSD__

+	    sprintf(vtname, "/dev/ttyv%01x", xf86Info.vtno - 1);

+#else 

+	    sprintf(vtname, "/dev/ttyC%01x", xf86Info.vtno - 1);

+#endif	    

+	    if ((fd = open(vtname, SYSCONS_CONSOLE_MODE, 0)) < 0)

+	    {

+		FatalError("xf86OpenSyscons: Cannot open %s (%s)",

+			   vtname, strerror(errno));

+	    }

+	    if (ioctl(fd, VT_GETMODE, &vtmode) < 0)

+	    {

+		FatalError("xf86OpenSyscons: VT_GETMODE failed");

+	    }

+	    xf86Info.consType = SYSCONS;

+	    xf86Msg(X_PROBED, "Using syscons driver with X support");

+	    if (syscons_version >= 0x100)

+	    {

+		xf86ErrorF(" (version %ld.%ld)\n", syscons_version >> 8,

+			   syscons_version & 0xFF);

+	    }

+	    else

+	    {

+		xf86ErrorF(" (version 0.x)\n");

+	    }

+	    xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno);

+	}

+	else

+	{

+	    /* VT_GETMODE failed, probably not syscons */

+	    close(fd);

+	    fd = -1;

+	}

+    }

+    return fd;

+}

+

+#endif /* SYSCONS_SUPPORT */

+

+

+#ifdef PCVT_SUPPORT

+

+static int

+xf86OpenPcvt()

+{

+    /* This looks much like syscons, since pcvt is API compatible */

+    int fd = -1;

+    vtmode_t vtmode;

+    char vtname[12], *vtprefix;

+    struct stat status;

+    struct pcvtid pcvt_version;

+

+#ifndef __OpenBSD__

+    vtprefix = "/dev/ttyv";

+#else

+    vtprefix = "/dev/ttyC";

+#endif

+

+    fd = open(PCVT_CONSOLE_DEV, PCVT_CONSOLE_MODE, 0);

+#ifdef WSCONS_PCVT_COMPAT_CONSOLE_DEV

+    if (fd < 0)

+    {

+	fd = open(WSCONS_PCVT_COMPAT_CONSOLE_DEV, PCVT_CONSOLE_MODE, 0);

+	vtprefix = "/dev/ttyE";

+    }

+#endif

+    if (fd >= 0) 

+    {

+	if (ioctl(fd, VGAPCVTID, &pcvt_version) >= 0)

+	{

+	    if(ioctl(fd, VT_GETMODE, &vtmode) < 0)

+	    {

+		FatalError("%s: VT_GETMODE failed\n%s%s\n%s",

+			   "xf86OpenPcvt",

+			   "Found pcvt driver but X11 seems to be",

+			   " not supported.", CHECK_DRIVER_MSG);

+	    }

+

+	    xf86Info.vtno = VTnum;

+		

+	    if (ioctl(fd, VT_GETACTIVE, &initialVT) < 0)

+		initialVT = -1;

+

+	    if (xf86Info.vtno == -1)

+	    {

+		if (ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0)

+		{

+		    /* No free VTs */

+		    xf86Info.vtno = -1;

+		}

+

+		if (xf86Info.vtno == -1)

+		{

+		    /*

+		     * All VTs are in use.  If initialVT was found, use it.

+		     * Otherwise, if stdin is a VT, use that one.

+		     * XXX stdin is already closed, so this won't work.

+		     */

+		    if (initialVT != -1)

+		    {

+			xf86Info.vtno = initialVT;

+		    }

+		    else if ((fstat(0, &status) >= 0)

+			     && S_ISCHR(status.st_mode)

+			     && (ioctl(0, VT_GETMODE, &vtmode) >= 0))

+		    {

+			/* stdin is a VT */

+			xf86Info.vtno = minor(status.st_rdev) + 1;

+		    }

+		    else

+		    {

+			FatalError("%s: Cannot find a free VT",

+				   "xf86OpenPcvt");

+		    }

+		}

+	    }

+

+	    close(fd);

+            sprintf(vtname, "%s%01x", vtprefix, xf86Info.vtno - 1);

+	    if ((fd = open(vtname, PCVT_CONSOLE_MODE, 0)) < 0)

+	    {

+		ErrorF("xf86OpenPcvt: Cannot open %s (%s)",

+			   vtname, strerror(errno));

+		xf86Info.vtno = initialVT;

+	        sprintf(vtname, "%s%01x", vtprefix, xf86Info.vtno - 1);

+		if ((fd = open(vtname, PCVT_CONSOLE_MODE, 0)) < 0) {

+			FatalError("xf86OpenPcvt: Cannot open %s (%s)",

+			   	vtname, strerror(errno));

+		}

+	    }

+	    if (ioctl(fd, VT_GETMODE, &vtmode) < 0)

+	    {

+		FatalError("xf86OpenPcvt: VT_GETMODE failed");

+	    }

+	    xf86Info.consType = PCVT;

+#ifdef WSCONS_SUPPORT

+	    xf86Msg(X_PROBED,

+		    "Using wscons driver on %s in pcvt compatibility mode "

+		    "(version %d.%d)\n", vtname,

+		    pcvt_version.rmajor, pcvt_version.rminor);

+#else

+	    xf86Msg(X_PROBED, "Using pcvt driver (version %d.%d)\n",

+		    pcvt_version.rmajor, pcvt_version.rminor);

+#endif

+	}

+	else

+	{

+	    /* Not pcvt */

+	    close(fd);

+	    fd = -1;

+	}

+    }

+    return fd;

+}

+

+#endif /* PCVT_SUPPORT */

+

+#ifdef WSCONS_SUPPORT

+

+static int

+xf86OpenWScons()

+{

+    int fd = -1;

+    int mode = WSDISPLAYIO_MODE_MAPPED;

+    int i;

+    char ttyname[16];

+

+    /* XXX Is this ok? */

+    for (i = 0; i < 8; i++) {

+#if defined(__NetBSD__)

+	sprintf(ttyname, "/dev/ttyE%d", i);

+#elif defined(__OpenBSD__)

+	sprintf(ttyname, "/dev/ttyC%x", i);

+#endif

+	if ((fd = open(ttyname, 2)) != -1)

+	    break;

+    }

+    if (fd != -1) {

+	if (ioctl(fd, WSDISPLAYIO_SMODE, &mode) < 0) {

+	    FatalError("%s: WSDISPLAYIO_MODE_MAPPED failed (%s)\n%s",

+		       "xf86OpenConsole", strerror(errno),

+		       CHECK_DRIVER_MSG);

+	}

+	xf86Info.consType = WSCONS;

+	xf86Msg(X_PROBED, "Using wscons driver\n");

+    }

+    return fd;

+}

+

+#endif /* WSCONS_SUPPORT */

+

+void

+xf86CloseConsole()

+{

+#if defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT)

+    struct vt_mode   VT;

+#endif

+

+    if (ShareVTs) return;

+

+    switch (xf86Info.consType)

+    {

+#ifdef PCCONS_SUPPORT

+    case PCCONS:

+	ioctl (xf86Info.consoleFd, CONSOLE_X_MODE_OFF, 0);

+	break;

+#endif /* PCCONS_SUPPORT */

+#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)

+    case SYSCONS:

+    case PCVT:

+        ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT);  /* Back to text mode */

+        if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) != -1)

+        {

+	    VT.mode = VT_AUTO;

+	    ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* dflt vt handling */

+        }

+#if !defined(OpenBSD) && !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)

+        if (ioctl(xf86Info.consoleFd, KDDISABIO, 0) < 0)

+        {

+            xf86FatalError("xf86CloseConsole: KDDISABIO failed (%s)",

+	                   strerror(errno));

+        }

+#endif

+	if (initialVT != -1)

+		ioctl(xf86Info.consoleFd, VT_ACTIVATE, initialVT);

+        break;

+#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */

+#ifdef WSCONS_SUPPORT

+    case WSCONS:

+      {

+	int mode = WSDISPLAYIO_MODE_EMUL;

+	ioctl(xf86Info.screenFd, WSDISPLAYIO_SMODE, &mode);

+	break;

+      }

+#endif

+    }

+

+    if (xf86Info.screenFd != xf86Info.consoleFd)

+    {

+	close(xf86Info.screenFd);

+	close(xf86Info.consoleFd);

+	if ((xf86Info.consoleFd = open("/dev/console",O_RDONLY,0)) <0)

+	{

+	    xf86FatalError("xf86CloseConsole: Cannot open /dev/console (%s)",

+			   strerror(errno));

+	}

+    }

+    close(xf86Info.consoleFd);

+    if (devConsoleFd >= 0)

+	close(devConsoleFd);

+    return;

+}

+

+int

+xf86ProcessArgument(int argc, char *argv[], int i)

+{

+	/*

+	 * Keep server from detaching from controlling tty.  This is useful 

+	 * when debugging (so the server can receive keyboard signals.

+	 */

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

+	{

+		KeepTty = TRUE;

+		return 1;

+	}

+#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)

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

+	{	

+		ShareVTs = TRUE;

+		return 1;

+	}

+	if ((argv[i][0] == 'v') && (argv[i][1] == 't'))

+	{

+		if (sscanf(argv[i], "vt%2d", &VTnum) == 0 ||

+		    VTnum < 1 || VTnum > 12)

+		{

+			UseMsg();

+			VTnum = -1;

+			return 0;

+		}

+		return 1;

+	}

+#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */

+	return 0;

+}

+

+void

+xf86UseMsg()

+{

+#if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)

+	ErrorF("vtXX                   use the specified VT number (1-12)\n");

+	ErrorF("-sharevts              share VTs with another X server\n");

+#endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */

+	ErrorF("-keeptty               ");

+	ErrorF("don't detach controlling tty (for debugging only)\n");

+	return;

+}

diff --git a/xorg-server/hw/xfree86/os-support/bsd/i386_video.c b/xorg-server/hw/xfree86/os-support/bsd/i386_video.c
index 0d457193a..9b26fb1dd 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/i386_video.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/i386_video.c
@@ -246,7 +246,7 @@ mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
 			   "xf86MapVidMem", DEV_MEM, Size, Base, 

 			   strerror(errno));

 	    }

-	    return(base);

+	    return base;

 	}

 		

 	/* else, mmap /dev/vga */

@@ -266,7 +266,7 @@ mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
 	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)",

 		       strerror(errno));

 	}

-	return(base);

+	return base;

 }

 

 static void

@@ -289,7 +289,7 @@ xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
 

 	checkDevMem(TRUE);

 	if (devMemFd == -1) {

-	    return(-1);

+	    return -1;

 	}

 

 	psize = getpagesize();

@@ -308,7 +308,7 @@ xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
 		    xf86Msg(X_WARNING, SYSCTL_MSG2);

 		} 

 #endif

-		return(-1);

+		return -1;

 	}

 #ifdef DEBUG

 	ErrorF("xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",

@@ -321,7 +321,7 @@ xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
 		"-> %02x %02x %02x %02x...\n",

 		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);

 #endif

-	return(Len);

+	return Len;

 }

 

 #ifdef USE_I386_IOPL

diff --git a/xorg-server/hw/xfree86/os-support/bsd/sparc64_video.c b/xorg-server/hw/xfree86/os-support/bsd/sparc64_video.c
index ea520c49e..1dcd77711 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/sparc64_video.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/sparc64_video.c
@@ -1,91 +1,91 @@
-/*
- * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
- * Copyright 1993 by David Wexelblat <dwex@goblin.org>
- *
- * 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 names of Rich Murphey and David Wexelblat 
- * not be used in advertising or publicity pertaining to distribution of 
- * the software without specific, written prior permission.  Rich Murphey and
- * David Wexelblat make no representations about the suitability of this 
- * software for any purpose.  It is provided "as is" without express or 
- * implied warranty.
- *
- * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 
- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
- * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT 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_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include "xf86.h"
-#include "xf86Priv.h"
-
-#include "xf86_OSlib.h"
-#include "xf86OSpriv.h"
-
-#ifndef MAP_FAILED
-#define MAP_FAILED ((caddr_t)-1)
-#endif
-
-/***************************************************************************/
-/* Video Memory Mapping section                                            */
-/***************************************************************************/
-
-static pointer sparc64MapVidMem(int, unsigned long, unsigned long, int);
-static void sparc64UnmapVidMem(int, pointer, unsigned long);
-
-void
-xf86OSInitVidMem(VidMemInfoPtr pVidMem)
-{
-	pVidMem->linearSupported = TRUE;
-	pVidMem->mapMem = sparc64MapVidMem;
-	pVidMem->unmapMem = sparc64UnmapVidMem;
-	pVidMem->initialised = TRUE;
-}
-
-static pointer
-sparc64MapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, 
-		 int flags)
-{
-	int fd = xf86Info.screenFd;
-	pointer base;
-
-#ifdef DEBUG
-	xf86MsgVerb(X_INFO, 3, "mapVidMem %lx, %lx, fd = %d", 
-		    Base, Size, fd);
-#endif
-
-	base = mmap(0, Size,
-		    (flags & VIDMEM_READONLY) ?
-		     PROT_READ : (PROT_READ | PROT_WRITE),
-		    MAP_SHARED, fd, Base);
-	if (base == MAP_FAILED)
-		FatalError("%s: could not mmap screen [s=%x,a=%x] (%s)",
-			   "xf86MapVidMem", Size, Base, strerror(errno));
-	return base;
-}
-
-static void
-sparc64UnmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
-{
-	munmap(Base, Size);
-}
-
-int
-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
-	     int Len)
-{
-
-	return (0);
-}
+/*

+ * Copyright 1992 by Rich Murphey <Rich@Rice.edu>

+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>

+ *

+ * 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 names of Rich Murphey and David Wexelblat 

+ * not be used in advertising or publicity pertaining to distribution of 

+ * the software without specific, written prior permission.  Rich Murphey and

+ * David Wexelblat make no representations about the suitability of this 

+ * software for any purpose.  It is provided "as is" without express or 

+ * implied warranty.

+ *

+ * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 

+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

+ * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT 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_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+#include "xf86.h"

+#include "xf86Priv.h"

+

+#include "xf86_OSlib.h"

+#include "xf86OSpriv.h"

+

+#ifndef MAP_FAILED

+#define MAP_FAILED ((caddr_t)-1)

+#endif

+

+/***************************************************************************/

+/* Video Memory Mapping section                                            */

+/***************************************************************************/

+

+static pointer sparc64MapVidMem(int, unsigned long, unsigned long, int);

+static void sparc64UnmapVidMem(int, pointer, unsigned long);

+

+void

+xf86OSInitVidMem(VidMemInfoPtr pVidMem)

+{

+	pVidMem->linearSupported = TRUE;

+	pVidMem->mapMem = sparc64MapVidMem;

+	pVidMem->unmapMem = sparc64UnmapVidMem;

+	pVidMem->initialised = TRUE;

+}

+

+static pointer

+sparc64MapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, 

+		 int flags)

+{

+	int fd = xf86Info.screenFd;

+	pointer base;

+

+#ifdef DEBUG

+	xf86MsgVerb(X_INFO, 3, "mapVidMem %lx, %lx, fd = %d", 

+		    Base, Size, fd);

+#endif

+

+	base = mmap(0, Size,

+		    (flags & VIDMEM_READONLY) ?

+		     PROT_READ : (PROT_READ | PROT_WRITE),

+		    MAP_SHARED, fd, Base);

+	if (base == MAP_FAILED)

+		FatalError("%s: could not mmap screen [s=%x,a=%x] (%s)",

+			   "xf86MapVidMem", Size, Base, strerror(errno));

+	return base;

+}

+

+static void

+sparc64UnmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

+{

+	munmap(Base, Size);

+}

+

+int

+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

+	     int Len)

+{

+

+	return 0;

+}

diff --git a/xorg-server/hw/xfree86/os-support/linux/lnx_agp.c b/xorg-server/hw/xfree86/os-support/linux/lnx_agp.c
index 3fa897366..705bb5ea0 100644
--- a/xorg-server/hw/xfree86/os-support/linux/lnx_agp.c
+++ b/xorg-server/hw/xfree86/os-support/linux/lnx_agp.c
@@ -64,7 +64,7 @@ GARTInit(int screenNum)
 	struct _agp_info agpinf;

 

 	if (initDone)

-		return (gartFd != -1);

+		return gartFd != -1;

 

 	initDone = TRUE;

 

diff --git a/xorg-server/hw/xfree86/os-support/linux/lnx_init.c b/xorg-server/hw/xfree86/os-support/linux/lnx_init.c
index 297e7a65a..722fbb0c1 100644
--- a/xorg-server/hw/xfree86/os-support/linux/lnx_init.c
+++ b/xorg-server/hw/xfree86/os-support/linux/lnx_init.c
@@ -1,401 +1,401 @@
-/*
- * Copyright 1992 by Orest Zborowski <obz@Kodak.com>
- * Copyright 1993 by David Wexelblat <dwex@goblin.org>
- *
- * 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 names of Orest Zborowski and David Wexelblat
- * not be used in advertising or publicity pertaining to distribution of
- * the software without specific, written prior permission.  Orest Zborowski
- * and David Wexelblat make no representations about the suitability of this
- * software for any purpose.  It is provided "as is" without express or
- * implied warranty.
- *
- * OREST ZBOROWSKI AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD
- * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL OREST ZBOROWSKI OR DAVID WEXELBLAT 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_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xmd.h>
-
-#include "compiler.h"
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-
-#include <sys/stat.h>
-
-static Bool KeepTty = FALSE;
-static int VTnum = -1;
-static Bool VTSwitch = TRUE;
-static Bool ShareVTs = FALSE;
-static int activeVT = -1;
-
-static int vtPermSave[4];
-static char vtname[11];
-static struct termios tty_attr; /* tty state to restore */
-static int tty_mode; /* kbd mode to restore */
-
-static int
-saveVtPerms(void)
-{
-    /* We need to use stat to get permissions. */
-    struct stat svtp;
-
-    /* Do them numerically ordered, hard coded tty0 first. */
-    if (stat("/dev/tty0", &svtp) != 0)
-	return 0;
-    vtPermSave[0] = (int)svtp.st_uid;
-    vtPermSave[1] = (int)svtp.st_gid;
-
-    /* Now check the console we are dealing with. */
-    if (stat(vtname, &svtp) != 0)
-	return 0;
-    vtPermSave[2] = (int)svtp.st_uid;
-    vtPermSave[3] = (int)svtp.st_gid;
-
-    return 1;
-}
-
-static void
-restoreVtPerms(void)
-{
-    if (geteuid() == 0) {
-	 /* Set the terminal permissions back to before we started. */
-	 (void)chown("/dev/tty0", vtPermSave[0], vtPermSave[1]);
-	 (void)chown(vtname, vtPermSave[2], vtPermSave[3]);
-    }
-}
-
-static void *console_handler;
-
-static void
-drain_console(int fd, void *closure)
-{
-    tcflush(fd, TCIOFLUSH);
-}
-
-void
-xf86OpenConsole(void)
-{
-    int i, fd = -1;
-    struct vt_mode VT;
-    struct vt_stat vts;
-    MessageType from = X_PROBED;
-    char *tty0[] = { "/dev/tty0", "/dev/vc/0", NULL };
-    char *vcs[] = { "/dev/vc/%d", "/dev/tty%d", NULL };
-
-    if (serverGeneration == 1) {
-
-	/* when KeepTty check if we're run with euid==0 */
-	if (KeepTty && geteuid() != 0) 
-	    FatalError("xf86OpenConsole:"
-		       " Server must be suid root for option \"KeepTTY\"\n");
-
-	/*
-	 * setup the virtual terminal manager
-	 */
-	if (VTnum != -1) {
-	    xf86Info.vtno = VTnum;
-	    from = X_CMDLINE;
-	} else {
-
-	    i=0;
-	    while (tty0[i] != NULL) {
-		if ((fd = open(tty0[i],O_WRONLY,0)) >= 0)
-		  break;
-		i++;
-	    }
-	    
-	    if (fd < 0)
-		FatalError(
-		    "xf86OpenConsole: Cannot open /dev/tty0 (%s)\n",
-		    strerror(errno));
-
-            if (ShareVTs)
-            {
-                if (ioctl(fd, VT_GETSTATE, &vts) == 0)
-                    xf86Info.vtno = vts.v_active;
-                else
-                    FatalError("xf86OpenConsole: Cannot find the current"
-                               " VT (%s)\n", strerror(errno));
-            } else {
-	        if ((ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0) ||
-		    (xf86Info.vtno == -1))
-		    FatalError("xf86OpenConsole: Cannot find a free VT: %s\n",
-                               strerror(errno));
-            }
-	    close(fd);
-	}
-
-	xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno);
-
-	if (!KeepTty) {
-	    pid_t ppid = getppid();
-	    pid_t ppgid;
-	    ppgid = getpgid(ppid);
-
-	    /*
-	     * change to parent process group that pgid != pid so
-	     * that setsid() doesn't fail and we become process
-	     * group leader
-	     */
-	    if (setpgid(0,ppgid) < 0)
-		xf86Msg(X_WARNING, "xf86OpenConsole: setpgid failed: %s\n",
-			strerror(errno));
-
-	    /* become process group leader */
-	    if ((setsid() < 0))
-		xf86Msg(X_WARNING, "xf86OpenConsole: setsid failed: %s\n",
-			strerror(errno));
-	}
-
-        i=0;
-        while (vcs[i] != NULL) {
-            sprintf(vtname, vcs[i], xf86Info.vtno); /* /dev/tty1-64 */
-     	    if ((xf86Info.consoleFd = open(vtname, O_RDWR|O_NDELAY, 0)) >= 0)
-		break;
-            i++;
-        }
-
-	if (xf86Info.consoleFd < 0)
-	    FatalError("xf86OpenConsole: Cannot open virtual console"
-		       " %d (%s)\n", xf86Info.vtno, strerror(errno));
-
-        if (!ShareVTs)
-        {
-	    /*
-	     * Grab the vt ownership before we overwrite it.
-	     * Hard coded /dev/tty0 into this function as well for below.
-	     */
-	    if (!saveVtPerms())
-	        xf86Msg(X_WARNING,
-		        "xf86OpenConsole: Could not save ownership of VT\n");
-
-	    if (geteuid() == 0) {
-		    /* change ownership of the vt */
-		    if (chown(vtname, getuid(), getgid()) < 0)
-			    xf86Msg(X_WARNING,"xf86OpenConsole: chown %s failed: %s\n",
-				    vtname, strerror(errno));
-
-		    /*
-		     * the current VT device we're running on is not
-		     * "console", we want to grab all consoles too
-		     *
-		     * Why is this needed??
-		     */
-		    if (chown("/dev/tty0", getuid(), getgid()) < 0)
-			    xf86Msg(X_WARNING,"xf86OpenConsole: chown /dev/tty0 failed: %s\n",
-				    strerror(errno));
-	    }
-        }
-
-	/*
-	 * Linux doesn't switch to an active vt after the last close of a vt,
-	 * so we do this ourselves by remembering which is active now.
-	 */
-	if (ioctl(xf86Info.consoleFd, VT_GETSTATE, &vts) < 0)
-	    xf86Msg(X_WARNING,"xf86OpenConsole: VT_GETSTATE failed: %s\n",
-		    strerror(errno));
-	else
-	    activeVT = vts.v_active;
-
-#if 0
-	if (!KeepTty) {
-	    /*
-	     * Detach from the controlling tty to avoid char loss
-	     */
-	    if ((i = open("/dev/tty",O_RDWR)) >= 0) {
-		ioctl(i, TIOCNOTTY, 0);
-		close(i);
-	    }
-	}
-#endif
-
-        if (!ShareVTs)
-        {
-            struct termios nTty;
-
-	    /*
-	     * now get the VT.  This _must_ succeed, or else fail completely.
-	     */
-	    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) < 0)
-	        FatalError("xf86OpenConsole: VT_ACTIVATE failed: %s\n",
-		           strerror(errno));
-
-	    if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) < 0)
-	        FatalError("xf86OpenConsole: VT_WAITACTIVE failed: %s\n",
-			   strerror(errno));
-
-	    if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0)
-	        FatalError("xf86OpenConsole: VT_GETMODE failed %s\n",
-		           strerror(errno));
-
-	    signal(SIGUSR1, xf86VTRequest);
-
-	    VT.mode = VT_PROCESS;
-	    VT.relsig = SIGUSR1;
-	    VT.acqsig = SIGUSR1;
-
-	    if (ioctl(xf86Info.consoleFd, VT_SETMODE, &VT) < 0)
-	        FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed: %s\n",
-		    strerror(errno));
-	
-	    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0)
-	        FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed %s\n",
-		           strerror(errno));
-
-            tcgetattr(xf86Info.consoleFd, &tty_attr);
-            ioctl(xf86Info.consoleFd, KDGKBMODE, &tty_mode);
-
-            if (ioctl(xf86Info.consoleFd, KDSKBMODE, K_RAW) < 0)
-                FatalError("xf86OpenConsole: KDSKBMODE K_RAW failed %s\n",
-                        strerror(errno));
-
-            nTty = tty_attr;
-            nTty.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
-            nTty.c_oflag = 0;
-            nTty.c_cflag = CREAD | CS8;
-            nTty.c_lflag = 0;
-            nTty.c_cc[VTIME]=0;
-            nTty.c_cc[VMIN]=1;
-            cfsetispeed(&nTty, 9600);
-            cfsetospeed(&nTty, 9600);
-            tcsetattr(xf86Info.consoleFd, TCSANOW, &nTty);
-
-            /* need to keep the buffer clean, else the kernel gets angry */
-            console_handler = xf86AddGeneralHandler(xf86Info.consoleFd,
-                    drain_console, NULL);
-
-	    /* we really should have a InitOSInputDevices() function instead
-	     * of Init?$#*&Device(). So I just place it here */
-        }
-    } else { 	/* serverGeneration != 1 */
-        if (!ShareVTs && VTSwitch)
-        {
-	    /*
-	     * now get the VT
-	     */
-	    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) < 0)
-	        xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed %s\n",
-		        strerror(errno));
-
-	    if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) < 0)
-	        xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed %s\n",
-		        strerror(errno));
-        }
-    }
-}
-
-void
-xf86CloseConsole(void)
-{
-    struct vt_mode   VT;
-
-    if (ShareVTs) {
-        close(xf86Info.consoleFd);
-        return;
-    }
-
-    if (console_handler) {
-	xf86RemoveGeneralHandler(console_handler);
-	console_handler = NULL;
-    };
-
-    /* Back to text mode ... */
-    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT) < 0)
-	xf86Msg(X_WARNING, "xf86CloseConsole: KDSETMODE failed: %s\n",
-		strerror(errno));
-
-    ioctl(xf86Info.consoleFd, KDSKBMODE, tty_mode);
-    tcsetattr(xf86Info.consoleFd, TCSANOW, &tty_attr);
-
-    if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0) 
-	xf86Msg(X_WARNING, "xf86CloseConsole: VT_GETMODE failed: %s\n",
-		strerror(errno));
-    else {
-	/* set dflt vt handling */
-	VT.mode = VT_AUTO;
-	if (ioctl(xf86Info.consoleFd, VT_SETMODE, &VT) < 0) 
-	    xf86Msg(X_WARNING, "xf86CloseConsole: VT_SETMODE failed: %s\n",
-		    strerror(errno));
-    }
-
-    if (VTSwitch)
-    {
-        /*
-         * Perform a switch back to the active VT when we were started
-         */
-        if (activeVT >= 0) {
-	    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, activeVT) < 0)
-	        xf86Msg(X_WARNING, "xf86CloseConsole: VT_ACTIVATE failed: %s\n",
-		        strerror(errno));
-	    if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, activeVT) < 0)
-		xf86Msg(X_WARNING,
-			"xf86CloseConsole: VT_WAITACTIVE failed: %s\n",
-			strerror(errno));
-	    activeVT = -1;
-        }
-    }
-    close(xf86Info.consoleFd);	/* make the vt-manager happy */
-
-    restoreVtPerms();		/* restore the permissions */
-}
-
-int
-xf86ProcessArgument(int argc, char *argv[], int i)
-{
-	/*
-	 * Keep server from detaching from controlling tty.  This is useful
-	 * when debugging (so the server can receive keyboard signals.
-	 */
-	if (!strcmp(argv[i], "-keeptty"))
-	{
-		KeepTty = TRUE;
-		return(1);
-	}
-        if (!strcmp(argv[i], "-novtswitch"))
-        {
-                VTSwitch = FALSE;
-                return(1);
-        }
-        if (!strcmp(argv[i], "-sharevts"))
-        {
-                ShareVTs = TRUE;
-                return(1);
-        }
-	if ((argv[i][0] == 'v') && (argv[i][1] == 't'))
-	{
-		if (sscanf(argv[i], "vt%2d", &VTnum) == 0)
-		{
-			UseMsg();
-			VTnum = -1;
-			return(0);
-		}
-		return(1);
-	}
-	return(0);
-}
-
-void
-xf86UseMsg(void)
-{
-	ErrorF("vtXX                   use the specified VT number\n");
-	ErrorF("-keeptty               ");
-	ErrorF("don't detach controlling tty (for debugging only)\n");
-	ErrorF("-novtswitch            don't immediately switch to new VT\n");
-	ErrorF("-sharevts              share VTs with another X server\n");
-}
+/*

+ * Copyright 1992 by Orest Zborowski <obz@Kodak.com>

+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>

+ *

+ * 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 names of Orest Zborowski and David Wexelblat

+ * not be used in advertising or publicity pertaining to distribution of

+ * the software without specific, written prior permission.  Orest Zborowski

+ * and David Wexelblat make no representations about the suitability of this

+ * software for any purpose.  It is provided "as is" without express or

+ * implied warranty.

+ *

+ * OREST ZBOROWSKI AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD

+ * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS, IN NO EVENT SHALL OREST ZBOROWSKI OR DAVID WEXELBLAT 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_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+#include <X11/Xmd.h>

+

+#include "compiler.h"

+

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86_OSlib.h"

+

+#include <sys/stat.h>

+

+static Bool KeepTty = FALSE;

+static int VTnum = -1;

+static Bool VTSwitch = TRUE;

+static Bool ShareVTs = FALSE;

+static int activeVT = -1;

+

+static int vtPermSave[4];

+static char vtname[11];

+static struct termios tty_attr; /* tty state to restore */

+static int tty_mode; /* kbd mode to restore */

+

+static int

+saveVtPerms(void)

+{

+    /* We need to use stat to get permissions. */

+    struct stat svtp;

+

+    /* Do them numerically ordered, hard coded tty0 first. */

+    if (stat("/dev/tty0", &svtp) != 0)

+	return 0;

+    vtPermSave[0] = (int)svtp.st_uid;

+    vtPermSave[1] = (int)svtp.st_gid;

+

+    /* Now check the console we are dealing with. */

+    if (stat(vtname, &svtp) != 0)

+	return 0;

+    vtPermSave[2] = (int)svtp.st_uid;

+    vtPermSave[3] = (int)svtp.st_gid;

+

+    return 1;

+}

+

+static void

+restoreVtPerms(void)

+{

+    if (geteuid() == 0) {

+	 /* Set the terminal permissions back to before we started. */

+	 (void)chown("/dev/tty0", vtPermSave[0], vtPermSave[1]);

+	 (void)chown(vtname, vtPermSave[2], vtPermSave[3]);

+    }

+}

+

+static void *console_handler;

+

+static void

+drain_console(int fd, void *closure)

+{

+    tcflush(fd, TCIOFLUSH);

+}

+

+void

+xf86OpenConsole(void)

+{

+    int i, fd = -1;

+    struct vt_mode VT;

+    struct vt_stat vts;

+    MessageType from = X_PROBED;

+    char *tty0[] = { "/dev/tty0", "/dev/vc/0", NULL };

+    char *vcs[] = { "/dev/vc/%d", "/dev/tty%d", NULL };

+

+    if (serverGeneration == 1) {

+

+	/* when KeepTty check if we're run with euid==0 */

+	if (KeepTty && geteuid() != 0) 

+	    FatalError("xf86OpenConsole:"

+		       " Server must be suid root for option \"KeepTTY\"\n");

+

+	/*

+	 * setup the virtual terminal manager

+	 */

+	if (VTnum != -1) {

+	    xf86Info.vtno = VTnum;

+	    from = X_CMDLINE;

+	} else {

+

+	    i=0;

+	    while (tty0[i] != NULL) {

+		if ((fd = open(tty0[i],O_WRONLY,0)) >= 0)

+		  break;

+		i++;

+	    }

+	    

+	    if (fd < 0)

+		FatalError(

+		    "xf86OpenConsole: Cannot open /dev/tty0 (%s)\n",

+		    strerror(errno));

+

+            if (ShareVTs)

+            {

+                if (ioctl(fd, VT_GETSTATE, &vts) == 0)

+                    xf86Info.vtno = vts.v_active;

+                else

+                    FatalError("xf86OpenConsole: Cannot find the current"

+                               " VT (%s)\n", strerror(errno));

+            } else {

+	        if ((ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0) ||

+		    (xf86Info.vtno == -1))

+		    FatalError("xf86OpenConsole: Cannot find a free VT: %s\n",

+                               strerror(errno));

+            }

+	    close(fd);

+	}

+

+	xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno);

+

+	if (!KeepTty) {

+	    pid_t ppid = getppid();

+	    pid_t ppgid;

+	    ppgid = getpgid(ppid);

+

+	    /*

+	     * change to parent process group that pgid != pid so

+	     * that setsid() doesn't fail and we become process

+	     * group leader

+	     */

+	    if (setpgid(0,ppgid) < 0)

+		xf86Msg(X_WARNING, "xf86OpenConsole: setpgid failed: %s\n",

+			strerror(errno));

+

+	    /* become process group leader */

+	    if ((setsid() < 0))

+		xf86Msg(X_WARNING, "xf86OpenConsole: setsid failed: %s\n",

+			strerror(errno));

+	}

+

+        i=0;

+        while (vcs[i] != NULL) {

+            sprintf(vtname, vcs[i], xf86Info.vtno); /* /dev/tty1-64 */

+     	    if ((xf86Info.consoleFd = open(vtname, O_RDWR|O_NDELAY, 0)) >= 0)

+		break;

+            i++;

+        }

+

+	if (xf86Info.consoleFd < 0)

+	    FatalError("xf86OpenConsole: Cannot open virtual console"

+		       " %d (%s)\n", xf86Info.vtno, strerror(errno));

+

+        if (!ShareVTs)

+        {

+	    /*

+	     * Grab the vt ownership before we overwrite it.

+	     * Hard coded /dev/tty0 into this function as well for below.

+	     */

+	    if (!saveVtPerms())

+	        xf86Msg(X_WARNING,

+		        "xf86OpenConsole: Could not save ownership of VT\n");

+

+	    if (geteuid() == 0) {

+		    /* change ownership of the vt */

+		    if (chown(vtname, getuid(), getgid()) < 0)

+			    xf86Msg(X_WARNING,"xf86OpenConsole: chown %s failed: %s\n",

+				    vtname, strerror(errno));

+

+		    /*

+		     * the current VT device we're running on is not

+		     * "console", we want to grab all consoles too

+		     *

+		     * Why is this needed??

+		     */

+		    if (chown("/dev/tty0", getuid(), getgid()) < 0)

+			    xf86Msg(X_WARNING,"xf86OpenConsole: chown /dev/tty0 failed: %s\n",

+				    strerror(errno));

+	    }

+        }

+

+	/*

+	 * Linux doesn't switch to an active vt after the last close of a vt,

+	 * so we do this ourselves by remembering which is active now.

+	 */

+	if (ioctl(xf86Info.consoleFd, VT_GETSTATE, &vts) < 0)

+	    xf86Msg(X_WARNING,"xf86OpenConsole: VT_GETSTATE failed: %s\n",

+		    strerror(errno));

+	else

+	    activeVT = vts.v_active;

+

+#if 0

+	if (!KeepTty) {

+	    /*

+	     * Detach from the controlling tty to avoid char loss

+	     */

+	    if ((i = open("/dev/tty",O_RDWR)) >= 0) {

+		ioctl(i, TIOCNOTTY, 0);

+		close(i);

+	    }

+	}

+#endif

+

+        if (!ShareVTs)

+        {

+            struct termios nTty;

+

+	    /*

+	     * now get the VT.  This _must_ succeed, or else fail completely.

+	     */

+	    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) < 0)

+	        FatalError("xf86OpenConsole: VT_ACTIVATE failed: %s\n",

+		           strerror(errno));

+

+	    if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) < 0)

+	        FatalError("xf86OpenConsole: VT_WAITACTIVE failed: %s\n",

+			   strerror(errno));

+

+	    if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0)

+	        FatalError("xf86OpenConsole: VT_GETMODE failed %s\n",

+		           strerror(errno));

+

+	    signal(SIGUSR1, xf86VTRequest);

+

+	    VT.mode = VT_PROCESS;

+	    VT.relsig = SIGUSR1;

+	    VT.acqsig = SIGUSR1;

+

+	    if (ioctl(xf86Info.consoleFd, VT_SETMODE, &VT) < 0)

+	        FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed: %s\n",

+		    strerror(errno));

+	

+	    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0)

+	        FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed %s\n",

+		           strerror(errno));

+

+            tcgetattr(xf86Info.consoleFd, &tty_attr);

+            ioctl(xf86Info.consoleFd, KDGKBMODE, &tty_mode);

+

+            if (ioctl(xf86Info.consoleFd, KDSKBMODE, K_RAW) < 0)

+                FatalError("xf86OpenConsole: KDSKBMODE K_RAW failed %s\n",

+                        strerror(errno));

+

+            nTty = tty_attr;

+            nTty.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);

+            nTty.c_oflag = 0;

+            nTty.c_cflag = CREAD | CS8;

+            nTty.c_lflag = 0;

+            nTty.c_cc[VTIME]=0;

+            nTty.c_cc[VMIN]=1;

+            cfsetispeed(&nTty, 9600);

+            cfsetospeed(&nTty, 9600);

+            tcsetattr(xf86Info.consoleFd, TCSANOW, &nTty);

+

+            /* need to keep the buffer clean, else the kernel gets angry */

+            console_handler = xf86AddGeneralHandler(xf86Info.consoleFd,

+                    drain_console, NULL);

+

+	    /* we really should have a InitOSInputDevices() function instead

+	     * of Init?$#*&Device(). So I just place it here */

+        }

+    } else { 	/* serverGeneration != 1 */

+        if (!ShareVTs && VTSwitch)

+        {

+	    /*

+	     * now get the VT

+	     */

+	    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) < 0)

+	        xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed %s\n",

+		        strerror(errno));

+

+	    if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) < 0)

+	        xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed %s\n",

+		        strerror(errno));

+        }

+    }

+}

+

+void

+xf86CloseConsole(void)

+{

+    struct vt_mode   VT;

+

+    if (ShareVTs) {

+        close(xf86Info.consoleFd);

+        return;

+    }

+

+    if (console_handler) {

+	xf86RemoveGeneralHandler(console_handler);

+	console_handler = NULL;

+    };

+

+    /* Back to text mode ... */

+    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT) < 0)

+	xf86Msg(X_WARNING, "xf86CloseConsole: KDSETMODE failed: %s\n",

+		strerror(errno));

+

+    ioctl(xf86Info.consoleFd, KDSKBMODE, tty_mode);

+    tcsetattr(xf86Info.consoleFd, TCSANOW, &tty_attr);

+

+    if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0) 

+	xf86Msg(X_WARNING, "xf86CloseConsole: VT_GETMODE failed: %s\n",

+		strerror(errno));

+    else {

+	/* set dflt vt handling */

+	VT.mode = VT_AUTO;

+	if (ioctl(xf86Info.consoleFd, VT_SETMODE, &VT) < 0) 

+	    xf86Msg(X_WARNING, "xf86CloseConsole: VT_SETMODE failed: %s\n",

+		    strerror(errno));

+    }

+

+    if (VTSwitch)

+    {

+        /*

+         * Perform a switch back to the active VT when we were started

+         */

+        if (activeVT >= 0) {

+	    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, activeVT) < 0)

+	        xf86Msg(X_WARNING, "xf86CloseConsole: VT_ACTIVATE failed: %s\n",

+		        strerror(errno));

+	    if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, activeVT) < 0)

+		xf86Msg(X_WARNING,

+			"xf86CloseConsole: VT_WAITACTIVE failed: %s\n",

+			strerror(errno));

+	    activeVT = -1;

+        }

+    }

+    close(xf86Info.consoleFd);	/* make the vt-manager happy */

+

+    restoreVtPerms();		/* restore the permissions */

+}

+

+int

+xf86ProcessArgument(int argc, char *argv[], int i)

+{

+	/*

+	 * Keep server from detaching from controlling tty.  This is useful

+	 * when debugging (so the server can receive keyboard signals.

+	 */

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

+	{

+		KeepTty = TRUE;

+		return 1;

+	}

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

+        {

+                VTSwitch = FALSE;

+                return 1;

+        }

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

+        {

+                ShareVTs = TRUE;

+                return 1;

+        }

+	if ((argv[i][0] == 'v') && (argv[i][1] == 't'))

+	{

+		if (sscanf(argv[i], "vt%2d", &VTnum) == 0)

+		{

+			UseMsg();

+			VTnum = -1;

+			return 0;

+		}

+		return 1;

+	}

+	return 0;

+}

+

+void

+xf86UseMsg(void)

+{

+	ErrorF("vtXX                   use the specified VT number\n");

+	ErrorF("-keeptty               ");

+	ErrorF("don't detach controlling tty (for debugging only)\n");

+	ErrorF("-novtswitch            don't immediately switch to new VT\n");

+	ErrorF("-sharevts              share VTs with another X server\n");

+}

diff --git a/xorg-server/hw/xfree86/os-support/sco/VTsw_sco.c b/xorg-server/hw/xfree86/os-support/sco/VTsw_sco.c
index 9300b13b9..c9ef7d5cd 100644
--- a/xorg-server/hw/xfree86/os-support/sco/VTsw_sco.c
+++ b/xorg-server/hw/xfree86/os-support/sco/VTsw_sco.c
@@ -58,7 +58,7 @@ xf86VTRequest(int sig)
 Bool

 xf86VTSwitchPending(void)

 {

-  return(xf86Info.vtRequestsPending ? TRUE : FALSE);

+  return xf86Info.vtRequestsPending ? TRUE : FALSE;

 }

 

 /*

@@ -79,9 +79,9 @@ xf86VTSwitchAway(void)
 

   xf86Info.vtRequestsPending = FALSE;

   if (ioctl(xf86Info.consoleFd, VT_RELDISP, VT_TRUE) < 0) {

-    return(FALSE);

+    return FALSE;

   } else {

-    return(TRUE);

+    return TRUE;

   }

 }

 

@@ -97,7 +97,7 @@ xf86VTSwitchTo(void)
 

   xf86Info.vtRequestsPending = FALSE;

   if (ioctl(xf86Info.consoleFd, VT_RELDISP, VT_ACKACQ) < 0) {

-    return(FALSE);

+    return FALSE;

   } else {

     if (sco_ledstatus >= 0) {

       ioctl (xf86Info.consoleFd, KDSETLED, sco_ledstate);

@@ -120,8 +120,8 @@ Bool
 xf86VTActivate(int vtno)

 {

 	if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, vtno - 1) < 0) {

-		return(FALSE);

+		return FALSE;

 	}

 

-	return(TRUE);

+	return TRUE;

 }

diff --git a/xorg-server/hw/xfree86/os-support/sco/sco_init.c b/xorg-server/hw/xfree86/os-support/sco/sco_init.c
index 5f7db3437..fd4c898dd 100644
--- a/xorg-server/hw/xfree86/os-support/sco/sco_init.c
+++ b/xorg-server/hw/xfree86/os-support/sco/sco_init.c
@@ -1,294 +1,294 @@
-/*
- * Copyright 2001-2005 by J. Kean Johnston <jkj@sco.com>
- *
- * 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 J. Kean Johnston not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  J. Kean Johnston makes no
- * representations about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
- *
- * J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL J. KEAN JOHNSTON 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.
- */
-
-/* Re-written May 2001 to represent the current state of reality */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xmd.h>
-
-#include "compiler.h"
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-
-static Bool KeepTty = FALSE;
-static int VTnum = -1;
-static char vtdevice[48];
-static int sco_console_mode = -1;
-
-extern Bool mpxLock;
-
-void
-xf86OpenConsole(void)
-{
-  int i, ioctl_ret;
-  struct vt_mode VT;
-  struct vid_info vidinf;
-  struct sigaction sigvtsw;
-  char *ttn;
-
-  if (serverGeneration == 1) {
-    /* check if we're run with euid==0 */
-    if (geteuid() != 0) {
-      FatalError("xf86OpenConsole: Server must be setuid root\n");
-    }
-
-    /* If we are run in the background we will get SIGTTOU. Ignore it. */
-    OsSignal (SIGTTOU, SIG_IGN);
-
-    /*
-     * Set up the virtual terminal (multiscreen in SCO parlance).
-     * For the actual console itself, screens are numbered from
-     * 1 to (usually) 16. However, it is possible to have a nested
-     * server, and it is also possible to be on a multi-console
-     * system such as MaxSpeed or SunRiver. Therefore, we should
-     * not make any assumptions about the TTY name we are on, and
-     * instead we rely on ttyname() to give us the real TTY name.
-     * Previously, we tried to determine the TTY name manually.
-     * This is wrong. The only time we need to futz with the TTY name
-     * is if we were given the name of a TTY to run on explicity on
-     * the command line.
-     */
-
-    if (VTnum == -1) {
-      /*
-       * No device was specified. We need to query the kernel to see which
-       * console device we are on (and in fact if we are on a console at all).
-       */
-      ttn = ttyname (1);
-
-      if (ttn == (char *)0) {
-	FatalError ("xf86OpenConsole: Could not determine TTY name: %s\n",
-	  strerror(errno));
-      }
-      strlcpy (vtdevice, ttn, sizeof(vtdevice));
-    } else if (VTnum >= 0) {
-      snprintf (vtdevice, sizeof(vtdevice), "/dev/tty%02d", VTnum);
-    }
-
-    /*
-     * Now we can dispose of stdin/stdout
-     */
-    fclose (stdin);
-    fclose (stdout);
-
-    if ((xf86Info.consoleFd = open(vtdevice, O_RDWR | O_NDELAY, 0)) < 0) {
-      FatalError("xf86OpenConsole: Cannot open %s: %s\n", vtdevice,
-	strerror(errno));
-    }
-
-    /*
-     * We make 100% sure we use the correct VT number. This can get ugly
-     * where there are multi-consoles in use, so we make sure we query
-     * the kernel for the correct VT number. It knows best, we don't.
-     */
-    vidinf.size = sizeof(vidinf);
-    if (ioctl (xf86Info.consoleFd, CONS_GETINFO, &vidinf) < 0) {
-      FatalError ("xf86OpenConsole: %s not a console device "
-	"or error querying device: %s\n", vtdevice, strerror (errno));
-    }
-    xf86Info.vtno = vidinf.m_num;
-    VTnum = vidinf.m_num + 1; /* 0-based */
-
-    ErrorF("(using VT%02d device %s)\n\n", VTnum, vtdevice);
-
-    /* We activate the console just in case its not the one we are on */
-    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) {
-        ErrorF("xf86OpenConsole: VT_ACTIVATE failed (%s)\n", strerror(errno));
-    }
-
-    /* Disassociate from controling TTY */
-    if (!KeepTty) {
-      setpgrp();
-    }
-
-    /*
-     * Now we get the current mode that the console device is in. We will
-     * use this later when we close the console device to restore it to
-     * that same mode.
-     */
-    if ((sco_console_mode = ioctl(xf86Info.consoleFd, CONS_GET, 0L)) < 0) {
-      FatalError("xf86OpenConsole: CONS_GET failed on console (%s)\n",
-          strerror(errno));
-    }
-
-    if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0) {
-      FatalError("xf86OpenConsole: VT_GETMODE failed (%s)\n", strerror(errno));
-    }
-
-    sigvtsw.sa_handler = xf86VTRequest;
-    sigfillset(&sigvtsw.sa_mask);
-    sigvtsw.sa_flags = 0;
-
-    /* NOTE: Using sigaction means we dont have to re-arm the signal */
-    sigaction(SIGUSR1, &sigvtsw, NULL);
-
-    VT.mode = VT_PROCESS;
-    VT.relsig = SIGUSR1;
-    VT.acqsig = SIGUSR1;
-    VT.frsig = SIGINT;          /* Not implemented */
-    VT.waitv = 0;
-
-    /*
-     * The SCO X server tries the following call 5 times. Lets do the same
-     * thing. It shouldn't really be required but sometimes things take a
-     * while to settle down when switching screens. *helpless shrug* I know
-     * its sucks but ...
-     */
-
-    ioctl_ret = 0;
-    for (i = 0; i < 5; i++) {
-      ioctl_ret = ioctl(xf86Info.consoleFd, VT_SETMODE, &VT);
-      if (ioctl_ret >= 0)
-        break;
-      usleep(999999); /* Dont use nap() - it forces linking with -lx */
-    }
-
-    if (ioctl_ret < 0) {
-      FatalError("xf86OpenConsole: VT_SETMODE failed (%s)\n", strerror(errno));
-    }
-
-    /*
-     * Convince the console driver we are in graphics mode.
-     */
-    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0) {
-        ErrorF("Failed to set graphics mode (%s)\n", strerror(errno));
-    }
-  } else { /* serverGeneration != 1 */
-    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) {
-      ErrorF("xf86OpenConsole: VT_ACTIVATE failed (%s)\n", strerror(errno));
-    }
-  }
-}
-
-/*
- * Restore the console to its previous state. This may cause flicker if
- * the screen was previous in a graphics mode, because we first set it
- * to text mode. This has the advantage of getting the console driver
- * to do a soft reset on the card, which really does help settle the
- * video card down again after coming out of Xfree86.
- */
-void
-xf86CloseConsole(void)
-{
-  struct vt_mode VT;
-  struct sigaction sigvtsw;
-
-  /* Set text mode (possibly briefly) */
-  ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT0);
-
-  /* Restore the original mode */
-  if (sco_console_mode != -1) {
-      ioctl(xf86Info.consoleFd, MODESWITCH | sco_console_mode, 0L);
-  }
-
-  ioctl(xf86Info.consoleFd, VT_RELDISP, 1);     /* Release the display */
-
-  sigvtsw.sa_handler = SIG_DFL;
-  sigfillset(&sigvtsw.sa_mask);
-  sigvtsw.sa_flags = 0;
-
-  sigaction(SIGUSR1, &sigvtsw, NULL);
-
-  VT.mode = VT_AUTO;
-  VT.waitv = 0;
-  VT.relsig = SIGUSR1;
-  VT.acqsig = SIGUSR1;
-  VT.frsig  = SIGINT;
-  ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* Revert to auto handling */
-
-  close(xf86Info.consoleFd); /* We're done with the device */
-}
-
-int
-xf86ProcessArgument(int argc, char *argv[], int i)
-{
-  /*
-   * Keep server from detaching from controlling tty.  This is useful
-   * when debugging (so the server can receive keyboard signals).
-   */
-  if (!strcmp(argv[i], "-keeptty")) {
-    KeepTty = TRUE;
-    return(1);
-  }
-
-  /*
-   * By default, the X server wants to bind itself to CPU 0. This makes
-   * sure that the server has full access to the I/O ports at IOPL 3.
-   * Some SMP systems have trouble with I/O on CPU's other than 0. If,
-   * however, you have a system that is well behaved, you can specify
-   * this argument and let the scheduler decide which CPU the server
-   * should run on.
-   */
-  if (!strcmp(argv[i], "-nompxlock")) {
-    mpxLock = FALSE;
-    return (1);
-  }
-
-  /*
-   * Specify the VT number to run on (NOT the device).
-   */
-  if ((argv[i][0] == 'v') && (argv[i][1] == 't')) {
-    if (sscanf(argv[i], "vt%2d", &VTnum) == 0) {
-      UseMsg();
-      VTnum = -1;
-      return(0);
-    }
-    if (VTnum <= 0) {
-      UseMsg();
-      VTnum = -1;
-      return(0);
-    }
-    return(1);
-  }
-
-  /*
-   * Use a device the user specifies.
-   */
-  if (!strcmp(argv[i], "-crt")) {
-    if (++i > argc) {
-      UseMsg();
-      VTnum = -1;
-      return(0);
-    } else {
-      VTnum = -2;
-      strlcpy (vtdevice, argv[i], sizeof(vtdevice));
-      return(2);
-    }
-  }
-  return(0);
-}
-
-void
-xf86UseMsg(void)
-{
-	ErrorF("vtXX                   use the specified VT number\n");
-	ErrorF("-crt DEVICE            use the specified VT device\n");
-        ErrorF("-nompxlock             dont bind X server to CPU 0\n");
-	ErrorF("-keeptty               ");
-	ErrorF("don't detach controlling tty (for debugging only)\n");
-}
+/*

+ * Copyright 2001-2005 by J. Kean Johnston <jkj@sco.com>

+ *

+ * 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 J. Kean Johnston not be used in

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

+ * specific, written prior permission.  J. Kean Johnston makes no

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

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

+ *

+ * J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

+ * EVENT SHALL J. KEAN JOHNSTON 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.

+ */

+

+/* Re-written May 2001 to represent the current state of reality */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+#include <X11/Xmd.h>

+

+#include "compiler.h"

+

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86_OSlib.h"

+

+static Bool KeepTty = FALSE;

+static int VTnum = -1;

+static char vtdevice[48];

+static int sco_console_mode = -1;

+

+extern Bool mpxLock;

+

+void

+xf86OpenConsole(void)

+{

+  int i, ioctl_ret;

+  struct vt_mode VT;

+  struct vid_info vidinf;

+  struct sigaction sigvtsw;

+  char *ttn;

+

+  if (serverGeneration == 1) {

+    /* check if we're run with euid==0 */

+    if (geteuid() != 0) {

+      FatalError("xf86OpenConsole: Server must be setuid root\n");

+    }

+

+    /* If we are run in the background we will get SIGTTOU. Ignore it. */

+    OsSignal (SIGTTOU, SIG_IGN);

+

+    /*

+     * Set up the virtual terminal (multiscreen in SCO parlance).

+     * For the actual console itself, screens are numbered from

+     * 1 to (usually) 16. However, it is possible to have a nested

+     * server, and it is also possible to be on a multi-console

+     * system such as MaxSpeed or SunRiver. Therefore, we should

+     * not make any assumptions about the TTY name we are on, and

+     * instead we rely on ttyname() to give us the real TTY name.

+     * Previously, we tried to determine the TTY name manually.

+     * This is wrong. The only time we need to futz with the TTY name

+     * is if we were given the name of a TTY to run on explicity on

+     * the command line.

+     */

+

+    if (VTnum == -1) {

+      /*

+       * No device was specified. We need to query the kernel to see which

+       * console device we are on (and in fact if we are on a console at all).

+       */

+      ttn = ttyname (1);

+

+      if (ttn == (char *)0) {

+	FatalError ("xf86OpenConsole: Could not determine TTY name: %s\n",

+	  strerror(errno));

+      }

+      strlcpy (vtdevice, ttn, sizeof(vtdevice));

+    } else if (VTnum >= 0) {

+      snprintf (vtdevice, sizeof(vtdevice), "/dev/tty%02d", VTnum);

+    }

+

+    /*

+     * Now we can dispose of stdin/stdout

+     */

+    fclose (stdin);

+    fclose (stdout);

+

+    if ((xf86Info.consoleFd = open(vtdevice, O_RDWR | O_NDELAY, 0)) < 0) {

+      FatalError("xf86OpenConsole: Cannot open %s: %s\n", vtdevice,

+	strerror(errno));

+    }

+

+    /*

+     * We make 100% sure we use the correct VT number. This can get ugly

+     * where there are multi-consoles in use, so we make sure we query

+     * the kernel for the correct VT number. It knows best, we don't.

+     */

+    vidinf.size = sizeof(vidinf);

+    if (ioctl (xf86Info.consoleFd, CONS_GETINFO, &vidinf) < 0) {

+      FatalError ("xf86OpenConsole: %s not a console device "

+	"or error querying device: %s\n", vtdevice, strerror (errno));

+    }

+    xf86Info.vtno = vidinf.m_num;

+    VTnum = vidinf.m_num + 1; /* 0-based */

+

+    ErrorF("(using VT%02d device %s)\n\n", VTnum, vtdevice);

+

+    /* We activate the console just in case its not the one we are on */

+    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) {

+        ErrorF("xf86OpenConsole: VT_ACTIVATE failed (%s)\n", strerror(errno));

+    }

+

+    /* Disassociate from controling TTY */

+    if (!KeepTty) {

+      setpgrp();

+    }

+

+    /*

+     * Now we get the current mode that the console device is in. We will

+     * use this later when we close the console device to restore it to

+     * that same mode.

+     */

+    if ((sco_console_mode = ioctl(xf86Info.consoleFd, CONS_GET, 0L)) < 0) {

+      FatalError("xf86OpenConsole: CONS_GET failed on console (%s)\n",

+          strerror(errno));

+    }

+

+    if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0) {

+      FatalError("xf86OpenConsole: VT_GETMODE failed (%s)\n", strerror(errno));

+    }

+

+    sigvtsw.sa_handler = xf86VTRequest;

+    sigfillset(&sigvtsw.sa_mask);

+    sigvtsw.sa_flags = 0;

+

+    /* NOTE: Using sigaction means we dont have to re-arm the signal */

+    sigaction(SIGUSR1, &sigvtsw, NULL);

+

+    VT.mode = VT_PROCESS;

+    VT.relsig = SIGUSR1;

+    VT.acqsig = SIGUSR1;

+    VT.frsig = SIGINT;          /* Not implemented */

+    VT.waitv = 0;

+

+    /*

+     * The SCO X server tries the following call 5 times. Lets do the same

+     * thing. It shouldn't really be required but sometimes things take a

+     * while to settle down when switching screens. *helpless shrug* I know

+     * its sucks but ...

+     */

+

+    ioctl_ret = 0;

+    for (i = 0; i < 5; i++) {

+      ioctl_ret = ioctl(xf86Info.consoleFd, VT_SETMODE, &VT);

+      if (ioctl_ret >= 0)

+        break;

+      usleep(999999); /* Dont use nap() - it forces linking with -lx */

+    }

+

+    if (ioctl_ret < 0) {

+      FatalError("xf86OpenConsole: VT_SETMODE failed (%s)\n", strerror(errno));

+    }

+

+    /*

+     * Convince the console driver we are in graphics mode.

+     */

+    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0) {

+        ErrorF("Failed to set graphics mode (%s)\n", strerror(errno));

+    }

+  } else { /* serverGeneration != 1 */

+    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) {

+      ErrorF("xf86OpenConsole: VT_ACTIVATE failed (%s)\n", strerror(errno));

+    }

+  }

+}

+

+/*

+ * Restore the console to its previous state. This may cause flicker if

+ * the screen was previous in a graphics mode, because we first set it

+ * to text mode. This has the advantage of getting the console driver

+ * to do a soft reset on the card, which really does help settle the

+ * video card down again after coming out of Xfree86.

+ */

+void

+xf86CloseConsole(void)

+{

+  struct vt_mode VT;

+  struct sigaction sigvtsw;

+

+  /* Set text mode (possibly briefly) */

+  ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT0);

+

+  /* Restore the original mode */

+  if (sco_console_mode != -1) {

+      ioctl(xf86Info.consoleFd, MODESWITCH | sco_console_mode, 0L);

+  }

+

+  ioctl(xf86Info.consoleFd, VT_RELDISP, 1);     /* Release the display */

+

+  sigvtsw.sa_handler = SIG_DFL;

+  sigfillset(&sigvtsw.sa_mask);

+  sigvtsw.sa_flags = 0;

+

+  sigaction(SIGUSR1, &sigvtsw, NULL);

+

+  VT.mode = VT_AUTO;

+  VT.waitv = 0;

+  VT.relsig = SIGUSR1;

+  VT.acqsig = SIGUSR1;

+  VT.frsig  = SIGINT;

+  ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* Revert to auto handling */

+

+  close(xf86Info.consoleFd); /* We're done with the device */

+}

+

+int

+xf86ProcessArgument(int argc, char *argv[], int i)

+{

+  /*

+   * Keep server from detaching from controlling tty.  This is useful

+   * when debugging (so the server can receive keyboard signals).

+   */

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

+    KeepTty = TRUE;

+    return 1;

+  }

+

+  /*

+   * By default, the X server wants to bind itself to CPU 0. This makes

+   * sure that the server has full access to the I/O ports at IOPL 3.

+   * Some SMP systems have trouble with I/O on CPU's other than 0. If,

+   * however, you have a system that is well behaved, you can specify

+   * this argument and let the scheduler decide which CPU the server

+   * should run on.

+   */

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

+    mpxLock = FALSE;

+    return 1;

+  }

+

+  /*

+   * Specify the VT number to run on (NOT the device).

+   */

+  if ((argv[i][0] == 'v') && (argv[i][1] == 't')) {

+    if (sscanf(argv[i], "vt%2d", &VTnum) == 0) {

+      UseMsg();

+      VTnum = -1;

+      return 0;

+    }

+    if (VTnum <= 0) {

+      UseMsg();

+      VTnum = -1;

+      return 0;

+    }

+    return 1;

+  }

+

+  /*

+   * Use a device the user specifies.

+   */

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

+    if (++i > argc) {

+      UseMsg();

+      VTnum = -1;

+      return 0;

+    } else {

+      VTnum = -2;

+      strlcpy (vtdevice, argv[i], sizeof(vtdevice));

+      return 2;

+    }

+  }

+  return 0;

+}

+

+void

+xf86UseMsg(void)

+{

+	ErrorF("vtXX                   use the specified VT number\n");

+	ErrorF("-crt DEVICE            use the specified VT device\n");

+        ErrorF("-nompxlock             dont bind X server to CPU 0\n");

+	ErrorF("-keeptty               ");

+	ErrorF("don't detach controlling tty (for debugging only)\n");

+}

diff --git a/xorg-server/hw/xfree86/os-support/shared/VTsw_noop.c b/xorg-server/hw/xfree86/os-support/shared/VTsw_noop.c
index f3ddb29c9..be47cd681 100644
--- a/xorg-server/hw/xfree86/os-support/shared/VTsw_noop.c
+++ b/xorg-server/hw/xfree86/os-support/shared/VTsw_noop.c
@@ -38,23 +38,23 @@
 Bool

 xf86VTSwitchPending(void)

 {

-	return(FALSE);

+	return FALSE;

 }

 

 Bool

 xf86VTSwitchAway(void)

 {

-	return(FALSE);

+	return FALSE;

 }

 

 Bool

 xf86VTSwitchTo(void)

 {

-	return(TRUE);

+	return TRUE;

 }

 

 Bool

 xf86VTActivate(int vtno)

 {

-	return(TRUE);

+	return TRUE;

 }

diff --git a/xorg-server/hw/xfree86/os-support/shared/VTsw_usl.c b/xorg-server/hw/xfree86/os-support/shared/VTsw_usl.c
index 34bca7ae2..00bfb7151 100644
--- a/xorg-server/hw/xfree86/os-support/shared/VTsw_usl.c
+++ b/xorg-server/hw/xfree86/os-support/shared/VTsw_usl.c
@@ -55,7 +55,7 @@ xf86VTRequest(int sig)
 Bool

 xf86VTSwitchPending(void)

 {

-    return(xf86Info.vtRequestsPending ? TRUE : FALSE);

+    return xf86Info.vtRequestsPending ? TRUE : FALSE;

 }

 

 Bool

@@ -64,14 +64,14 @@ xf86VTSwitchAway(void)
 	xf86Info.vtRequestsPending = FALSE;

 	if (ioctl(xf86Info.consoleFd, VT_RELDISP, 1) < 0)

 	{

-		return(FALSE);

+		return FALSE;

 	}

 	else

 	{

 #ifdef OSSWITCHAWAY

 	        OSSWITCHAWAY;

 #endif

-		return(TRUE);

+		return TRUE;

 	}

 }

 

@@ -81,11 +81,11 @@ xf86VTSwitchTo(void)
 	xf86Info.vtRequestsPending = FALSE;

 	if (ioctl(xf86Info.consoleFd, VT_RELDISP, VT_ACKACQ) < 0)

 	{

-		return(FALSE);

+		return FALSE;

 	}

 	else

 	{

-		return(TRUE);

+		return TRUE;

 	}

 }

 

@@ -94,8 +94,8 @@ xf86VTActivate(int vtno)
 {

 #ifdef VT_ACTIVATE

 	if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, vtno) < 0) {

-		return(FALSE);

+		return FALSE;

 	}

 #endif

-	return(TRUE);

+	return TRUE;

 }

diff --git a/xorg-server/hw/xfree86/os-support/shared/bios_devmem.c b/xorg-server/hw/xfree86/os-support/shared/bios_devmem.c
index 67a14f5d6..4699fcb88 100644
--- a/xorg-server/hw/xfree86/os-support/shared/bios_devmem.c
+++ b/xorg-server/hw/xfree86/os-support/shared/bios_devmem.c
@@ -1,75 +1,75 @@
-/*
- * Copyright 1993 by David Wexelblat <dwex@goblin.org>
- *
- * 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 David Wexelblat not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  David Wexelblat makes no representations
- * about the suitability of this software for any purpose.  It is provided
- * "as is" without express or implied warranty.
- *
- * DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL DAVID WEXELBLAT 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_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-#include <string.h>
-
-/*
- * Read BIOS via /dev/mem.
- */
-
-#ifndef DEV_MEM
-# define DEV_MEM "/dev/mem"
-#endif
-
-int
-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
-		int Len)
-{
- 	int fd;
-
-#ifdef __ia64__
-	if ((fd = open(DEV_MEM, O_RDONLY | O_SYNC)) < 0)
-#else
- 	if ((fd = open(DEV_MEM, O_RDONLY)) < 0)
-#endif
-	{
-		xf86Msg(X_WARNING, "xf86ReadBIOS: Failed to open %s (%s)\n",
-			DEV_MEM, strerror(errno));
-		return(-1);
-	}
-
-	if (lseek(fd, (Base+Offset), SEEK_SET) < 0)
-	{
-		xf86Msg(X_WARNING, "xf86ReadBIOS: %s seek failed (%s)\n",
-			DEV_MEM, strerror(errno));
-		close(fd);
-		return(-1);
-	}
-	if (read(fd, Buf, Len) != Len)
-	{
-		xf86Msg(X_WARNING, "xf86ReadBIOS: %s read failed (%s)\n",
-			DEV_MEM, strerror(errno));
-		close(fd);
-		return(-1);
-	}
-	close(fd);
-	return(Len);
-}
+/*

+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>

+ *

+ * 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 David Wexelblat not be used in

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

+ * specific, written prior permission.  David Wexelblat makes no representations

+ * about the suitability of this software for any purpose.  It is provided

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

+ *

+ * DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

+ * EVENT SHALL DAVID WEXELBLAT 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_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86_OSlib.h"

+#include <string.h>

+

+/*

+ * Read BIOS via /dev/mem.

+ */

+

+#ifndef DEV_MEM

+# define DEV_MEM "/dev/mem"

+#endif

+

+int

+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

+		int Len)

+{

+ 	int fd;

+

+#ifdef __ia64__

+	if ((fd = open(DEV_MEM, O_RDONLY | O_SYNC)) < 0)

+#else

+ 	if ((fd = open(DEV_MEM, O_RDONLY)) < 0)

+#endif

+	{

+		xf86Msg(X_WARNING, "xf86ReadBIOS: Failed to open %s (%s)\n",

+			DEV_MEM, strerror(errno));

+		return -1;

+	}

+

+	if (lseek(fd, (Base+Offset), SEEK_SET) < 0)

+	{

+		xf86Msg(X_WARNING, "xf86ReadBIOS: %s seek failed (%s)\n",

+			DEV_MEM, strerror(errno));

+		close(fd);

+		return -1;

+	}

+	if (read(fd, Buf, Len) != Len)

+	{

+		xf86Msg(X_WARNING, "xf86ReadBIOS: %s read failed (%s)\n",

+			DEV_MEM, strerror(errno));

+		close(fd);

+		return -1;

+	}

+	close(fd);

+	return Len;

+}

diff --git a/xorg-server/hw/xfree86/os-support/shared/bios_mmap.c b/xorg-server/hw/xfree86/os-support/shared/bios_mmap.c
index 40afd5b8e..a5887f578 100644
--- a/xorg-server/hw/xfree86/os-support/shared/bios_mmap.c
+++ b/xorg-server/hw/xfree86/os-support/shared/bios_mmap.c
@@ -1,141 +1,141 @@
-/*
- * Copyright 1993 by David Wexelblat <dwex@goblin.org>
- *
- * 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 David Wexelblat not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  David Wexelblat makes no representations
- * about the suitability of this software for any purpose.  It is provided
- * "as is" without express or implied warranty.
- *
- * DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL DAVID WEXELBLAT 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_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-
-#ifndef MAP_FAILED
-#define MAP_FAILED ((void *)-1)
-#endif
-
-/*
- * Read BIOS via mmap()ing DEV_MEM
- */
-
-#ifndef __alpha__
-int
-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
-	     int Len)
-{
-	int fd;
-	unsigned char *ptr;
-	int psize;
-	int mlen;
-
-	if ((fd = open(DEV_MEM, O_RDONLY)) < 0)
-	{
-		xf86Msg(X_WARNING, "xf86ReadBIOS: Failed to open %s (%s)\n",
-			DEV_MEM, strerror(errno));
-		return(-1);
-	}
-	psize = getpagesize();
-	Offset += Base & (psize - 1);
-	Base &= ~(psize - 1);
-	mlen = (Offset + Len + psize - 1) & ~(psize - 1);
-	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,
-					MAP_SHARED, fd, (off_t)Base);
-	if (ptr == MAP_FAILED)
-	{
-		xf86Msg(X_WARNING, "xf86ReadBIOS: %s mmap failed (%s)\n",
-			DEV_MEM, strerror(errno));
-		close(fd);
-		return(-1);
-	}
-	DebugF("xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",
-		Base, ptr[0] | (ptr[1] << 8));
-	(void)memcpy(Buf, (void *)(ptr + Offset), Len);
-	(void)munmap((caddr_t)ptr, mlen);
-	(void)close(fd);
-	return(Len);
-}
-
-#else /* __alpha__ */
-
-  /*
-   *  We trick "mmap" into mapping BUS memory for us via BUS_BASE,
-   *  which is the KSEG address of the start of the DENSE memory
-   *  area.
-   */
-
-  /*
-   * NOTE: there prolly ought to be more validity checks and all
-   *  re: boundaries and sizes and such...
-   */
-
-#ifdef linux
-
-extern unsigned long _bus_base(void);
-#define BUS_BASE _bus_base()
-
-#else
-
-extern u_int64_t dense_base(void);
-#define BUS_BASE dense_base()
-
-#endif
-
-int
-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
-	     int Len)
-{
-	caddr_t base;
- 	int fd;
-	int psize;
-	int mlen;
-
-	if ((fd = open(DEV_MEM, O_RDONLY)) < 0)
-	{
-		xf86Msg(X_WARNING, "xf86ReadBIOS: Failed to open %s (%s)\n",
-			DEV_MEM, strerror(errno));
-		return(-1);
-	}
-
-	psize = getpagesize();
-	Offset += Base & (psize - 1);
-	Base &= ~(psize - 1);
-	mlen = (Offset + Len + psize - 1) & ~(psize - 1);
-	base = mmap((caddr_t)0, mlen, PROT_READ,
-		    MAP_SHARED, fd, (off_t)(Base + BUS_BASE));
-
-	if (base == MAP_FAILED)
-	{
-		xf86Msg(X_WARNING, "xf86ReadBIOS: Failed to mmap %s (%s)\n",
-			DEV_MEM, strerror(errno));
-		return(-1);
-	}
-
-	xf86SlowBCopyFromBus((unsigned char *)(base+Offset), Buf, Len);
-
-	munmap((caddr_t)base, mlen);
-	close(fd);
-	return(Len);
-}
-
-#endif /* __alpha__ */
+/*

+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>

+ *

+ * 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 David Wexelblat not be used in

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

+ * specific, written prior permission.  David Wexelblat makes no representations

+ * about the suitability of this software for any purpose.  It is provided

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

+ *

+ * DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

+ * EVENT SHALL DAVID WEXELBLAT 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_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86_OSlib.h"

+

+#ifndef MAP_FAILED

+#define MAP_FAILED ((void *)-1)

+#endif

+

+/*

+ * Read BIOS via mmap()ing DEV_MEM

+ */

+

+#ifndef __alpha__

+int

+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

+	     int Len)

+{

+	int fd;

+	unsigned char *ptr;

+	int psize;

+	int mlen;

+

+	if ((fd = open(DEV_MEM, O_RDONLY)) < 0)

+	{

+		xf86Msg(X_WARNING, "xf86ReadBIOS: Failed to open %s (%s)\n",

+			DEV_MEM, strerror(errno));

+		return -1;

+	}

+	psize = getpagesize();

+	Offset += Base & (psize - 1);

+	Base &= ~(psize - 1);

+	mlen = (Offset + Len + psize - 1) & ~(psize - 1);

+	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,

+					MAP_SHARED, fd, (off_t)Base);

+	if (ptr == MAP_FAILED)

+	{

+		xf86Msg(X_WARNING, "xf86ReadBIOS: %s mmap failed (%s)\n",

+			DEV_MEM, strerror(errno));

+		close(fd);

+		return -1;

+	}

+	DebugF("xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",

+		Base, ptr[0] | (ptr[1] << 8));

+	(void)memcpy(Buf, (void *)(ptr + Offset), Len);

+	(void)munmap((caddr_t)ptr, mlen);

+	(void)close(fd);

+	return Len;

+}

+

+#else /* __alpha__ */

+

+  /*

+   *  We trick "mmap" into mapping BUS memory for us via BUS_BASE,

+   *  which is the KSEG address of the start of the DENSE memory

+   *  area.

+   */

+

+  /*

+   * NOTE: there prolly ought to be more validity checks and all

+   *  re: boundaries and sizes and such...

+   */

+

+#ifdef linux

+

+extern unsigned long _bus_base(void);

+#define BUS_BASE _bus_base()

+

+#else

+

+extern u_int64_t dense_base(void);

+#define BUS_BASE dense_base()

+

+#endif

+

+int

+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

+	     int Len)

+{

+	caddr_t base;

+ 	int fd;

+	int psize;

+	int mlen;

+

+	if ((fd = open(DEV_MEM, O_RDONLY)) < 0)

+	{

+		xf86Msg(X_WARNING, "xf86ReadBIOS: Failed to open %s (%s)\n",

+			DEV_MEM, strerror(errno));

+		return -1;

+	}

+

+	psize = getpagesize();

+	Offset += Base & (psize - 1);

+	Base &= ~(psize - 1);

+	mlen = (Offset + Len + psize - 1) & ~(psize - 1);

+	base = mmap((caddr_t)0, mlen, PROT_READ,

+		    MAP_SHARED, fd, (off_t)(Base + BUS_BASE));

+

+	if (base == MAP_FAILED)

+	{

+		xf86Msg(X_WARNING, "xf86ReadBIOS: Failed to mmap %s (%s)\n",

+			DEV_MEM, strerror(errno));

+		return -1;

+	}

+

+	xf86SlowBCopyFromBus((unsigned char *)(base+Offset), Buf, Len);

+

+	munmap((caddr_t)base, mlen);

+	close(fd);

+	return Len;

+}

+

+#endif /* __alpha__ */

diff --git a/xorg-server/hw/xfree86/os-support/shared/posix_tty.c b/xorg-server/hw/xfree86/os-support/shared/posix_tty.c
index 7e2c4a181..97860d0f2 100644
--- a/xorg-server/hw/xfree86/os-support/shared/posix_tty.c
+++ b/xorg-server/hw/xfree86/os-support/shared/posix_tty.c
@@ -108,7 +108,7 @@ GetBaud (int baudrate)
 	if (baudrate == 460800)

 		return B460800;

 #endif

-	return (0);

+	return 0;

 }

 

 int

@@ -122,7 +122,7 @@ xf86OpenSerial (pointer options)
 	if (!dev)

 	{

 		xf86Msg (X_ERROR, "xf86OpenSerial: No Device specified.\n");

-		return (-1);

+		return -1;

 	}

 

 	SYSCALL (fd = open (dev, O_RDWR | O_NONBLOCK));

@@ -132,14 +132,14 @@ xf86OpenSerial (pointer options)
 			 "xf86OpenSerial: Cannot open device %s\n\t%s.\n",

 			 dev, strerror (errno));

 		free(dev);

-		return (-1);

+		return -1;

 	}

 

 	if (!isatty (fd))

 	{

 		/* Allow non-tty devices to be opened. */

 		free(dev);

-		return (fd);

+		return fd;

 	}

 

 	/* set up default port parameters */

@@ -162,7 +162,7 @@ xf86OpenSerial (pointer options)
 	{

 		SYSCALL (close (fd));

 		free(dev);

-		return (-1);

+		return -1;

 	}

 

 	SYSCALL (i = fcntl (fd, F_GETFL, 0));

@@ -170,7 +170,7 @@ xf86OpenSerial (pointer options)
 	{

 		SYSCALL (close (fd));

 		free(dev);

-		return (-1);

+		return -1;

 	}

 	i &= ~O_NONBLOCK;

 	SYSCALL (i = fcntl (fd, F_SETFL, i));

@@ -178,10 +178,10 @@ xf86OpenSerial (pointer options)
 	{

 		SYSCALL (close (fd));

 		free(dev);

-		return (-1);

+		return -1;

 	}

 	free(dev);

-	return (fd);

+	return fd;

 }

 

 int

@@ -212,7 +212,7 @@ xf86SetSerial (int fd, pointer options)
 		{

 			xf86Msg (X_ERROR,

 				 "Invalid Option BaudRate value: %d\n", val);

-			return (-1);

+			return -1;

 		}

 	}

 

@@ -229,7 +229,7 @@ xf86SetSerial (int fd, pointer options)
 		default:

 			xf86Msg (X_ERROR,

 				 "Invalid Option StopBits value: %d\n", val);

-			return (-1);

+			return -1;

 			break;

 		}

 	}

@@ -257,7 +257,7 @@ xf86SetSerial (int fd, pointer options)
 		default:

 			xf86Msg (X_ERROR,

 				 "Invalid Option DataBits value: %d\n", val);

-			return (-1);

+			return -1;

 			break;

 		}

 	}

@@ -281,7 +281,7 @@ xf86SetSerial (int fd, pointer options)
 		{

 			xf86Msg (X_ERROR, "Invalid Option Parity value: %s\n",

 				 s);

-			return (-1);

+			return -1;

 		}

 	}

 

@@ -317,7 +317,7 @@ xf86SetSerial (int fd, pointer options)
 		{

 			xf86Msg (X_ERROR,

 				 "Invalid Option FlowControl value: %s\n", s);

-			return (-1);

+			return -1;

 		}

 	}

 

@@ -333,7 +333,7 @@ xf86SetSerial (int fd, pointer options)
 #else

 		xf86Msg (X_WARNING,

 			 "Option ClearDTR not supported on this OS\n");

-			return (-1);

+			return -1;

 #endif

 		xf86MarkOptionUsedByName (options, "ClearDTR");

 	}

@@ -342,12 +342,12 @@ xf86SetSerial (int fd, pointer options)
 	{

 		xf86Msg (X_WARNING,

 			 "Option ClearRTS not supported on this OS\n");

-			return (-1);

+			return -1;

 		xf86MarkOptionUsedByName (options, "ClearRTS");

 	}

 

 	SYSCALL (r = tcsetattr (fd, TCSANOW, &t));

-	return (r);

+	return r;

 }

 

 int

@@ -374,11 +374,11 @@ xf86SetSerialSpeed (int fd, int speed)
 	{

 		xf86Msg (X_ERROR,

 			 "Invalid Option BaudRate value: %d\n", speed);

-		return (-1);

+		return -1;

 	}

 

 	SYSCALL (r = tcsetattr (fd, TCSANOW, &t));

-	return (r);

+	return r;

 }

 

 int

@@ -393,7 +393,7 @@ xf86ReadSerial (int fd, void *buf, int count)
 	for (i = 1; i < r; i++)

 	    DebugF(", 0x%x",(unsigned char)*(((unsigned char *)buf) + i));

 	DebugF("\n");

-	return (r);

+	return r;

 }

 

 int

@@ -407,7 +407,7 @@ xf86WriteSerial (int fd, const void *buf, int count)
 	    ErrorF(", 0x%x",(unsigned char)*(((unsigned char *)buf) + i));

 	DebugF("\n");

 	SYSCALL (r = write (fd, buf, count));

-	return (r);

+	return r;

 }

 

 int

@@ -416,7 +416,7 @@ xf86CloseSerial (int fd)
 	int r;

 

 	SYSCALL (r = close (fd));

-	return (r);

+	return r;

 }

 

 int

@@ -442,7 +442,7 @@ xf86WaitForInput (int fd, int timeout)
 	    SYSCALL (r = select (FD_SETSIZE, NULL, NULL, NULL, &to));

 	}

 	xf86ErrorFVerb (9,"select returned %d\n", r);

-	return (r);

+	return r;

 }

 

 int

@@ -451,7 +451,7 @@ xf86SerialSendBreak (int fd, int duration)
 	int r;

 

 	SYSCALL (r = tcsendbreak (fd, duration));

-	return (r);

+	return r;

 	

 }

 

diff --git a/xorg-server/hw/xfree86/os-support/solaris/sun_VTsw.c b/xorg-server/hw/xfree86/os-support/solaris/sun_VTsw.c
index ee5c7c064..e297f8c49 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/sun_VTsw.c
+++ b/xorg-server/hw/xfree86/os-support/solaris/sun_VTsw.c
@@ -66,7 +66,7 @@ xf86VTAcquire(int sig)
 Bool

 xf86VTSwitchPending(void)

 {

-    return(xf86Info.vtRequestsPending ? TRUE : FALSE);

+    return xf86Info.vtRequestsPending ? TRUE : FALSE;

 }

 

 Bool

@@ -81,7 +81,7 @@ xf86VTSwitchAway(void)
 	if (xf86VTPruneDoor) {

 		xf86VTPruneDoor = 0;

 		ioctl(xf86Info.consoleFd, VT_RELDISP, 1);

-		return (TRUE);

+		return TRUE;

 	}

 

 	vt_door_arg.vt_ev = VT_EV_HOTKEYS;

@@ -94,15 +94,15 @@ xf86VTSwitchAway(void)
 	door_arg.desc_num = 0;

 

 	if ((door_fd = open(VT_DAEMON_DOOR_FILE, O_RDONLY)) < 0)

-		return (FALSE);

+		return FALSE;

 

 	if (door_call(door_fd, &door_arg) != 0) {

 		close(door_fd);

-		return (FALSE);

+		return FALSE;

 	}

 

 	close(door_fd);

-	return (TRUE);

+	return TRUE;

 }

 

 Bool

@@ -111,11 +111,11 @@ xf86VTSwitchTo(void)
 	xf86Info.vtRequestsPending = FALSE;

 	if (ioctl(xf86Info.consoleFd, VT_RELDISP, VT_ACKACQ) < 0)

 	{

-		return(FALSE);

+		return FALSE;

 	}

 	else

 	{

-		return(TRUE);

+		return TRUE;

 	}

 }

 

@@ -125,13 +125,13 @@ xf86VTActivate(int vtno)
 	struct vt_stat state;

 

 	if (ioctl(xf86Info.consoleFd, VT_GETSTATE, &state) < 0)

-		return(FALSE);

+		return FALSE;

 

 	if ((state.v_state & (1 << vtno)) == 0)

-		return(FALSE);

+		return FALSE;

 

 	xf86Info.vtRequestsPending = TRUE;

 	xf86Info.vtPendingNum = vtno;

 

-	return(TRUE);

+	return TRUE;

 }

diff --git a/xorg-server/hw/xfree86/os-support/solaris/sun_agp.c b/xorg-server/hw/xfree86/os-support/solaris/sun_agp.c
index a5fb5c6e6..b85a3c86b 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/sun_agp.c
+++ b/xorg-server/hw/xfree86/os-support/solaris/sun_agp.c
@@ -78,7 +78,7 @@ static Bool
 GARTInit(int screenNum)

 {

 	if (initDone)

-		return (gartFd != -1);

+		return gartFd != -1;

 

 	if (gartFd == -1)

 		gartFd = open(AGP_DEVICE, O_RDWR);

@@ -115,16 +115,16 @@ xf86GetAGPInfo(int screenNum)
 	if (!GARTInit(screenNum))

 		return NULL;

 

-	if ((info = calloc(sizeof(AgpInfo), 1)) == NULL) {

+	if (ioctl(gartFd, AGPIOC_INFO, &agpinf) != 0) {

 		xf86DrvMsg(screenNum, X_ERROR,

-		    "xf86GetAGPInfo: Failed to allocate AgpInfo\n");

+		    "xf86GetAGPInfo: AGPIOC_INFO failed (%s)\n",

+		    strerror(errno));

 		return NULL;

 	}

 

-	if (ioctl(gartFd, AGPIOC_INFO, &agpinf) != 0) {

+	if ((info = calloc(sizeof(AgpInfo), 1)) == NULL) {

 		xf86DrvMsg(screenNum, X_ERROR,

-		    "xf86GetAGPInfo: AGPIOC_INFO failed (%s)\n",

-		    strerror(errno));

+		    "xf86GetAGPInfo: Failed to allocate AgpInfo\n");

 		return NULL;

 	}

 

diff --git a/xorg-server/hw/xfree86/os-support/solaris/sun_bell.c b/xorg-server/hw/xfree86/os-support/solaris/sun_bell.c
index 05d17492a..e064c9733 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/sun_bell.c
+++ b/xorg-server/hw/xfree86/os-support/solaris/sun_bell.c
@@ -1,180 +1,180 @@
-/* Copyright 2004-2005 Sun Microsystems, Inc.  All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <sys/audio.h>
-#include <sys/uio.h>
-#include <limits.h>
-#include <math.h>
-#include <poll.h>
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-
-#define BELL_RATE       48000   /* Samples per second */
-#define BELL_HZ         50      /* Fraction of a second i.e. 1/x */
-#define BELL_MS         (1000/BELL_HZ)  /* MS */
-#define BELL_SAMPLES    (BELL_RATE / BELL_HZ)
-#define BELL_MIN        3       /* Min # of repeats */
-
-#define AUDIO_DEVICE    "/dev/audio"
-
-void
-xf86OSRingBell(int loudness, int pitch, int duration)
-{
-    static short    samples[BELL_SAMPLES];
-    static short    silence[BELL_SAMPLES]; /* "The Sound of Silence" */
-    static int      lastFreq;
-    int             cnt; 
-    int             i;
-    int             written;
-    int             repeats;
-    int             freq;
-    audio_info_t    audioInfo;
-    struct iovec    iov[IOV_MAX];
-    int             iovcnt;
-    double          ampl, cyclen, phase;
-    int             audioFD;
-
-    if ((loudness <= 0) || (pitch <= 0) || (duration <= 0)) {
-        return;
-    }
-
-    lastFreq = 0;
-    bzero(silence, sizeof(silence));
-
-    audioFD = open(AUDIO_DEVICE, O_WRONLY | O_NONBLOCK);
-    if (audioFD == -1) {
-        xf86Msg(X_ERROR, "Bell: cannot open audio device \"%s\": %s\n",
-                AUDIO_DEVICE, strerror(errno));
-        return;
-    }
-
-    freq = pitch;
-    freq = min(freq, (BELL_RATE / 2) - 1);
-    freq = max(freq, 2 * BELL_HZ);
-
-    /*
-     * Ensure full waves per buffer
-     */
-    freq -= freq % BELL_HZ;
-
-    if (freq != lastFreq) {
-        lastFreq = freq;
-        ampl =  16384.0;
-
-        cyclen = (double) freq / (double) BELL_RATE;
-        phase = 0.0;
-
-        for (i = 0; i < BELL_SAMPLES; i++) {
-            samples[i] = (short) (ampl * sin(2.0 * M_PI * phase));
-            phase += cyclen;
-            if (phase >= 1.0)
-                phase -= 1.0;
-        }
-    }
-
-    repeats = (duration + (BELL_MS / 2)) / BELL_MS;
-    repeats = max(repeats, BELL_MIN);
-
-    loudness = max(0, loudness);
-    loudness = min(loudness, 100);
-
-#ifdef DEBUG
-    ErrorF("BELL : freq %d volume %d duration %d repeats %d\n",
-           freq, loudness, duration, repeats);
-#endif
-
-    AUDIO_INITINFO(&audioInfo);
-    audioInfo.play.encoding = AUDIO_ENCODING_LINEAR;
-    audioInfo.play.sample_rate = BELL_RATE;
-    audioInfo.play.channels = 2;
-    audioInfo.play.precision = 16;
-    audioInfo.play.gain = min(AUDIO_MAX_GAIN, AUDIO_MAX_GAIN * loudness / 100);
-
-    if (ioctl(audioFD, AUDIO_SETINFO, &audioInfo) < 0){
-        xf86Msg(X_ERROR,
-                "Bell: AUDIO_SETINFO failed on audio device \"%s\": %s\n",
-                AUDIO_DEVICE, strerror(errno));
-        close(audioFD);
-        return;
-    }
-
-    iovcnt = 0;
-
-    for (cnt = 0; cnt <= repeats; cnt++) {
-        if (cnt == repeats) {
-            /* Insert a bit of silence so that multiple beeps are distinct and
-             * not compressed into a single tone.
-             */
-            iov[iovcnt].iov_base = (char *) silence;
-            iov[iovcnt++].iov_len = sizeof(silence);
-        } else {
-            iov[iovcnt].iov_base = (char *) samples;
-            iov[iovcnt++].iov_len = sizeof(samples);
-        }
-        if ((iovcnt >= IOV_MAX) || (cnt == repeats)) {
-            written = writev(audioFD, iov, iovcnt);
-
-            if ((written < ((int)(sizeof(samples) * iovcnt)))) {
-                /* audio buffer was full! */
-
-                int naptime;
-
-                if (written == -1) {
-                    if (errno != EAGAIN) {
-                        xf86Msg(X_ERROR,
-                               "Bell: writev failed on audio device \"%s\": %s\n",
-                                AUDIO_DEVICE, strerror(errno));
-                        close(audioFD);
-                        return;
-                    }
-                    i = iovcnt;
-                } else {
-                    i = ((sizeof(samples) * iovcnt) - written)
-                        / sizeof(samples);
-                }
-                cnt -= i;
-
-                /* sleep a little to allow audio buffer to drain */
-                naptime = BELL_MS * i;
-                poll(NULL, 0, naptime);
-
-                i = ((sizeof(samples) * iovcnt) - written) % sizeof(samples);
-                iovcnt = 0;
-                if ((written != -1) && (i > 0)) {
-                    iov[iovcnt].iov_base = ((char *) samples) + i;
-                    iov[iovcnt++].iov_len = sizeof(samples) - i;
-                }
-            } else {
-                iovcnt = 0;
-            }
-        }
-    }
-
-    close(audioFD);
-    return;
-}
+/* Copyright 2004-2005 Sun Microsystems, Inc.  All rights reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

+ * DEALINGS IN THE SOFTWARE.

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <sys/audio.h>

+#include <sys/uio.h>

+#include <limits.h>

+#include <math.h>

+#include <poll.h>

+

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86_OSlib.h"

+

+#define BELL_RATE       48000   /* Samples per second */

+#define BELL_HZ         50      /* Fraction of a second i.e. 1/x */

+#define BELL_MS         (1000/BELL_HZ)  /* MS */

+#define BELL_SAMPLES    (BELL_RATE / BELL_HZ)

+#define BELL_MIN        3       /* Min # of repeats */

+

+#define AUDIO_DEVICE    "/dev/audio"

+

+void

+xf86OSRingBell(int loudness, int pitch, int duration)

+{

+    static short    samples[BELL_SAMPLES];

+    static short    silence[BELL_SAMPLES]; /* "The Sound of Silence" */

+    static int      lastFreq;

+    int             cnt; 

+    int             i;

+    int             written;

+    int             repeats;

+    int             freq;

+    audio_info_t    audioInfo;

+    struct iovec    iov[IOV_MAX];

+    int             iovcnt;

+    double          ampl, cyclen, phase;

+    int             audioFD;

+

+    if ((loudness <= 0) || (pitch <= 0) || (duration <= 0)) {

+        return;

+    }

+

+    lastFreq = 0;

+    memset(silence, 0, sizeof(silence));

+

+    audioFD = open(AUDIO_DEVICE, O_WRONLY | O_NONBLOCK);

+    if (audioFD == -1) {

+        xf86Msg(X_ERROR, "Bell: cannot open audio device \"%s\": %s\n",

+                AUDIO_DEVICE, strerror(errno));

+        return;

+    }

+

+    freq = pitch;

+    freq = min(freq, (BELL_RATE / 2) - 1);

+    freq = max(freq, 2 * BELL_HZ);

+

+    /*

+     * Ensure full waves per buffer

+     */

+    freq -= freq % BELL_HZ;

+

+    if (freq != lastFreq) {

+        lastFreq = freq;

+        ampl =  16384.0;

+

+        cyclen = (double) freq / (double) BELL_RATE;

+        phase = 0.0;

+

+        for (i = 0; i < BELL_SAMPLES; i++) {

+            samples[i] = (short) (ampl * sin(2.0 * M_PI * phase));

+            phase += cyclen;

+            if (phase >= 1.0)

+                phase -= 1.0;

+        }

+    }

+

+    repeats = (duration + (BELL_MS / 2)) / BELL_MS;

+    repeats = max(repeats, BELL_MIN);

+

+    loudness = max(0, loudness);

+    loudness = min(loudness, 100);

+

+#ifdef DEBUG

+    ErrorF("BELL : freq %d volume %d duration %d repeats %d\n",

+           freq, loudness, duration, repeats);

+#endif

+

+    AUDIO_INITINFO(&audioInfo);

+    audioInfo.play.encoding = AUDIO_ENCODING_LINEAR;

+    audioInfo.play.sample_rate = BELL_RATE;

+    audioInfo.play.channels = 2;

+    audioInfo.play.precision = 16;

+    audioInfo.play.gain = min(AUDIO_MAX_GAIN, AUDIO_MAX_GAIN * loudness / 100);

+

+    if (ioctl(audioFD, AUDIO_SETINFO, &audioInfo) < 0){

+        xf86Msg(X_ERROR,

+                "Bell: AUDIO_SETINFO failed on audio device \"%s\": %s\n",

+                AUDIO_DEVICE, strerror(errno));

+        close(audioFD);

+        return;

+    }

+

+    iovcnt = 0;

+

+    for (cnt = 0; cnt <= repeats; cnt++) {

+        if (cnt == repeats) {

+            /* Insert a bit of silence so that multiple beeps are distinct and

+             * not compressed into a single tone.

+             */

+            iov[iovcnt].iov_base = (char *) silence;

+            iov[iovcnt++].iov_len = sizeof(silence);

+        } else {

+            iov[iovcnt].iov_base = (char *) samples;

+            iov[iovcnt++].iov_len = sizeof(samples);

+        }

+        if ((iovcnt >= IOV_MAX) || (cnt == repeats)) {

+            written = writev(audioFD, iov, iovcnt);

+

+            if ((written < ((int)(sizeof(samples) * iovcnt)))) {

+                /* audio buffer was full! */

+

+                int naptime;

+

+                if (written == -1) {

+                    if (errno != EAGAIN) {

+                        xf86Msg(X_ERROR,

+                               "Bell: writev failed on audio device \"%s\": %s\n",

+                                AUDIO_DEVICE, strerror(errno));

+                        close(audioFD);

+                        return;

+                    }

+                    i = iovcnt;

+                } else {

+                    i = ((sizeof(samples) * iovcnt) - written)

+                        / sizeof(samples);

+                }

+                cnt -= i;

+

+                /* sleep a little to allow audio buffer to drain */

+                naptime = BELL_MS * i;

+                poll(NULL, 0, naptime);

+

+                i = ((sizeof(samples) * iovcnt) - written) % sizeof(samples);

+                iovcnt = 0;

+                if ((written != -1) && (i > 0)) {

+                    iov[iovcnt].iov_base = ((char *) samples) + i;

+                    iov[iovcnt++].iov_len = sizeof(samples) - i;

+                }

+            } else {

+                iovcnt = 0;

+            }

+        }

+    }

+

+    close(audioFD);

+    return;

+}

diff --git a/xorg-server/hw/xfree86/os-support/sysv/sysv_init.c b/xorg-server/hw/xfree86/os-support/sysv/sysv_init.c
index 170bb8914..3b94ac135 100644
--- a/xorg-server/hw/xfree86/os-support/sysv/sysv_init.c
+++ b/xorg-server/hw/xfree86/os-support/sysv/sysv_init.c
@@ -1,252 +1,252 @@
-/*
- * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany
- * Copyright 1993 by David Wexelblat <dwex@goblin.org>
- *
- * 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 names of Thomas Roell and David Wexelblat 
- * not be used in advertising or publicity pertaining to distribution of 
- * the software without specific, written prior permission.  Thomas Roell and
- * David Wexelblat makes no representations about the suitability of this 
- * software for any purpose.  It is provided "as is" without express or 
- * implied warranty.
- *
- * THOMAS ROELL AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO 
- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
- * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR DAVID WEXELBLAT 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_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xmd.h>
-
-#include "compiler.h"
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-
-static Bool KeepTty = FALSE;
-#ifdef SVR4
-static Bool Protect0 = FALSE;
-#endif
-static int VTnum = -1;
-
-
-void
-xf86OpenConsole()
-{
-    int fd;
-    struct vt_mode VT;
-    char vtname1[10],vtname2[10];
-    MessageType from = X_PROBED;
-
-    if (serverGeneration == 1) 
-    {
-    	/* check if we're run with euid==0 */
-    	if (geteuid() != 0)
-	{
-      	    FatalError("xf86OpenConsole: Server must be suid root\n");
-	}
-
-#ifdef SVR4
-	/* Protect page 0 to help find NULL dereferencing */
-	/* mprotect() doesn't seem to work */
-	if (Protect0)
-	{
-	    int fd = -1;
-
-	    if ((fd = open("/dev/zero", O_RDONLY, 0)) < 0)
-	    {
-		xf86Msg(X_WARNING,
-			"xf86OpenConsole: cannot open /dev/zero (%s)\n",
-			strerror(errno));
-	    }
-	    else
-	    {
-		if ((int)mmap(0, 0x1000, PROT_NONE,
-			      MAP_FIXED | MAP_SHARED, fd, 0) == -1)
-		{
-		    xf86Msg(X_WARNING,
-			"xf86OpenConsole: failed to protect page 0 (%s)\n",
-			strerror(errno));
-		}
-		close(fd);
-	    }
-	}
-#endif
-    	/*
-     	 * setup the virtual terminal manager
-     	 */
-    	if (VTnum != -1) 
-	{
-      	    xf86Info.vtno = VTnum;
-	    from = X_CMDLINE;
-    	}
-    	else 
-	{
-      	    if ((fd = open("/dev/console",O_WRONLY,0)) < 0) 
-	    {
-        	FatalError(
-		    "xf86OpenConsole: Cannot open /dev/console (%s)\n",
-		    strerror(errno));
-	    }
-      	    if ((ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0) || 
-		(xf86Info.vtno == -1))
-	    {
-        	FatalError("xf86OpenConsole: Cannot find a free VT\n");
-	    }
-           close(fd);
-        }
-	xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno);
-
-	sprintf(vtname1,"/dev/vc%02d",xf86Info.vtno); /* ESIX */
-	sprintf(vtname2,"/dev/vt%02d",xf86Info.vtno); /* rest of the world */
-
-	if (!KeepTty)
-    	{
-    	    setpgrp();
-	}
-
-	if (((xf86Info.consoleFd = open(vtname1, O_RDWR|O_NDELAY, 0)) < 0) &&
-	    ((xf86Info.consoleFd = open(vtname2, O_RDWR|O_NDELAY, 0)) < 0))
-	{
-            FatalError("xf86OpenConsole: Cannot open %s (%s) (%s)\n",
-		       vtname2, vtname1, strerror(errno));
-	}
-
-	/* change ownership of the vt */
-	if (chown(vtname1, getuid(), getgid()) < 0)
-	{
-            chown(vtname2, getuid(), getgid());
-	}
-
-	/*
-	 * now get the VT
-	 */
-	if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0)
-	{
-    	    xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");
-	}
-	if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) != 0)
-	{
-	    xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed\n");
-	}
-	if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0) 
-	{
-	    FatalError("xf86OpenConsole: VT_GETMODE failed\n");
-	}
-
-	signal(SIGUSR1, xf86VTRequest);
-
-	VT.mode = VT_PROCESS;
-	VT.relsig = SIGUSR1;
-	VT.acqsig = SIGUSR1;
-	if (ioctl(xf86Info.consoleFd, VT_SETMODE, &VT) < 0) 
-	{
-	    FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed\n");
-	}
-	if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0)
-	{
-	    FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed\n");
-	}
-    }
-    else 
-    {   
-	/* serverGeneration != 1 */
-	/*
-	 * now get the VT
-	 */
-	if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0)
-	{
-	    xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");
-	}
-	if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) != 0)
-	{
-      	    xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed\n");
-	}
-	/*
-	 * If the server doesn't have the VT when the reset occurs,
-	 * this is to make sure we don't continue until the activate
-	 * signal is received.
-	 */
-	if (!xf86Screens[0]->vtSema)
-	    sleep(5);
-    }
-    return;
-}
-
-void
-xf86CloseConsole()
-{
-    struct vt_mode   VT;
-
-#if 0
-    ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno);
-    ioctl(xf86Info.consoleFd, VT_WAITACTIVE, 0);
-#endif
-    ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT);  /* Back to text mode ... */
-    if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) != -1)
-    {
-	VT.mode = VT_AUTO;
-	ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* set dflt vt handling */
-    }
-    close(xf86Info.consoleFd);                 /* make the vt-manager happy */
-    return;
-}
-
-int
-xf86ProcessArgument(int argc, char *argv[], int i)
-{
-	/*
-	 * Keep server from detaching from controlling tty.  This is useful 
-	 * when debugging (so the server can receive keyboard signals.
-	 */
-	if (!strcmp(argv[i], "-keeptty"))
-	{
-		KeepTty = TRUE;
-		return(1);
-	}
-#ifdef SVR4
-	/*
-	 * Undocumented flag to protect page 0 from read/write to help
-	 * catch NULL pointer dereferences.  This is purely a debugging
-	 * flag.
-	 */
-	if (!strcmp(argv[i], "-protect0"))
-	{
-		Protect0 = TRUE;
-		return(1);
-	}
-#endif
-	if ((argv[i][0] == 'v') && (argv[i][1] == 't'))
-	{
-		if (sscanf(argv[i], "vt%2d", &VTnum) == 0)
-		{
-			UseMsg();
-			VTnum = -1;
-			return(0);
-		}
-		return(1);
-	}
-	return(0);
-}
-
-void
-xf86UseMsg()
-{
-	ErrorF("vtXX                   use the specified VT number\n");
-	ErrorF("-keeptty               ");
-	ErrorF("don't detach controlling tty (for debugging only)\n");
-	return;
-}
+/*

+ * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany

+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>

+ *

+ * 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 names of Thomas Roell and David Wexelblat 

+ * not be used in advertising or publicity pertaining to distribution of 

+ * the software without specific, written prior permission.  Thomas Roell and

+ * David Wexelblat makes no representations about the suitability of this 

+ * software for any purpose.  It is provided "as is" without express or 

+ * implied warranty.

+ *

+ * THOMAS ROELL AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO 

+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

+ * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR DAVID WEXELBLAT 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_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+#include <X11/Xmd.h>

+

+#include "compiler.h"

+

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86_OSlib.h"

+

+static Bool KeepTty = FALSE;

+#ifdef SVR4

+static Bool Protect0 = FALSE;

+#endif

+static int VTnum = -1;

+

+

+void

+xf86OpenConsole()

+{

+    int fd;

+    struct vt_mode VT;

+    char vtname1[10],vtname2[10];

+    MessageType from = X_PROBED;

+

+    if (serverGeneration == 1) 

+    {

+    	/* check if we're run with euid==0 */

+    	if (geteuid() != 0)

+	{

+      	    FatalError("xf86OpenConsole: Server must be suid root\n");

+	}

+

+#ifdef SVR4

+	/* Protect page 0 to help find NULL dereferencing */

+	/* mprotect() doesn't seem to work */

+	if (Protect0)

+	{

+	    int fd = -1;

+

+	    if ((fd = open("/dev/zero", O_RDONLY, 0)) < 0)

+	    {

+		xf86Msg(X_WARNING,

+			"xf86OpenConsole: cannot open /dev/zero (%s)\n",

+			strerror(errno));

+	    }

+	    else

+	    {

+		if ((int)mmap(0, 0x1000, PROT_NONE,

+			      MAP_FIXED | MAP_SHARED, fd, 0) == -1)

+		{

+		    xf86Msg(X_WARNING,

+			"xf86OpenConsole: failed to protect page 0 (%s)\n",

+			strerror(errno));

+		}

+		close(fd);

+	    }

+	}

+#endif

+    	/*

+     	 * setup the virtual terminal manager

+     	 */

+    	if (VTnum != -1) 

+	{

+      	    xf86Info.vtno = VTnum;

+	    from = X_CMDLINE;

+    	}

+    	else 

+	{

+      	    if ((fd = open("/dev/console",O_WRONLY,0)) < 0) 

+	    {

+        	FatalError(

+		    "xf86OpenConsole: Cannot open /dev/console (%s)\n",

+		    strerror(errno));

+	    }

+      	    if ((ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0) || 

+		(xf86Info.vtno == -1))

+	    {

+        	FatalError("xf86OpenConsole: Cannot find a free VT\n");

+	    }

+           close(fd);

+        }

+	xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno);

+

+	sprintf(vtname1,"/dev/vc%02d",xf86Info.vtno); /* ESIX */

+	sprintf(vtname2,"/dev/vt%02d",xf86Info.vtno); /* rest of the world */

+

+	if (!KeepTty)

+    	{

+    	    setpgrp();

+	}

+

+	if (((xf86Info.consoleFd = open(vtname1, O_RDWR|O_NDELAY, 0)) < 0) &&

+	    ((xf86Info.consoleFd = open(vtname2, O_RDWR|O_NDELAY, 0)) < 0))

+	{

+            FatalError("xf86OpenConsole: Cannot open %s (%s) (%s)\n",

+		       vtname2, vtname1, strerror(errno));

+	}

+

+	/* change ownership of the vt */

+	if (chown(vtname1, getuid(), getgid()) < 0)

+	{

+            chown(vtname2, getuid(), getgid());

+	}

+

+	/*

+	 * now get the VT

+	 */

+	if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0)

+	{

+    	    xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");

+	}

+	if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) != 0)

+	{

+	    xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed\n");

+	}

+	if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0) 

+	{

+	    FatalError("xf86OpenConsole: VT_GETMODE failed\n");

+	}

+

+	signal(SIGUSR1, xf86VTRequest);

+

+	VT.mode = VT_PROCESS;

+	VT.relsig = SIGUSR1;

+	VT.acqsig = SIGUSR1;

+	if (ioctl(xf86Info.consoleFd, VT_SETMODE, &VT) < 0) 

+	{

+	    FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed\n");

+	}

+	if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0)

+	{

+	    FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed\n");

+	}

+    }

+    else 

+    {   

+	/* serverGeneration != 1 */

+	/*

+	 * now get the VT

+	 */

+	if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0)

+	{

+	    xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");

+	}

+	if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) != 0)

+	{

+      	    xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed\n");

+	}

+	/*

+	 * If the server doesn't have the VT when the reset occurs,

+	 * this is to make sure we don't continue until the activate

+	 * signal is received.

+	 */

+	if (!xf86Screens[0]->vtSema)

+	    sleep(5);

+    }

+    return;

+}

+

+void

+xf86CloseConsole()

+{

+    struct vt_mode   VT;

+

+#if 0

+    ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno);

+    ioctl(xf86Info.consoleFd, VT_WAITACTIVE, 0);

+#endif

+    ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT);  /* Back to text mode ... */

+    if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) != -1)

+    {

+	VT.mode = VT_AUTO;

+	ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* set dflt vt handling */

+    }

+    close(xf86Info.consoleFd);                 /* make the vt-manager happy */

+    return;

+}

+

+int

+xf86ProcessArgument(int argc, char *argv[], int i)

+{

+	/*

+	 * Keep server from detaching from controlling tty.  This is useful 

+	 * when debugging (so the server can receive keyboard signals.

+	 */

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

+	{

+		KeepTty = TRUE;

+		return 1;

+	}

+#ifdef SVR4

+	/*

+	 * Undocumented flag to protect page 0 from read/write to help

+	 * catch NULL pointer dereferences.  This is purely a debugging

+	 * flag.

+	 */

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

+	{

+		Protect0 = TRUE;

+		return 1;

+	}

+#endif

+	if ((argv[i][0] == 'v') && (argv[i][1] == 't'))

+	{

+		if (sscanf(argv[i], "vt%2d", &VTnum) == 0)

+		{

+			UseMsg();

+			VTnum = -1;

+			return 0;

+		}

+		return 1;

+	}

+	return 0;

+}

+

+void

+xf86UseMsg()

+{

+	ErrorF("vtXX                   use the specified VT number\n");

+	ErrorF("-keeptty               ");

+	ErrorF("don't detach controlling tty (for debugging only)\n");

+	return;

+}

diff --git a/xorg-server/hw/xfree86/os-support/sysv/sysv_video.c b/xorg-server/hw/xfree86/os-support/sysv/sysv_video.c
index 43c30621c..6d5948796 100644
--- a/xorg-server/hw/xfree86/os-support/sysv/sysv_video.c
+++ b/xorg-server/hw/xfree86/os-support/sysv/sysv_video.c
@@ -1,315 +1,315 @@
-/*
- * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany
- * Copyright 1993 by David Wexelblat <dwex@goblin.org>
- *
- * 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 names of Thomas Roell and David Wexelblat 
- * not be used in advertising or publicity pertaining to distribution of 
- * the software without specific, written prior permission.  Thomas Roell and
- * David Wexelblat makes no representations about the suitability of this 
- * software for any purpose.  It is provided "as is" without express or 
- * implied warranty.
- *
- * THOMAS ROELL AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO 
- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
- * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR DAVID WEXELBLAT 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_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-
-#define _NEED_SYSI86
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-#include "xf86OSpriv.h"
-
-#ifndef MAP_FAILED
-#define MAP_FAILED ((void *)-1)
-#endif
-
-#ifndef SI86IOPL
-#define SET_IOPL() sysi86(SI86V86,V86SC_IOPL,PS_IOPL)
-#define RESET_IOPL() sysi86(SI86V86,V86SC_IOPL,0)
-#else
-#define SET_IOPL() sysi86(SI86IOPL,3)
-#define RESET_IOPL() sysi86(SI86IOPL,0)
-#endif
-
-/***************************************************************************/
-/* Video Memory Mapping section                                            */
-/***************************************************************************/
-
-/*
- * XXX Support for SVR3 will need to be reworked if needed.  In particular
- * the Region parameter is no longer passed, and will need to be dealt
- * with internally if required.
- * OK, i'll rework that thing ... (clean it up a lot)
- * SVR3 Support only with SVR3_MMAPDRV (mr)
- * 
- */
-
-#ifdef HAS_SVR3_MMAPDRV
-#ifndef MMAP_DEBUG
-#define MMAP_DEBUG	3
-#endif
-
-struct kd_memloc MapDSC;
-int mmapFd = -2;
-
-static int
-mmapStat(pointer Base, unsigned long Size) {
-
-	int nmmreg,i=0,region=-1;
-	mmapinfo_t *ibuf;
-
-	nmmreg = ioctl(mmapFd, GETNMMREG);
-
-	if(nmmreg <= 0)
-	   xf86MsgVerb(X_INFO, MMAP_DEBUG,
-			  "\nNo physical memory mapped currently.\n\n");
-	else {
-	  if((ibuf = (mmapinfo_t *)malloc(nmmreg*sizeof(mmapinfo_t))) == NULL) 
-		xf86Msg(X_WARNING,
-			  "Couldn't allocate memory 4 mmapinfo_t\n");
-	  else {
-	     if(ioctl(mmapFd, GETMMREG, ibuf) != -1)
-		{ 
-		   xf86MsgVerb(X_INFO, MMAP_DEBUG,
-				"# mmapStat: [Size=%x,Base=%x]\n", Size, Base);
-		   xf86MsgVerb(X_INFO, MMAP_DEBUG,
-		     "#      Physical Address     Size      Reference Count\n");
-		for(i = 0; i < nmmreg; i++) {
-		   xf86MsgVerb(X_INFO, MMAP_DEBUG,
-                      "%-4d   0x%08X         %5dk                %5d	",
-          	      i, ibuf[i].physaddr, ibuf[i].length/1024, ibuf[i].refcnt);
-		   if (ibuf[i].physaddr == Base || ibuf[i].length == Size ) {
-			xf86MsgVerb(X_INFO, MMAP_DEBUG,"MATCH !!!");
-			if (region==-1) region=i;
-                      }
-		   xf86ErrorFVerb(MMAP_DEBUG, "\n");
-		}
-		xf86ErrorFVerb(MMAP_DEBUG, "\n");
-		}
-	     free(ibuf);
-	   }
-	}
-	if (region == -1 && nmmreg > 0) region=region * i;
-	return(region);
-}
-#endif
-
-
-static Bool
-linearVidMem()
-{
-#ifdef SVR4
-	return TRUE;
-#elif defined(HAS_SVR3_MMAPDRV)
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-		    "# xf86LinearVidMem: MMAP 2.2.2 called\n");
-
-	if(mmapFd >= 0) return TRUE;
-
-	if ((mmapFd = open("/dev/mmap", O_RDWR)) != -1)
-	{
-	    if(ioctl(mmapFd, GETVERSION) < 0x0222) {
-		xf86Msg(X_WARNING,
-			"xf86LinearVidMem: MMAP 2.2.2 or above required\n");
-		xf86ErrorF("\tlinear memory access disabled\n");
-		return FALSE;
-	    }
-	    return TRUE;
-	}
-	xf86Msg(X_WARNING, "xf86LinearVidMem: failed to open /dev/mmap (%s)\n",
-	        strerror(errno));
-	xf86ErrorF("\tlinear memory access disabled\n");
-	return FALSE;
-#endif
-}
-
-static pointer
-mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
-{
-	pointer base;
-	int fd;
-
-#if defined(SVR4)
-	fd = open(DEV_MEM, (flags & VIDMEM_READONLY) ? O_RDONLY : O_RDWR);
-	if (fd < 0)
-	{
-		FatalError("xf86MapVidMem: failed to open %s (%s)\n",
-			   DEV_MEM, strerror(errno));
-	}
-	base = mmap((caddr_t)0, Size,
-		    (flags & VIDMEM_READONLY) ?
-		     PROT_READ : (PROT_READ | PROT_WRITE),
-		    MAP_SHARED, fd, (off_t)Base);
-	close(fd);
-	if (base == MAP_FAILED)
-	{
-		FatalError("%s: Could not mmap framebuffer [s=%x,a=%x] (%s)\n",
-			   "xf86MapVidMem", Size, Base, strerror(errno));
-	}
-#else /* SVR4 */
-#ifdef HAS_SVR3_MMAPDRV
-
-	xf86MsgVerb(X_INFO, MMAP_DEBUG, "# xf86MapVidMem: MMAP 2.2.2 called\n");
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-			"MMAP_VERSION: 0x%x\n",ioctl(mmapFd, GETVERSION));
-	if (ioctl(mmapFd, GETVERSION) == -1)
-	{
-		xf86LinearVidMem();
-	}
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-			"MMAP_VERSION: 0x%x\n",ioctl(mmapFd, GETVERSION));
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-		"xf86MapVidMem: Screen: %d\n", ScreenNum);
-	mmapStat(Base,Size);
-	/* To force the MMAP driver to provide the address */
-	base = (pointer)0;
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-			"xf86MapVidMem: [s=%x,a=%x]\n", Size, Base);
-	MapDSC.vaddr    = (char *)base;
-	MapDSC.physaddr = (char *)Base;
-	MapDSC.length   = Size;
-	MapDSC.ioflg    = 1;
-	if(mmapFd >= 0)
-	{
-	    if((base = (pointer)ioctl(mmapFd, MAP, &MapDSC)) == (pointer)-1)
-	    {
-		FatalError("%s: Could not mmap framebuffer [s=%x,a=%x] (%s)\n",
-			   "xf86MapVidMem", Size, Base, strerror(errno));
-		/* NOTREACHED */
-	    }
-
-	    /* Next time we want the same address! */
-	    MapDSC.vaddr    = (char *)base;
-	}
-
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-			"MapDSC.vaddr   : 0x%x\n", MapDSC.vaddr);
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-			"MapDSC.physaddr: 0x%x\n", MapDSC.physaddr);
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-			"MapDSC.length  : %d\n", MapDSC.length);
-	mmapStat(Base,Size);
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-			"xf86MapVidMem: [s=%x,a=%x,b=%x]\n", Size, Base, base);
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-			"xf86MapVidMem: SUCCEED Mapping FrameBuffer \n");
-#endif /* HAS_SVR3_MMAPDRV */
-#endif /* SVR4 */
-	return(base);
-}
-
-/* ARGSUSED */
-static void
-unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
-{
-#if defined (SVR4)
-	munmap(Base, Size);
-#else /* SVR4 */
-#ifdef HAS_SVR3_MMAPDRV
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-	        "# xf86UnMapVidMem: UNMapping FrameBuffer\n");
-	mmapStat(Base,Size);
-	ioctl(mmapFd, UNMAPRM , Base);
-	mmapStat(Base,Size);
-	xf86MsgVerb(X_INFO, MMAP_DEBUG,
-		"# xf86UnMapVidMem: Screen: %d [v=%x]\n", ScreenNum, Base);
-#endif /* HAS_SVR3_MMAPDRV */
-#endif /* SVR4 */
-	return;
-}
-
-#if defined(SVR4) && defined(__i386__) && !defined(sun)
-/*
- * For some SVR4 versions, a 32-bit read is done for the first location
- * in each page when the page is first mapped.  If this is done while
- * memory access is enabled for regions that have read side-effects,
- * this can cause unexpected results, including lockups on some hardware.
- * This function is called to make sure each page is mapped while it is
- * safe to do so.
- */
-
-/*
- * XXX Should get this the correct way (see os/xalloc.c), but since this is
- * for one platform I'll be lazy.
- */
-#define X_PAGE_SIZE 4096
-
-static void
-readSideEffects(int ScreenNum, pointer Base, unsigned long Size)
-{
-	unsigned long base, end, addr;
-	CARD32 val;
-
-	base = (unsigned long)Base;
-	end = base + Size;
-
-	for (addr = base; addr < end; addr += X_PAGE_SIZE)
-		val = *(volatile CARD32 *)addr;
-}
-#endif
-
-void
-xf86OSInitVidMem(VidMemInfoPtr pVidMem)
-{
-	pVidMem->linearSupported = linearVidMem();
-	pVidMem->mapMem = mapVidMem;
-	pVidMem->unmapMem = unmapVidMem;
-#if defined(SVR4) && defined(__i386__) && !defined(sun)
-	pVidMem->readSideEffects = readSideEffects;
-#endif
-	pVidMem->initialised = TRUE;
-}
-	
-/***************************************************************************/
-/* I/O Permissions section                                                 */
-/***************************************************************************/
-
-static Bool ExtendedEnabled = FALSE;
-static Bool InitDone = FALSE;
-
-Bool
-xf86EnableIO()
-{
-	int i;
-
-	if (ExtendedEnabled)
-		return TRUE;
-
-	if (SET_IOPL() < 0)
-	{
-	    xf86Msg(X_WARNING,
-			"xf86EnableIO: Failed to set IOPL for extended I/O\n");
-	    return FALSE;
-	}
-	ExtendedEnabled = TRUE;
-
-	return TRUE;
-}
-	
-void
-xf86DisableIO()
-{
-	if (!ExtendedEnabled)
-		return;
-
-	RESET_IOPL();
-	ExtendedEnabled = FALSE;
-
-	return;
-}
+/*

+ * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany

+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>

+ *

+ * 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 names of Thomas Roell and David Wexelblat 

+ * not be used in advertising or publicity pertaining to distribution of 

+ * the software without specific, written prior permission.  Thomas Roell and

+ * David Wexelblat makes no representations about the suitability of this 

+ * software for any purpose.  It is provided "as is" without express or 

+ * implied warranty.

+ *

+ * THOMAS ROELL AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO 

+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

+ * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR DAVID WEXELBLAT 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_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+

+#define _NEED_SYSI86

+#include "xf86.h"

+#include "xf86Priv.h"

+#include "xf86_OSlib.h"

+#include "xf86OSpriv.h"

+

+#ifndef MAP_FAILED

+#define MAP_FAILED ((void *)-1)

+#endif

+

+#ifndef SI86IOPL

+#define SET_IOPL() sysi86(SI86V86,V86SC_IOPL,PS_IOPL)

+#define RESET_IOPL() sysi86(SI86V86,V86SC_IOPL,0)

+#else

+#define SET_IOPL() sysi86(SI86IOPL,3)

+#define RESET_IOPL() sysi86(SI86IOPL,0)

+#endif

+

+/***************************************************************************/

+/* Video Memory Mapping section                                            */

+/***************************************************************************/

+

+/*

+ * XXX Support for SVR3 will need to be reworked if needed.  In particular

+ * the Region parameter is no longer passed, and will need to be dealt

+ * with internally if required.

+ * OK, i'll rework that thing ... (clean it up a lot)

+ * SVR3 Support only with SVR3_MMAPDRV (mr)

+ * 

+ */

+

+#ifdef HAS_SVR3_MMAPDRV

+#ifndef MMAP_DEBUG

+#define MMAP_DEBUG	3

+#endif

+

+struct kd_memloc MapDSC;

+int mmapFd = -2;

+

+static int

+mmapStat(pointer Base, unsigned long Size) {

+

+	int nmmreg,i=0,region=-1;

+	mmapinfo_t *ibuf;

+

+	nmmreg = ioctl(mmapFd, GETNMMREG);

+

+	if(nmmreg <= 0)

+	   xf86MsgVerb(X_INFO, MMAP_DEBUG,

+			  "\nNo physical memory mapped currently.\n\n");

+	else {

+	  if((ibuf = (mmapinfo_t *)malloc(nmmreg*sizeof(mmapinfo_t))) == NULL) 

+		xf86Msg(X_WARNING,

+			  "Couldn't allocate memory 4 mmapinfo_t\n");

+	  else {

+	     if(ioctl(mmapFd, GETMMREG, ibuf) != -1)

+		{ 

+		   xf86MsgVerb(X_INFO, MMAP_DEBUG,

+				"# mmapStat: [Size=%x,Base=%x]\n", Size, Base);

+		   xf86MsgVerb(X_INFO, MMAP_DEBUG,

+		     "#      Physical Address     Size      Reference Count\n");

+		for(i = 0; i < nmmreg; i++) {

+		   xf86MsgVerb(X_INFO, MMAP_DEBUG,

+                      "%-4d   0x%08X         %5dk                %5d	",

+          	      i, ibuf[i].physaddr, ibuf[i].length/1024, ibuf[i].refcnt);

+		   if (ibuf[i].physaddr == Base || ibuf[i].length == Size ) {

+			xf86MsgVerb(X_INFO, MMAP_DEBUG,"MATCH !!!");

+			if (region==-1) region=i;

+                      }

+		   xf86ErrorFVerb(MMAP_DEBUG, "\n");

+		}

+		xf86ErrorFVerb(MMAP_DEBUG, "\n");

+		}

+	     free(ibuf);

+	   }

+	}

+	if (region == -1 && nmmreg > 0) region=region * i;

+	return region;

+}

+#endif

+

+

+static Bool

+linearVidMem()

+{

+#ifdef SVR4

+	return TRUE;

+#elif defined(HAS_SVR3_MMAPDRV)

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+		    "# xf86LinearVidMem: MMAP 2.2.2 called\n");

+

+	if(mmapFd >= 0) return TRUE;

+

+	if ((mmapFd = open("/dev/mmap", O_RDWR)) != -1)

+	{

+	    if(ioctl(mmapFd, GETVERSION) < 0x0222) {

+		xf86Msg(X_WARNING,

+			"xf86LinearVidMem: MMAP 2.2.2 or above required\n");

+		xf86ErrorF("\tlinear memory access disabled\n");

+		return FALSE;

+	    }

+	    return TRUE;

+	}

+	xf86Msg(X_WARNING, "xf86LinearVidMem: failed to open /dev/mmap (%s)\n",

+	        strerror(errno));

+	xf86ErrorF("\tlinear memory access disabled\n");

+	return FALSE;

+#endif

+}

+

+static pointer

+mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

+{

+	pointer base;

+	int fd;

+

+#if defined(SVR4)

+	fd = open(DEV_MEM, (flags & VIDMEM_READONLY) ? O_RDONLY : O_RDWR);

+	if (fd < 0)

+	{

+		FatalError("xf86MapVidMem: failed to open %s (%s)\n",

+			   DEV_MEM, strerror(errno));

+	}

+	base = mmap((caddr_t)0, Size,

+		    (flags & VIDMEM_READONLY) ?

+		     PROT_READ : (PROT_READ | PROT_WRITE),

+		    MAP_SHARED, fd, (off_t)Base);

+	close(fd);

+	if (base == MAP_FAILED)

+	{

+		FatalError("%s: Could not mmap framebuffer [s=%x,a=%x] (%s)\n",

+			   "xf86MapVidMem", Size, Base, strerror(errno));

+	}

+#else /* SVR4 */

+#ifdef HAS_SVR3_MMAPDRV

+

+	xf86MsgVerb(X_INFO, MMAP_DEBUG, "# xf86MapVidMem: MMAP 2.2.2 called\n");

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+			"MMAP_VERSION: 0x%x\n",ioctl(mmapFd, GETVERSION));

+	if (ioctl(mmapFd, GETVERSION) == -1)

+	{

+		xf86LinearVidMem();

+	}

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+			"MMAP_VERSION: 0x%x\n",ioctl(mmapFd, GETVERSION));

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+		"xf86MapVidMem: Screen: %d\n", ScreenNum);

+	mmapStat(Base,Size);

+	/* To force the MMAP driver to provide the address */

+	base = (pointer)0;

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+			"xf86MapVidMem: [s=%x,a=%x]\n", Size, Base);

+	MapDSC.vaddr    = (char *)base;

+	MapDSC.physaddr = (char *)Base;

+	MapDSC.length   = Size;

+	MapDSC.ioflg    = 1;

+	if(mmapFd >= 0)

+	{

+	    if((base = (pointer)ioctl(mmapFd, MAP, &MapDSC)) == (pointer)-1)

+	    {

+		FatalError("%s: Could not mmap framebuffer [s=%x,a=%x] (%s)\n",

+			   "xf86MapVidMem", Size, Base, strerror(errno));

+		/* NOTREACHED */

+	    }

+

+	    /* Next time we want the same address! */

+	    MapDSC.vaddr    = (char *)base;

+	}

+

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+			"MapDSC.vaddr   : 0x%x\n", MapDSC.vaddr);

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+			"MapDSC.physaddr: 0x%x\n", MapDSC.physaddr);

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+			"MapDSC.length  : %d\n", MapDSC.length);

+	mmapStat(Base,Size);

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+			"xf86MapVidMem: [s=%x,a=%x,b=%x]\n", Size, Base, base);

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+			"xf86MapVidMem: SUCCEED Mapping FrameBuffer \n");

+#endif /* HAS_SVR3_MMAPDRV */

+#endif /* SVR4 */

+	return base;

+}

+

+/* ARGSUSED */

+static void

+unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

+{

+#if defined (SVR4)

+	munmap(Base, Size);

+#else /* SVR4 */

+#ifdef HAS_SVR3_MMAPDRV

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+	        "# xf86UnMapVidMem: UNMapping FrameBuffer\n");

+	mmapStat(Base,Size);

+	ioctl(mmapFd, UNMAPRM , Base);

+	mmapStat(Base,Size);

+	xf86MsgVerb(X_INFO, MMAP_DEBUG,

+		"# xf86UnMapVidMem: Screen: %d [v=%x]\n", ScreenNum, Base);

+#endif /* HAS_SVR3_MMAPDRV */

+#endif /* SVR4 */

+	return;

+}

+

+#if defined(SVR4) && defined(__i386__) && !defined(sun)

+/*

+ * For some SVR4 versions, a 32-bit read is done for the first location

+ * in each page when the page is first mapped.  If this is done while

+ * memory access is enabled for regions that have read side-effects,

+ * this can cause unexpected results, including lockups on some hardware.

+ * This function is called to make sure each page is mapped while it is

+ * safe to do so.

+ */

+

+/*

+ * XXX Should get this the correct way (see os/xalloc.c), but since this is

+ * for one platform I'll be lazy.

+ */

+#define X_PAGE_SIZE 4096

+

+static void

+readSideEffects(int ScreenNum, pointer Base, unsigned long Size)

+{

+	unsigned long base, end, addr;

+	CARD32 val;

+

+	base = (unsigned long)Base;

+	end = base + Size;

+

+	for (addr = base; addr < end; addr += X_PAGE_SIZE)

+		val = *(volatile CARD32 *)addr;

+}

+#endif

+

+void

+xf86OSInitVidMem(VidMemInfoPtr pVidMem)

+{

+	pVidMem->linearSupported = linearVidMem();

+	pVidMem->mapMem = mapVidMem;

+	pVidMem->unmapMem = unmapVidMem;

+#if defined(SVR4) && defined(__i386__) && !defined(sun)

+	pVidMem->readSideEffects = readSideEffects;

+#endif

+	pVidMem->initialised = TRUE;

+}

+	

+/***************************************************************************/

+/* I/O Permissions section                                                 */

+/***************************************************************************/

+

+static Bool ExtendedEnabled = FALSE;

+static Bool InitDone = FALSE;

+

+Bool

+xf86EnableIO()

+{

+	int i;

+

+	if (ExtendedEnabled)

+		return TRUE;

+

+	if (SET_IOPL() < 0)

+	{

+	    xf86Msg(X_WARNING,

+			"xf86EnableIO: Failed to set IOPL for extended I/O\n");

+	    return FALSE;

+	}

+	ExtendedEnabled = TRUE;

+

+	return TRUE;

+}

+	

+void

+xf86DisableIO()

+{

+	if (!ExtendedEnabled)

+		return;

+

+	RESET_IOPL();

+	ExtendedEnabled = FALSE;

+

+	return;

+}

diff --git a/xorg-server/hw/xfree86/parser/Configint.h b/xorg-server/hw/xfree86/parser/Configint.h
index 03509b397..63e510d8f 100644
--- a/xorg-server/hw/xfree86/parser/Configint.h
+++ b/xorg-server/hw/xfree86/parser/Configint.h
@@ -1,222 +1,222 @@
-/*
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2002 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* 
- * These definitions are used through out the configuration file parser, but
- * they should not be visible outside of the parser.
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#ifndef _Configint_h_
-#define _Configint_h_
-
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include "xf86Parser.h"
-
-typedef enum { PARSE_DECIMAL, PARSE_OCTAL, PARSE_HEX } ParserNumType;
-
-typedef struct
-{
-	int num;		/* returned number */
-	char *str;		/* private copy of the return-string */
-	double realnum;		/* returned number as a real */
-        ParserNumType numType;  /* used to enforce correct number formatting */
-}
-LexRec, *LexPtr;
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-
-#ifndef FALSE
-#define FALSE 0
-#endif
-
-#include "configProcs.h"
-#include <stdlib.h>
-
-#define TestFree(a) if (a) { free (a); a = NULL; }
-
-#define parsePrologue(typeptr,typerec) typeptr ptr; \
-if( (ptr=calloc(1,sizeof(typerec))) == NULL ) { return NULL; }
-
-#define parsePrologueVoid(typeptr,typerec) int token; typeptr ptr; \
-if( (ptr=calloc(1,sizeof(typerec))) == NULL ) { return; }
-
-#define HANDLE_RETURN(f,func)\
-if ((ptr->f=func) == NULL)\
-{\
-	CLEANUP (ptr);\
-	return (NULL);\
-}
-
-#define HANDLE_LIST(field,func,type)\
-{\
-type p = func ();\
-if (p == NULL)\
-{\
-	CLEANUP (ptr);\
-	return (NULL);\
-}\
-else\
-{\
-	ptr->field = (type) xf86addListItem ((glp) ptr->field, (glp) p);\
-}\
-}
-
-#define Error(a,b) do { \
-			xf86parseError (a, b); CLEANUP (ptr); return NULL; \
-		   } while (0)
-
-/* 
- * These are defines for error messages to promote consistency.
- * error messages are preceded by the line number, section and file name,
- * so these messages should be about the specific keyword and syntax in error.
- * To help limit namespace polution, end each with _MSG.
- * limit messages to 70 characters if possible.
- */
-
-#define BAD_OPTION_MSG \
-"The Option keyword requires 1 or 2 quoted strings to follow it."
-#define INVALID_KEYWORD_MSG \
-"\"%s\" is not a valid keyword in this section."
-#define INVALID_SECTION_MSG \
-"\"%s\" is not a valid section name."
-#define UNEXPECTED_EOF_MSG \
-"Unexpected EOF. Missing EndSection keyword?"
-#define QUOTE_MSG \
-"The %s keyword requires a quoted string to follow it."
-#define NUMBER_MSG \
-"The %s keyword requires a number to follow it."
-#define POSITIVE_INT_MSG \
-"The %s keyword requires a positive integer to follow it."
-#define BOOL_MSG \
-"The %s keyword requires a boolean to follow it."
-#define ZAXISMAPPING_MSG \
-"The ZAxisMapping keyword requires 2 positive numbers or X or Y to follow it."
-#define AUTOREPEAT_MSG \
-"The AutoRepeat keyword requires 2 numbers (delay and rate) to follow it."
-#define XLEDS_MSG \
-"The XLeds keyword requries one or more numbers to follow it."
-#define DACSPEED_MSG \
-"The DacSpeed keyword must be followed by a list of up to %d numbers."
-#define DISPLAYSIZE_MSG \
-"The DisplaySize keyword must be followed by the width and height in mm."
-#define HORIZSYNC_MSG \
-"The HorizSync keyword must be followed by a list of numbers or ranges."
-#define VERTREFRESH_MSG \
-"The VertRefresh keyword must be followed by a list of numbers or ranges."
-#define VIEWPORT_MSG \
-"The Viewport keyword must be followed by an X and Y value."
-#define VIRTUAL_MSG \
-"The Virtual keyword must be followed by a width and height value."
-#define WEIGHT_MSG \
-"The Weight keyword must be followed by red, green and blue values."
-#define BLACK_MSG \
-"The Black keyword must be followed by red, green and blue values."
-#define WHITE_MSG \
-"The White keyword must be followed by red, green and blue values."
-#define SCREEN_MSG \
-"The Screen keyword must be followed by an optional number, a screen name\n" \
-"\tin quotes, and optional position/layout information."
-#define INVALID_SCR_MSG \
-"Invalid Screen line."
-#define INPUTDEV_MSG \
-"The InputDevice keyword must be followed by an input device name in quotes."
-#define INACTIVE_MSG \
-"The Inactive keyword must be followed by a Device name in quotes."
-#define UNDEFINED_SCREEN_MSG \
-"Undefined Screen \"%s\" referenced by ServerLayout \"%s\"."
-#define UNDEFINED_MODES_MSG \
-"Undefined Modes Section \"%s\" referenced by Monitor \"%s\"."
-#define UNDEFINED_DEVICE_MSG \
-"Undefined Device \"%s\" referenced by Screen \"%s\"."
-#define UNDEFINED_ADAPTOR_MSG \
-"Undefined VideoAdaptor \"%s\" referenced by Screen \"%s\"."
-#define ADAPTOR_REF_TWICE_MSG \
-"VideoAdaptor \"%s\" already referenced by Screen \"%s\"."
-#define UNDEFINED_DEVICE_LAY_MSG \
-"Undefined Device \"%s\" referenced by ServerLayout \"%s\"."
-#define UNDEFINED_INPUT_MSG \
-"Undefined InputDevice \"%s\" referenced by ServerLayout \"%s\"."
-#define NO_IDENT_MSG \
-"This section must have an Identifier line."
-#define ONLY_ONE_MSG \
-"This section must have only one of either %s line."
-#define UNDEFINED_INPUTDRIVER_MSG \
-"InputDevice section \"%s\" must have a Driver line."
-#define INVALID_GAMMA_MSG \
-"gamma correction value(s) expected\n either one value or three r/g/b values."
-#define GROUP_MSG \
-"The Group keyword must be followed by either a group name in quotes or\n" \
-"\ta numerical group id."
-#define MULTIPLE_MSG \
-"Multiple \"%s\" lines."
-#define MUST_BE_OCTAL_MSG \
-"The number \"%d\" given in this section must be in octal (0xxx) format."
-
-/* Warning messages */
-#define OBSOLETE_MSG \
-"Ignoring obsolete keyword \"%s\"."
-#define MOVED_TO_FLAGS_MSG \
-"Keyword \"%s\" is now an Option flag in the ServerFlags section."
-
-#endif /* _Configint_h_ */
+/*

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2002 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* 

+ * These definitions are used through out the configuration file parser, but

+ * they should not be visible outside of the parser.

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#ifndef _Configint_h_

+#define _Configint_h_

+

+#include <stdio.h>

+#include <string.h>

+#include <stdarg.h>

+#include <stddef.h>

+#include "xf86Parser.h"

+

+typedef enum { PARSE_DECIMAL, PARSE_OCTAL, PARSE_HEX } ParserNumType;

+

+typedef struct

+{

+	int num;		/* returned number */

+	char *str;		/* private copy of the return-string */

+	double realnum;		/* returned number as a real */

+        ParserNumType numType;  /* used to enforce correct number formatting */

+}

+LexRec, *LexPtr;

+

+#ifndef TRUE

+#define TRUE 1

+#endif

+

+#ifndef FALSE

+#define FALSE 0

+#endif

+

+#include "configProcs.h"

+#include <stdlib.h>

+

+#define TestFree(a) if (a) { free (a); a = NULL; }

+

+#define parsePrologue(typeptr,typerec) typeptr ptr; \

+if( (ptr=calloc(1,sizeof(typerec))) == NULL ) { return NULL; }

+

+#define parsePrologueVoid(typeptr,typerec) int token; typeptr ptr; \

+if( (ptr=calloc(1,sizeof(typerec))) == NULL ) { return; }

+

+#define HANDLE_RETURN(f,func)\

+if ((ptr->f=func) == NULL)\

+{\

+	CLEANUP (ptr);\

+	return NULL;\

+}

+

+#define HANDLE_LIST(field,func,type)\

+{\

+type p = func ();\

+if (p == NULL)\

+{\

+	CLEANUP (ptr);\

+	return NULL;\

+}\

+else\

+{\

+	ptr->field = (type) xf86addListItem ((glp) ptr->field, (glp) p);\

+}\

+}

+

+#define Error(a,b) do { \

+			xf86parseError (a, b); CLEANUP (ptr); return NULL; \

+		   } while (0)

+

+/* 

+ * These are defines for error messages to promote consistency.

+ * error messages are preceded by the line number, section and file name,

+ * so these messages should be about the specific keyword and syntax in error.

+ * To help limit namespace polution, end each with _MSG.

+ * limit messages to 70 characters if possible.

+ */

+

+#define BAD_OPTION_MSG \

+"The Option keyword requires 1 or 2 quoted strings to follow it."

+#define INVALID_KEYWORD_MSG \

+"\"%s\" is not a valid keyword in this section."

+#define INVALID_SECTION_MSG \

+"\"%s\" is not a valid section name."

+#define UNEXPECTED_EOF_MSG \

+"Unexpected EOF. Missing EndSection keyword?"

+#define QUOTE_MSG \

+"The %s keyword requires a quoted string to follow it."

+#define NUMBER_MSG \

+"The %s keyword requires a number to follow it."

+#define POSITIVE_INT_MSG \

+"The %s keyword requires a positive integer to follow it."

+#define BOOL_MSG \

+"The %s keyword requires a boolean to follow it."

+#define ZAXISMAPPING_MSG \

+"The ZAxisMapping keyword requires 2 positive numbers or X or Y to follow it."

+#define AUTOREPEAT_MSG \

+"The AutoRepeat keyword requires 2 numbers (delay and rate) to follow it."

+#define XLEDS_MSG \

+"The XLeds keyword requries one or more numbers to follow it."

+#define DACSPEED_MSG \

+"The DacSpeed keyword must be followed by a list of up to %d numbers."

+#define DISPLAYSIZE_MSG \

+"The DisplaySize keyword must be followed by the width and height in mm."

+#define HORIZSYNC_MSG \

+"The HorizSync keyword must be followed by a list of numbers or ranges."

+#define VERTREFRESH_MSG \

+"The VertRefresh keyword must be followed by a list of numbers or ranges."

+#define VIEWPORT_MSG \

+"The Viewport keyword must be followed by an X and Y value."

+#define VIRTUAL_MSG \

+"The Virtual keyword must be followed by a width and height value."

+#define WEIGHT_MSG \

+"The Weight keyword must be followed by red, green and blue values."

+#define BLACK_MSG \

+"The Black keyword must be followed by red, green and blue values."

+#define WHITE_MSG \

+"The White keyword must be followed by red, green and blue values."

+#define SCREEN_MSG \

+"The Screen keyword must be followed by an optional number, a screen name\n" \

+"\tin quotes, and optional position/layout information."

+#define INVALID_SCR_MSG \

+"Invalid Screen line."

+#define INPUTDEV_MSG \

+"The InputDevice keyword must be followed by an input device name in quotes."

+#define INACTIVE_MSG \

+"The Inactive keyword must be followed by a Device name in quotes."

+#define UNDEFINED_SCREEN_MSG \

+"Undefined Screen \"%s\" referenced by ServerLayout \"%s\"."

+#define UNDEFINED_MODES_MSG \

+"Undefined Modes Section \"%s\" referenced by Monitor \"%s\"."

+#define UNDEFINED_DEVICE_MSG \

+"Undefined Device \"%s\" referenced by Screen \"%s\"."

+#define UNDEFINED_ADAPTOR_MSG \

+"Undefined VideoAdaptor \"%s\" referenced by Screen \"%s\"."

+#define ADAPTOR_REF_TWICE_MSG \

+"VideoAdaptor \"%s\" already referenced by Screen \"%s\"."

+#define UNDEFINED_DEVICE_LAY_MSG \

+"Undefined Device \"%s\" referenced by ServerLayout \"%s\"."

+#define UNDEFINED_INPUT_MSG \

+"Undefined InputDevice \"%s\" referenced by ServerLayout \"%s\"."

+#define NO_IDENT_MSG \

+"This section must have an Identifier line."

+#define ONLY_ONE_MSG \

+"This section must have only one of either %s line."

+#define UNDEFINED_INPUTDRIVER_MSG \

+"InputDevice section \"%s\" must have a Driver line."

+#define INVALID_GAMMA_MSG \

+"gamma correction value(s) expected\n either one value or three r/g/b values."

+#define GROUP_MSG \

+"The Group keyword must be followed by either a group name in quotes or\n" \

+"\ta numerical group id."

+#define MULTIPLE_MSG \

+"Multiple \"%s\" lines."

+#define MUST_BE_OCTAL_MSG \

+"The number \"%d\" given in this section must be in octal (0xxx) format."

+

+/* Warning messages */

+#define OBSOLETE_MSG \

+"Ignoring obsolete keyword \"%s\"."

+#define MOVED_TO_FLAGS_MSG \

+"Keyword \"%s\" is now an Option flag in the ServerFlags section."

+

+#endif /* _Configint_h_ */

diff --git a/xorg-server/hw/xfree86/parser/Device.c b/xorg-server/hw/xfree86/parser/Device.c
index 47ece07de..c81aa05d9 100644
--- a/xorg-server/hw/xfree86/parser/Device.c
+++ b/xorg-server/hw/xfree86/parser/Device.c
@@ -1,371 +1,371 @@
-/* 
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Parser.h"
-#include "xf86tokens.h"
-#include "Configint.h"
-
-extern LexRec val;
-
-static
-xf86ConfigSymTabRec DeviceTab[] =
-{
-	{ENDSECTION, "endsection"},
-	{IDENTIFIER, "identifier"},
-	{VENDOR, "vendorname"},
-	{BOARD, "boardname"},
-	{CHIPSET, "chipset"},
-	{RAMDAC, "ramdac"},
-	{DACSPEED, "dacspeed"},
-	{CLOCKS, "clocks"},
-	{OPTION, "option"},
-	{VIDEORAM, "videoram"},
-	{BIOSBASE, "biosbase"},
-	{MEMBASE, "membase"},
-	{IOBASE, "iobase"},
-	{CLOCKCHIP, "clockchip"},
-	{CHIPID, "chipid"},
-	{CHIPREV, "chiprev"},
-	{CARD, "card"},
-	{DRIVER, "driver"},
-	{BUSID, "busid"},
-	{TEXTCLOCKFRQ, "textclockfreq"},
-	{IRQ, "irq"},
-	{SCREEN, "screen"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeDeviceList
-
-XF86ConfDevicePtr
-xf86parseDeviceSection (void)
-{
-	int i;
-	int has_ident = FALSE;
-	int token;
-	parsePrologue (XF86ConfDevicePtr, XF86ConfDeviceRec)
-
-	/* Zero is a valid value for these */
-	ptr->dev_chipid = -1;
-	ptr->dev_chiprev = -1;
-	ptr->dev_irq = -1;
-	while ((token = xf86getToken (DeviceTab)) != ENDSECTION)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->dev_comment = xf86addComment(ptr->dev_comment, val.str);
-			break;
-		case IDENTIFIER:
-			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)
-				Error (QUOTE_MSG, "Identifier");
-			if (has_ident == TRUE)
-				Error (MULTIPLE_MSG, "Identifier");
-			ptr->dev_identifier = val.str;
-			has_ident = TRUE;
-			break;
-		case VENDOR:
-			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)
-				Error (QUOTE_MSG, "Vendor");
-			ptr->dev_vendor = val.str;
-			break;
-		case BOARD:
-			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)
-				Error (QUOTE_MSG, "Board");
-			ptr->dev_board = val.str;
-			break;
-		case CHIPSET:
-			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)
-				Error (QUOTE_MSG, "Chipset");
-			ptr->dev_chipset = val.str;
-			break;
-		case CARD:
-			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)
-				Error (QUOTE_MSG, "Card");
-			ptr->dev_card = val.str;
-			break;
-		case DRIVER:
-			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)
-				Error (QUOTE_MSG, "Driver");
-			ptr->dev_driver = val.str;
-			break;
-		case RAMDAC:
-			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)
-				Error (QUOTE_MSG, "Ramdac");
-			ptr->dev_ramdac = val.str;
-			break;
-		case DACSPEED:
-			for (i = 0; i < CONF_MAXDACSPEEDS; i++)
-				ptr->dev_dacSpeeds[i] = 0;
-			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)
-			{
-				Error (DACSPEED_MSG, CONF_MAXDACSPEEDS);
-			}
-			else
-			{
-				ptr->dev_dacSpeeds[0] = (int) (val.realnum * 1000.0 + 0.5);
-				for (i = 1; i < CONF_MAXDACSPEEDS; i++)
-				{
-					if (xf86getSubToken (&(ptr->dev_comment)) == NUMBER)
-						ptr->dev_dacSpeeds[i] = (int)
-							(val.realnum * 1000.0 + 0.5);
-					else
-					{
-						xf86unGetToken (token);
-						break;
-					}
-				}
-			}
-			break;
-		case VIDEORAM:
-			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)
-				Error (NUMBER_MSG, "VideoRam");
-			ptr->dev_videoram = val.num;
-			break;
-		case BIOSBASE:
-			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)
-				Error (NUMBER_MSG, "BIOSBase");
-			ptr->dev_bios_base = val.num;
-			break;
-		case MEMBASE:
-			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)
-				Error (NUMBER_MSG, "MemBase");
-			ptr->dev_mem_base = val.num;
-			break;
-		case IOBASE:
-			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)
-				Error (NUMBER_MSG, "IOBase");
-			ptr->dev_io_base = val.num;
-			break;
-		case CLOCKCHIP:
-			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)
-				Error (QUOTE_MSG, "ClockChip");
-			ptr->dev_clockchip = val.str;
-			break;
-		case CHIPID:
-			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)
-				Error (NUMBER_MSG, "ChipID");
-			ptr->dev_chipid = val.num;
-			break;
-		case CHIPREV:
-			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)
-				Error (NUMBER_MSG, "ChipRev");
-			ptr->dev_chiprev = val.num;
-			break;
-
-		case CLOCKS:
-			token = xf86getSubToken(&(ptr->dev_comment));
-			for( i = ptr->dev_clocks;
-				token == NUMBER && i < CONF_MAXCLOCKS; i++ ) {
-				ptr->dev_clock[i] = (int)(val.realnum * 1000.0 + 0.5);
-				token = xf86getSubToken(&(ptr->dev_comment));
-			}
-			ptr->dev_clocks = i;
-			xf86unGetToken (token);
-			break;
-		case TEXTCLOCKFRQ:
-			if ((token = xf86getSubToken(&(ptr->dev_comment))) != NUMBER)
-				Error (NUMBER_MSG, "TextClockFreq");
-			ptr->dev_textclockfreq = (int)(val.realnum * 1000.0 + 0.5);
-			break;
-		case OPTION:
-			ptr->dev_option_lst = xf86parseOption(ptr->dev_option_lst);
-			break;
-		case BUSID:
-			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)
-				Error (QUOTE_MSG, "BusID");
-			ptr->dev_busid = val.str;
-			break;
-		case IRQ:
-			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)
-				Error (QUOTE_MSG, "IRQ");
-			ptr->dev_irq = val.num;
-			break;
-		case SCREEN:
-			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)
-				Error (NUMBER_MSG, "Screen");
-			ptr->dev_screen = val.num;
-			break;
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-			break;
-		}
-	}
-
-	if (!has_ident)
-		Error (NO_IDENT_MSG, NULL);
-
-#ifdef DEBUG
-	printf ("Device section parsed\n");
-#endif
-
-	return ptr;
-}
-
-#undef CLEANUP
-
-void
-xf86printDeviceSection (FILE * cf, XF86ConfDevicePtr ptr)
-{
-	int i;
-
-	while (ptr)
-	{
-		fprintf (cf, "Section \"Device\"\n");
-		if (ptr->dev_comment)
-			fprintf (cf, "%s", ptr->dev_comment);
-		if (ptr->dev_identifier)
-			fprintf (cf, "\tIdentifier  \"%s\"\n", ptr->dev_identifier);
-		if (ptr->dev_driver)
-			fprintf (cf, "\tDriver      \"%s\"\n", ptr->dev_driver);
-		if (ptr->dev_vendor)
-			fprintf (cf, "\tVendorName  \"%s\"\n", ptr->dev_vendor);
-		if (ptr->dev_board)
-			fprintf (cf, "\tBoardName   \"%s\"\n", ptr->dev_board);
-		if (ptr->dev_chipset)
-			fprintf (cf, "\tChipSet     \"%s\"\n", ptr->dev_chipset);
-		if (ptr->dev_card)
-			fprintf (cf, "\tCard        \"%s\"\n", ptr->dev_card);
-		if (ptr->dev_ramdac)
-			fprintf (cf, "\tRamDac      \"%s\"\n", ptr->dev_ramdac);
-		if (ptr->dev_dacSpeeds[0] > 0 ) {
-			fprintf (cf, "\tDacSpeed    ");
-			for (i = 0; i < CONF_MAXDACSPEEDS
-					&& ptr->dev_dacSpeeds[i] > 0; i++ )
-				fprintf (cf, "%g ", (double) (ptr->dev_dacSpeeds[i])/ 1000.0 );
-			fprintf (cf, "\n");
-		}
-		if (ptr->dev_videoram)
-			fprintf (cf, "\tVideoRam    %d\n", ptr->dev_videoram);
-		if (ptr->dev_bios_base)
-			fprintf (cf, "\tBiosBase    0x%lx\n", ptr->dev_bios_base);
-		if (ptr->dev_mem_base)
-			fprintf (cf, "\tMemBase     0x%lx\n", ptr->dev_mem_base);
-		if (ptr->dev_io_base)
-			fprintf (cf, "\tIOBase      0x%lx\n", ptr->dev_io_base);
-		if (ptr->dev_clockchip)
-			fprintf (cf, "\tClockChip   \"%s\"\n", ptr->dev_clockchip);
-		if (ptr->dev_chipid != -1)
-			fprintf (cf, "\tChipId      0x%x\n", ptr->dev_chipid);
-		if (ptr->dev_chiprev != -1)
-			fprintf (cf, "\tChipRev     0x%x\n", ptr->dev_chiprev);
-
-		xf86printOptionList(cf, ptr->dev_option_lst, 1);
-		if (ptr->dev_clocks > 0 ) {
-			fprintf (cf, "\tClocks      ");
-			for (i = 0; i < ptr->dev_clocks; i++ )
-				fprintf (cf, "%.1f ", (double)ptr->dev_clock[i] / 1000.0 );
-			fprintf (cf, "\n");
-		}
-		if (ptr->dev_textclockfreq) {
-			fprintf (cf, "\tTextClockFreq %.1f\n",
-					 (double)ptr->dev_textclockfreq / 1000.0);
-		}
-		if (ptr->dev_busid)
-			fprintf (cf, "\tBusID       \"%s\"\n", ptr->dev_busid);
-		if (ptr->dev_screen > 0)
-			fprintf (cf, "\tScreen      %d\n", ptr->dev_screen);
-		if (ptr->dev_irq >= 0)
-			fprintf (cf, "\tIRQ         %d\n", ptr->dev_irq);
-		fprintf (cf, "EndSection\n\n");
-		ptr = ptr->list.next;
-	}
-}
-
-void
-xf86freeDeviceList (XF86ConfDevicePtr ptr)
-{
-	XF86ConfDevicePtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->dev_identifier);
-		TestFree (ptr->dev_vendor);
-		TestFree (ptr->dev_board);
-		TestFree (ptr->dev_chipset);
-		TestFree (ptr->dev_card);
-		TestFree (ptr->dev_driver);
-		TestFree (ptr->dev_ramdac);
-		TestFree (ptr->dev_clockchip);
-		TestFree (ptr->dev_comment);
-		xf86optionListFree (ptr->dev_option_lst);
-
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-XF86ConfDevicePtr
-xf86findDevice (const char *ident, XF86ConfDevicePtr p)
-{
-	while (p)
-	{
-		if (xf86nameCompare (ident, p->dev_identifier) == 0)
-			return (p);
-
-		p = p->list.next;
-	}
-	return (NULL);
-}
+/* 

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86Parser.h"

+#include "xf86tokens.h"

+#include "Configint.h"

+

+extern LexRec val;

+

+static

+xf86ConfigSymTabRec DeviceTab[] =

+{

+	{ENDSECTION, "endsection"},

+	{IDENTIFIER, "identifier"},

+	{VENDOR, "vendorname"},

+	{BOARD, "boardname"},

+	{CHIPSET, "chipset"},

+	{RAMDAC, "ramdac"},

+	{DACSPEED, "dacspeed"},

+	{CLOCKS, "clocks"},

+	{OPTION, "option"},

+	{VIDEORAM, "videoram"},

+	{BIOSBASE, "biosbase"},

+	{MEMBASE, "membase"},

+	{IOBASE, "iobase"},

+	{CLOCKCHIP, "clockchip"},

+	{CHIPID, "chipid"},

+	{CHIPREV, "chiprev"},

+	{CARD, "card"},

+	{DRIVER, "driver"},

+	{BUSID, "busid"},

+	{TEXTCLOCKFRQ, "textclockfreq"},

+	{IRQ, "irq"},

+	{SCREEN, "screen"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeDeviceList

+

+XF86ConfDevicePtr

+xf86parseDeviceSection (void)

+{

+	int i;

+	int has_ident = FALSE;

+	int token;

+	parsePrologue (XF86ConfDevicePtr, XF86ConfDeviceRec)

+

+	/* Zero is a valid value for these */

+	ptr->dev_chipid = -1;

+	ptr->dev_chiprev = -1;

+	ptr->dev_irq = -1;

+	while ((token = xf86getToken (DeviceTab)) != ENDSECTION)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->dev_comment = xf86addComment(ptr->dev_comment, val.str);

+			break;

+		case IDENTIFIER:

+			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)

+				Error (QUOTE_MSG, "Identifier");

+			if (has_ident == TRUE)

+				Error (MULTIPLE_MSG, "Identifier");

+			ptr->dev_identifier = val.str;

+			has_ident = TRUE;

+			break;

+		case VENDOR:

+			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)

+				Error (QUOTE_MSG, "Vendor");

+			ptr->dev_vendor = val.str;

+			break;

+		case BOARD:

+			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)

+				Error (QUOTE_MSG, "Board");

+			ptr->dev_board = val.str;

+			break;

+		case CHIPSET:

+			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)

+				Error (QUOTE_MSG, "Chipset");

+			ptr->dev_chipset = val.str;

+			break;

+		case CARD:

+			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)

+				Error (QUOTE_MSG, "Card");

+			ptr->dev_card = val.str;

+			break;

+		case DRIVER:

+			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)

+				Error (QUOTE_MSG, "Driver");

+			ptr->dev_driver = val.str;

+			break;

+		case RAMDAC:

+			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)

+				Error (QUOTE_MSG, "Ramdac");

+			ptr->dev_ramdac = val.str;

+			break;

+		case DACSPEED:

+			for (i = 0; i < CONF_MAXDACSPEEDS; i++)

+				ptr->dev_dacSpeeds[i] = 0;

+			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)

+			{

+				Error (DACSPEED_MSG, CONF_MAXDACSPEEDS);

+			}

+			else

+			{

+				ptr->dev_dacSpeeds[0] = (int) (val.realnum * 1000.0 + 0.5);

+				for (i = 1; i < CONF_MAXDACSPEEDS; i++)

+				{

+					if (xf86getSubToken (&(ptr->dev_comment)) == NUMBER)

+						ptr->dev_dacSpeeds[i] = (int)

+							(val.realnum * 1000.0 + 0.5);

+					else

+					{

+						xf86unGetToken (token);

+						break;

+					}

+				}

+			}

+			break;

+		case VIDEORAM:

+			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)

+				Error (NUMBER_MSG, "VideoRam");

+			ptr->dev_videoram = val.num;

+			break;

+		case BIOSBASE:

+			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)

+				Error (NUMBER_MSG, "BIOSBase");

+			ptr->dev_bios_base = val.num;

+			break;

+		case MEMBASE:

+			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)

+				Error (NUMBER_MSG, "MemBase");

+			ptr->dev_mem_base = val.num;

+			break;

+		case IOBASE:

+			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)

+				Error (NUMBER_MSG, "IOBase");

+			ptr->dev_io_base = val.num;

+			break;

+		case CLOCKCHIP:

+			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)

+				Error (QUOTE_MSG, "ClockChip");

+			ptr->dev_clockchip = val.str;

+			break;

+		case CHIPID:

+			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)

+				Error (NUMBER_MSG, "ChipID");

+			ptr->dev_chipid = val.num;

+			break;

+		case CHIPREV:

+			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)

+				Error (NUMBER_MSG, "ChipRev");

+			ptr->dev_chiprev = val.num;

+			break;

+

+		case CLOCKS:

+			token = xf86getSubToken(&(ptr->dev_comment));

+			for( i = ptr->dev_clocks;

+				token == NUMBER && i < CONF_MAXCLOCKS; i++ ) {

+				ptr->dev_clock[i] = (int)(val.realnum * 1000.0 + 0.5);

+				token = xf86getSubToken(&(ptr->dev_comment));

+			}

+			ptr->dev_clocks = i;

+			xf86unGetToken (token);

+			break;

+		case TEXTCLOCKFRQ:

+			if ((token = xf86getSubToken(&(ptr->dev_comment))) != NUMBER)

+				Error (NUMBER_MSG, "TextClockFreq");

+			ptr->dev_textclockfreq = (int)(val.realnum * 1000.0 + 0.5);

+			break;

+		case OPTION:

+			ptr->dev_option_lst = xf86parseOption(ptr->dev_option_lst);

+			break;

+		case BUSID:

+			if (xf86getSubToken (&(ptr->dev_comment)) != STRING)

+				Error (QUOTE_MSG, "BusID");

+			ptr->dev_busid = val.str;

+			break;

+		case IRQ:

+			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)

+				Error (QUOTE_MSG, "IRQ");

+			ptr->dev_irq = val.num;

+			break;

+		case SCREEN:

+			if (xf86getSubToken (&(ptr->dev_comment)) != NUMBER)

+				Error (NUMBER_MSG, "Screen");

+			ptr->dev_screen = val.num;

+			break;

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+			break;

+		}

+	}

+

+	if (!has_ident)

+		Error (NO_IDENT_MSG, NULL);

+

+#ifdef DEBUG

+	printf ("Device section parsed\n");

+#endif

+

+	return ptr;

+}

+

+#undef CLEANUP

+

+void

+xf86printDeviceSection (FILE * cf, XF86ConfDevicePtr ptr)

+{

+	int i;

+

+	while (ptr)

+	{

+		fprintf (cf, "Section \"Device\"\n");

+		if (ptr->dev_comment)

+			fprintf (cf, "%s", ptr->dev_comment);

+		if (ptr->dev_identifier)

+			fprintf (cf, "\tIdentifier  \"%s\"\n", ptr->dev_identifier);

+		if (ptr->dev_driver)

+			fprintf (cf, "\tDriver      \"%s\"\n", ptr->dev_driver);

+		if (ptr->dev_vendor)

+			fprintf (cf, "\tVendorName  \"%s\"\n", ptr->dev_vendor);

+		if (ptr->dev_board)

+			fprintf (cf, "\tBoardName   \"%s\"\n", ptr->dev_board);

+		if (ptr->dev_chipset)

+			fprintf (cf, "\tChipSet     \"%s\"\n", ptr->dev_chipset);

+		if (ptr->dev_card)

+			fprintf (cf, "\tCard        \"%s\"\n", ptr->dev_card);

+		if (ptr->dev_ramdac)

+			fprintf (cf, "\tRamDac      \"%s\"\n", ptr->dev_ramdac);

+		if (ptr->dev_dacSpeeds[0] > 0 ) {

+			fprintf (cf, "\tDacSpeed    ");

+			for (i = 0; i < CONF_MAXDACSPEEDS

+					&& ptr->dev_dacSpeeds[i] > 0; i++ )

+				fprintf (cf, "%g ", (double) (ptr->dev_dacSpeeds[i])/ 1000.0 );

+			fprintf (cf, "\n");

+		}

+		if (ptr->dev_videoram)

+			fprintf (cf, "\tVideoRam    %d\n", ptr->dev_videoram);

+		if (ptr->dev_bios_base)

+			fprintf (cf, "\tBiosBase    0x%lx\n", ptr->dev_bios_base);

+		if (ptr->dev_mem_base)

+			fprintf (cf, "\tMemBase     0x%lx\n", ptr->dev_mem_base);

+		if (ptr->dev_io_base)

+			fprintf (cf, "\tIOBase      0x%lx\n", ptr->dev_io_base);

+		if (ptr->dev_clockchip)

+			fprintf (cf, "\tClockChip   \"%s\"\n", ptr->dev_clockchip);

+		if (ptr->dev_chipid != -1)

+			fprintf (cf, "\tChipId      0x%x\n", ptr->dev_chipid);

+		if (ptr->dev_chiprev != -1)

+			fprintf (cf, "\tChipRev     0x%x\n", ptr->dev_chiprev);

+

+		xf86printOptionList(cf, ptr->dev_option_lst, 1);

+		if (ptr->dev_clocks > 0 ) {

+			fprintf (cf, "\tClocks      ");

+			for (i = 0; i < ptr->dev_clocks; i++ )

+				fprintf (cf, "%.1f ", (double)ptr->dev_clock[i] / 1000.0 );

+			fprintf (cf, "\n");

+		}

+		if (ptr->dev_textclockfreq) {

+			fprintf (cf, "\tTextClockFreq %.1f\n",

+					 (double)ptr->dev_textclockfreq / 1000.0);

+		}

+		if (ptr->dev_busid)

+			fprintf (cf, "\tBusID       \"%s\"\n", ptr->dev_busid);

+		if (ptr->dev_screen > 0)

+			fprintf (cf, "\tScreen      %d\n", ptr->dev_screen);

+		if (ptr->dev_irq >= 0)

+			fprintf (cf, "\tIRQ         %d\n", ptr->dev_irq);

+		fprintf (cf, "EndSection\n\n");

+		ptr = ptr->list.next;

+	}

+}

+

+void

+xf86freeDeviceList (XF86ConfDevicePtr ptr)

+{

+	XF86ConfDevicePtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->dev_identifier);

+		TestFree (ptr->dev_vendor);

+		TestFree (ptr->dev_board);

+		TestFree (ptr->dev_chipset);

+		TestFree (ptr->dev_card);

+		TestFree (ptr->dev_driver);

+		TestFree (ptr->dev_ramdac);

+		TestFree (ptr->dev_clockchip);

+		TestFree (ptr->dev_comment);

+		xf86optionListFree (ptr->dev_option_lst);

+

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+XF86ConfDevicePtr

+xf86findDevice (const char *ident, XF86ConfDevicePtr p)

+{

+	while (p)

+	{

+		if (xf86nameCompare (ident, p->dev_identifier) == 0)

+			return p;

+

+		p = p->list.next;

+	}

+	return NULL;

+}

diff --git a/xorg-server/hw/xfree86/parser/Flags.c b/xorg-server/hw/xfree86/parser/Flags.c
index 699f15ceb..b6ffc1538 100644
--- a/xorg-server/hw/xfree86/parser/Flags.c
+++ b/xorg-server/hw/xfree86/parser/Flags.c
@@ -1,516 +1,515 @@
-/* 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Parser.h"
-#include "xf86tokens.h"
-#include "Configint.h"
-#include <math.h>
-#include <X11/Xfuncproto.h>
-
-extern LexRec val;
-
-static xf86ConfigSymTabRec ServerFlagsTab[] =
-{
-	{ENDSECTION, "endsection"},
-	{NOTRAPSIGNALS, "notrapsignals"},
-	{DONTZAP, "dontzap"},
-	{DONTZOOM, "dontzoom"},
-	{DISABLEVIDMODE, "disablevidmodeextension"},
-	{ALLOWNONLOCAL, "allownonlocalxvidtune"},
-	{DISABLEMODINDEV, "disablemodindev"},
-	{MODINDEVALLOWNONLOCAL, "allownonlocalmodindev"},
-	{ALLOWMOUSEOPENFAIL, "allowmouseopenfail"},
-	{OPTION, "option"},
-	{BLANKTIME, "blanktime"},
-	{STANDBYTIME, "standbytime"},
-	{SUSPENDTIME, "suspendtime"},
-	{OFFTIME, "offtime"},
-	{DEFAULTLAYOUT, "defaultserverlayout"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeFlags
-
-XF86ConfFlagsPtr
-xf86parseFlagsSection (void)
-{
-	int token;
-	parsePrologue (XF86ConfFlagsPtr, XF86ConfFlagsRec)
-
-	while ((token = xf86getToken (ServerFlagsTab)) != ENDSECTION)
-	{
-		int hasvalue = FALSE;
-		int strvalue = FALSE;
-		int tokentype;
-		switch (token)
-		{
-		case COMMENT:
-			ptr->flg_comment = xf86addComment(ptr->flg_comment, val.str);
-			break;
-			/* 
-			 * these old keywords are turned into standard generic options.
-			 * we fall through here on purpose
-			 */
-		case DEFAULTLAYOUT:
-			strvalue = TRUE;
-		case BLANKTIME:
-		case STANDBYTIME:
-		case SUSPENDTIME:
-		case OFFTIME:
-			hasvalue = TRUE;
-		case NOTRAPSIGNALS:
-		case DONTZAP:
-		case DONTZOOM:
-		case DISABLEVIDMODE:
-		case ALLOWNONLOCAL:
-		case DISABLEMODINDEV:
-		case MODINDEVALLOWNONLOCAL:
-		case ALLOWMOUSEOPENFAIL:
-			{
-				int i = 0;
-				while (ServerFlagsTab[i].token != -1)
-				{
-					char *tmp;
-
-					if (ServerFlagsTab[i].token == token)
-					{
-						char *valstr = NULL;
-						/* can't use strdup because it calls malloc */
-						tmp = strdup (ServerFlagsTab[i].name);
-						if (hasvalue)
-						{
-							tokentype = xf86getSubToken(&(ptr->flg_comment));
-							if (strvalue) {
-								if (tokentype != STRING)
-									Error (QUOTE_MSG, tmp);
-								valstr = val.str;
-							} else {
-								if (tokentype != NUMBER)
-									Error (NUMBER_MSG, tmp);
-								valstr = malloc(16);
-								if (valstr)
-									sprintf(valstr, "%d", val.num);
-							}
-						}
-						ptr->flg_option_lst = xf86addNewOption
-							(ptr->flg_option_lst, tmp, valstr);
-					}
-					i++;
-				}
-			}
-			break;
-		case OPTION:
-			ptr->flg_option_lst = xf86parseOption(ptr->flg_option_lst);
-			break;
-
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-			break;
-		}
-	}
-
-#ifdef DEBUG
-	printf ("Flags section parsed\n");
-#endif
-
-	return ptr;
-}
-
-#undef CLEANUP
-
-void
-xf86printServerFlagsSection (FILE * f, XF86ConfFlagsPtr flags)
-{
-	XF86OptionPtr p;
-
-	if ((!flags) || (!flags->flg_option_lst))
-		return;
-	p = flags->flg_option_lst;
-	fprintf (f, "Section \"ServerFlags\"\n");
-	if (flags->flg_comment)
-		fprintf (f, "%s", flags->flg_comment);
-	xf86printOptionList(f, p, 1);
-	fprintf (f, "EndSection\n\n");
-}
-
-static XF86OptionPtr
-addNewOption2 (XF86OptionPtr head, char *name, char *val, int used)
-{
-	XF86OptionPtr new, old = NULL;
-
-	/* Don't allow duplicates, free old strings */
-	if (head != NULL && (old = xf86findOption(head, name)) != NULL) {
-		new = old;
-		free(new->opt_name);
-		free(new->opt_val);
-	}
-	else
-		new = calloc (1, sizeof (XF86OptionRec));
-	new->opt_name = name;
-	new->opt_val = val;
-	new->opt_used = used;
-
-	if (old)
-		return head;
-	return ((XF86OptionPtr) xf86addListItem ((glp) head, (glp) new));
-}
-
-XF86OptionPtr
-xf86addNewOption (XF86OptionPtr head, char *name, char *val)
-{
-	return addNewOption2(head, name, val, 0);
-}
-
-void
-xf86freeFlags (XF86ConfFlagsPtr flags)
-{
-	if (flags == NULL)
-		return;
-	xf86optionListFree (flags->flg_option_lst);
-	TestFree(flags->flg_comment);
-	free (flags);
-}
-
-XF86OptionPtr
-xf86optionListDup (XF86OptionPtr opt)
-{
-	XF86OptionPtr newopt = NULL;
-	char *val;
-
-	while (opt)
-	{
-		val = opt->opt_val ? strdup(opt->opt_val) : NULL;
-		newopt = xf86addNewOption(newopt, strdup(opt->opt_name), val);
-		newopt->opt_used = opt->opt_used;
-		if (opt->opt_comment)
-			newopt->opt_comment = strdup(opt->opt_comment);
-		opt = opt->list.next;
-	}
-	return newopt;
-}
-
-void
-xf86optionListFree (XF86OptionPtr opt)
-{
-	XF86OptionPtr prev;
-
-	while (opt)
-	{
-		TestFree (opt->opt_name);
-		TestFree (opt->opt_val);
-		TestFree (opt->opt_comment);
-		prev = opt;
-		opt = opt->list.next;
-		free (prev);
-	}
-}
-
-char *
-xf86optionName(XF86OptionPtr opt)
-{
-	if (opt)
-		return opt->opt_name;
-	return 0;
-}
-
-char *
-xf86optionValue(XF86OptionPtr opt)
-{
-	if (opt)
-		return opt->opt_val;
-	return 0;
-}
-
-XF86OptionPtr
-xf86newOption(char *name, char *value)
-{
-	XF86OptionPtr opt;
-
-	opt = calloc(1, sizeof (XF86OptionRec));
-	if (!opt)
-		return NULL;
-
-	opt->opt_used = 0;
-	opt->list.next = 0;
-	opt->opt_name = name;
-	opt->opt_val = value;
-
-	return opt;
-}
-
-XF86OptionPtr
-xf86nextOption(XF86OptionPtr list)
-{
-	if (!list)
-		return NULL;
-	return list->list.next;
-}
-
-/*
- * this function searches the given option list for the named option and
- * returns a pointer to the option rec if found. If not found, it returns
- * NULL
- */
-
-XF86OptionPtr
-xf86findOption (XF86OptionPtr list, const char *name)
-{
-	while (list)
-	{
-		if (xf86nameCompare (list->opt_name, name) == 0)
-			return (list);
-		list = list->list.next;
-	}
-	return (NULL);
-}
-
-/*
- * this function searches the given option list for the named option. If
- * found and the option has a parameter, a pointer to the parameter is
- * returned.  If the option does not have a parameter an empty string is
- * returned.  If the option is not found, a NULL is returned.
- */
-
-char *
-xf86findOptionValue (XF86OptionPtr list, const char *name)
-{
-	XF86OptionPtr p = xf86findOption (list, name);
-
-	if (p)
-	{
-		if (p->opt_val)
-			return (p->opt_val);
-		else
-			return "";
-	}
-	return (NULL);
-}
-
-XF86OptionPtr
-xf86optionListCreate( const char **options, int count, int used )
-{
-	XF86OptionPtr p = NULL;
-	char *t1, *t2;
-	int i;
-
-	if (count == -1)
-	{
-		for (count = 0; options[count]; count++)
-			;
-	}
-	if( (count % 2) != 0 )
-	{
-		fprintf( stderr, "xf86optionListCreate: count must be an even number.\n" );
-		return (NULL);
-	}
-	for (i = 0; i < count; i += 2)
-	{
-		/* can't use strdup because it calls malloc */
-		t1 = malloc (sizeof (char) *
-				(strlen (options[i]) + 1));
-		strcpy (t1, options[i]);
-		t2 = malloc (sizeof (char) *
-				(strlen (options[i + 1]) + 1));
-		strcpy (t2, options[i + 1]);
-		p = addNewOption2 (p, t1, t2, used);
-	}
-
-	return (p);
-}
-
-/* the 2 given lists are merged. If an option with the same name is present in
- * both, the option from the user list - specified in the second argument -
- * is used. The end result is a single valid list of options. Duplicates
- * are freed, and the original lists are no longer guaranteed to be complete.
- */
-XF86OptionPtr
-xf86optionListMerge (XF86OptionPtr head, XF86OptionPtr tail)
-{
-	XF86OptionPtr a, b, ap = NULL, bp = NULL;
-
-	a = tail;
-	b = head;
-	while (tail && b) {
-		if (xf86nameCompare (a->opt_name, b->opt_name) == 0) {
-			if (b == head)
-				head = a;
-			else
-				bp->list.next = a;
-			if (a == tail)
-				tail = a->list.next;
-			else
-				ap->list.next = a->list.next;
-			a->list.next = b->list.next;
-			b->list.next = NULL;
-			xf86optionListFree (b);
-			b = a->list.next;
-			bp = a;
-			a = tail;
-			ap = NULL;
-		} else {
-			ap = a;
-			if (!(a = a->list.next)) {
-				a = tail;
-				bp = b;
-				b = b->list.next;
-				ap = NULL;
-			}
-		}
-	}
-
-	if (head) {
-		for (a = head; a->list.next; a = a->list.next)
-			;
-		a->list.next = tail;
-	} else 
-		head = tail;
-
-	return (head);
-}
-
-char *
-xf86uLongToString(unsigned long i)
-{
-	char *s;
-	int l;
-
-	l = ceil(log10((double)i) + 2.5);
-	s = malloc(l);
-	if (!s)
-		return NULL;
-	sprintf(s, "%lu", i);
-	return s;
-}
-
-XF86OptionPtr
-xf86parseOption(XF86OptionPtr head)
-{
-	XF86OptionPtr option, cnew, old;
-	char *name, *comment = NULL;
-	int token;
-
-	if ((token = xf86getSubToken(&comment)) != STRING) {
-		xf86parseError(BAD_OPTION_MSG, NULL);
-		if (comment)
-			free(comment);
-		return (head);
-	}
-
-	name = val.str;
-	if ((token = xf86getSubToken(&comment)) == STRING) {
-		option = xf86newOption(name, val.str);
-		option->opt_comment = comment;
-		if ((token = xf86getToken(NULL)) == COMMENT)
-			option->opt_comment = xf86addComment(option->opt_comment, val.str);
-		else
-			xf86unGetToken(token);
-	}
-	else {
-		option = xf86newOption(name, NULL);
-		option->opt_comment = comment;
-		if (token == COMMENT)
-			option->opt_comment = xf86addComment(option->opt_comment, val.str);
-		else
-			xf86unGetToken(token);
-	}
-
-	old = NULL;
-
-	/* Don't allow duplicates */
-	if (head != NULL && (old = xf86findOption(head, name)) != NULL) {
-		cnew = old;
-		free(option->opt_name);
-		TestFree(option->opt_val);
-		TestFree(option->opt_comment);
-		free(option);
-	}
-	else
-		cnew = option;
-	
-	if (old == NULL)
-		return ((XF86OptionPtr)xf86addListItem((glp)head, (glp)cnew));
-
-	return (head);
-}
-
-void
-xf86printOptionList(FILE *fp, XF86OptionPtr list, int tabs)
-{
-	int i;
-
-	if (!list)
-		return;
-	while (list) {
-		for (i = 0; i < tabs; i++)
-			fputc('\t', fp);
-		if (list->opt_val)
-			fprintf(fp, "Option	    \"%s\" \"%s\"", list->opt_name, list->opt_val);
-		else
-			fprintf(fp, "Option	    \"%s\"", list->opt_name);
-		if (list->opt_comment)
-			fprintf(fp, "%s", list->opt_comment);
-		else
-			fputc('\n', fp);
-		list = list->list.next;
-	}
-}
+/* 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86Parser.h"

+#include "xf86tokens.h"

+#include "Configint.h"

+#include <math.h>

+#include <X11/Xfuncproto.h>

+

+extern LexRec val;

+

+static xf86ConfigSymTabRec ServerFlagsTab[] =

+{

+	{ENDSECTION, "endsection"},

+	{NOTRAPSIGNALS, "notrapsignals"},

+	{DONTZAP, "dontzap"},

+	{DONTZOOM, "dontzoom"},

+	{DISABLEVIDMODE, "disablevidmodeextension"},

+	{ALLOWNONLOCAL, "allownonlocalxvidtune"},

+	{DISABLEMODINDEV, "disablemodindev"},

+	{MODINDEVALLOWNONLOCAL, "allownonlocalmodindev"},

+	{ALLOWMOUSEOPENFAIL, "allowmouseopenfail"},

+	{OPTION, "option"},

+	{BLANKTIME, "blanktime"},

+	{STANDBYTIME, "standbytime"},

+	{SUSPENDTIME, "suspendtime"},

+	{OFFTIME, "offtime"},

+	{DEFAULTLAYOUT, "defaultserverlayout"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeFlags

+

+XF86ConfFlagsPtr

+xf86parseFlagsSection (void)

+{

+	int token;

+	parsePrologue (XF86ConfFlagsPtr, XF86ConfFlagsRec)

+

+	while ((token = xf86getToken (ServerFlagsTab)) != ENDSECTION)

+	{

+		int hasvalue = FALSE;

+		int strvalue = FALSE;

+		int tokentype;

+		switch (token)

+		{

+		case COMMENT:

+			ptr->flg_comment = xf86addComment(ptr->flg_comment, val.str);

+			break;

+			/* 

+			 * these old keywords are turned into standard generic options.

+			 * we fall through here on purpose

+			 */

+		case DEFAULTLAYOUT:

+			strvalue = TRUE;

+		case BLANKTIME:

+		case STANDBYTIME:

+		case SUSPENDTIME:

+		case OFFTIME:

+			hasvalue = TRUE;

+		case NOTRAPSIGNALS:

+		case DONTZAP:

+		case DONTZOOM:

+		case DISABLEVIDMODE:

+		case ALLOWNONLOCAL:

+		case DISABLEMODINDEV:

+		case MODINDEVALLOWNONLOCAL:

+		case ALLOWMOUSEOPENFAIL:

+			{

+				int i = 0;

+				while (ServerFlagsTab[i].token != -1)

+				{

+					char *tmp;

+

+					if (ServerFlagsTab[i].token == token)

+					{

+						char *valstr = NULL;

+						/* can't use strdup because it calls malloc */

+						tmp = strdup (ServerFlagsTab[i].name);

+						if (hasvalue)

+						{

+							tokentype = xf86getSubToken(&(ptr->flg_comment));

+							if (strvalue) {

+								if (tokentype != STRING)

+									Error (QUOTE_MSG, tmp);

+								valstr = val.str;

+							} else {

+								if (tokentype != NUMBER)

+									Error (NUMBER_MSG, tmp);

+								valstr = malloc(16);

+								if (valstr)

+									sprintf(valstr, "%d", val.num);

+							}

+						}

+						ptr->flg_option_lst = xf86addNewOption

+							(ptr->flg_option_lst, tmp, valstr);

+					}

+					i++;

+				}

+			}

+			break;

+		case OPTION:

+			ptr->flg_option_lst = xf86parseOption(ptr->flg_option_lst);

+			break;

+

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+			break;

+		}

+	}

+

+#ifdef DEBUG

+	printf ("Flags section parsed\n");

+#endif

+

+	return ptr;

+}

+

+#undef CLEANUP

+

+void

+xf86printServerFlagsSection (FILE * f, XF86ConfFlagsPtr flags)

+{

+	XF86OptionPtr p;

+

+	if ((!flags) || (!flags->flg_option_lst))

+		return;

+	p = flags->flg_option_lst;

+	fprintf (f, "Section \"ServerFlags\"\n");

+	if (flags->flg_comment)

+		fprintf (f, "%s", flags->flg_comment);

+	xf86printOptionList(f, p, 1);

+	fprintf (f, "EndSection\n\n");

+}

+

+static XF86OptionPtr

+addNewOption2 (XF86OptionPtr head, char *name, char *val, int used)

+{

+	XF86OptionPtr new, old = NULL;

+

+	/* Don't allow duplicates, free old strings */

+	if (head != NULL && (old = xf86findOption(head, name)) != NULL) {

+		new = old;

+		free(new->opt_name);

+		free(new->opt_val);

+	}

+	else

+		new = calloc (1, sizeof (XF86OptionRec));

+	new->opt_name = name;

+	new->opt_val = val;

+	new->opt_used = used;

+

+	if (old)

+		return head;

+	return ((XF86OptionPtr) xf86addListItem ((glp) head, (glp) new));

+}

+

+XF86OptionPtr

+xf86addNewOption (XF86OptionPtr head, char *name, char *val)

+{

+	return addNewOption2(head, name, val, 0);

+}

+

+void

+xf86freeFlags (XF86ConfFlagsPtr flags)

+{

+	if (flags == NULL)

+		return;

+	xf86optionListFree (flags->flg_option_lst);

+	TestFree(flags->flg_comment);

+	free (flags);

+}

+

+XF86OptionPtr

+xf86optionListDup (XF86OptionPtr opt)

+{

+	XF86OptionPtr newopt = NULL;

+	char *val;

+

+	while (opt)

+	{

+		val = opt->opt_val ? strdup(opt->opt_val) : NULL;

+		newopt = xf86addNewOption(newopt, strdup(opt->opt_name), val);

+		newopt->opt_used = opt->opt_used;

+		if (opt->opt_comment)

+			newopt->opt_comment = strdup(opt->opt_comment);

+		opt = opt->list.next;

+	}

+	return newopt;

+}

+

+void

+xf86optionListFree (XF86OptionPtr opt)

+{

+	XF86OptionPtr prev;

+

+	while (opt)

+	{

+		TestFree (opt->opt_name);

+		TestFree (opt->opt_val);

+		TestFree (opt->opt_comment);

+		prev = opt;

+		opt = opt->list.next;

+		free (prev);

+	}

+}

+

+char *

+xf86optionName(XF86OptionPtr opt)

+{

+	if (opt)

+		return opt->opt_name;

+	return 0;

+}

+

+char *

+xf86optionValue(XF86OptionPtr opt)

+{

+	if (opt)

+		return opt->opt_val;

+	return 0;

+}

+

+XF86OptionPtr

+xf86newOption(char *name, char *value)

+{

+	XF86OptionPtr opt;

+

+	opt = calloc(1, sizeof (XF86OptionRec));

+	if (!opt)

+		return NULL;

+

+	opt->opt_used = 0;

+	opt->list.next = 0;

+	opt->opt_name = name;

+	opt->opt_val = value;

+

+	return opt;

+}

+

+XF86OptionPtr

+xf86nextOption(XF86OptionPtr list)

+{

+	if (!list)

+		return NULL;

+	return list->list.next;

+}

+

+/*

+ * this function searches the given option list for the named option and

+ * returns a pointer to the option rec if found. If not found, it returns

+ * NULL

+ */

+

+XF86OptionPtr

+xf86findOption (XF86OptionPtr list, const char *name)

+{

+	while (list)

+	{

+		if (xf86nameCompare (list->opt_name, name) == 0)

+			return list;

+		list = list->list.next;

+	}

+	return NULL;

+}

+

+/*

+ * this function searches the given option list for the named option. If

+ * found and the option has a parameter, a pointer to the parameter is

+ * returned.  If the option does not have a parameter an empty string is

+ * returned.  If the option is not found, a NULL is returned.

+ */

+

+char *

+xf86findOptionValue (XF86OptionPtr list, const char *name)

+{

+	XF86OptionPtr p = xf86findOption (list, name);

+

+	if (p)

+	{

+		if (p->opt_val)

+			return p->opt_val;

+		else

+			return "";

+	}

+	return NULL;

+}

+

+XF86OptionPtr

+xf86optionListCreate( const char **options, int count, int used )

+{

+	XF86OptionPtr p = NULL;

+	char *t1, *t2;

+	int i;

+

+	if (count == -1)

+	{

+		for (count = 0; options[count]; count++)

+			;

+	}

+	if( (count % 2) != 0 )

+	{

+		fprintf( stderr, "xf86optionListCreate: count must be an even number.\n" );

+		return NULL;

+	}

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

+	{

+		/* can't use strdup because it calls malloc */

+		t1 = malloc (sizeof (char) *

+				(strlen (options[i]) + 1));

+		strcpy (t1, options[i]);

+		t2 = malloc (sizeof (char) *

+				(strlen (options[i + 1]) + 1));

+		strcpy (t2, options[i + 1]);

+		p = addNewOption2 (p, t1, t2, used);

+	}

+

+	return p;

+}

+

+/* the 2 given lists are merged. If an option with the same name is present in

+ * both, the option from the user list - specified in the second argument -

+ * is used. The end result is a single valid list of options. Duplicates

+ * are freed, and the original lists are no longer guaranteed to be complete.

+ */

+XF86OptionPtr

+xf86optionListMerge (XF86OptionPtr head, XF86OptionPtr tail)

+{

+	XF86OptionPtr a, b, ap = NULL, bp = NULL;

+

+	a = tail;

+	b = head;

+	while (tail && b) {

+		if (xf86nameCompare (a->opt_name, b->opt_name) == 0) {

+			if (b == head)

+				head = a;

+			else

+				bp->list.next = a;

+			if (a == tail)

+				tail = a->list.next;

+			else

+				ap->list.next = a->list.next;

+			a->list.next = b->list.next;

+			b->list.next = NULL;

+			xf86optionListFree (b);

+			b = a->list.next;

+			bp = a;

+			a = tail;

+			ap = NULL;

+		} else {

+			ap = a;

+			if (!(a = a->list.next)) {

+				a = tail;

+				bp = b;

+				b = b->list.next;

+				ap = NULL;

+			}

+		}

+	}

+

+	if (head) {

+		for (a = head; a->list.next; a = a->list.next)

+			;

+		a->list.next = tail;

+	} else 

+		head = tail;

+

+	return head;

+}

+

+char *

+xf86uLongToString(unsigned long i)

+{

+	char *s;

+	int l;

+

+	l = ceil(log10((double)i) + 2.5);

+	s = malloc(l);

+	if (!s)

+		return NULL;

+	sprintf(s, "%lu", i);

+	return s;

+}

+

+XF86OptionPtr

+xf86parseOption(XF86OptionPtr head)

+{

+	XF86OptionPtr option, cnew, old;

+	char *name, *comment = NULL;

+	int token;

+

+	if ((token = xf86getSubToken(&comment)) != STRING) {

+		xf86parseError(BAD_OPTION_MSG, NULL);

+		free(comment);

+		return head;

+	}

+

+	name = val.str;

+	if ((token = xf86getSubToken(&comment)) == STRING) {

+		option = xf86newOption(name, val.str);

+		option->opt_comment = comment;

+		if ((token = xf86getToken(NULL)) == COMMENT)

+			option->opt_comment = xf86addComment(option->opt_comment, val.str);

+		else

+			xf86unGetToken(token);

+	}

+	else {

+		option = xf86newOption(name, NULL);

+		option->opt_comment = comment;

+		if (token == COMMENT)

+			option->opt_comment = xf86addComment(option->opt_comment, val.str);

+		else

+			xf86unGetToken(token);

+	}

+

+	old = NULL;

+

+	/* Don't allow duplicates */

+	if (head != NULL && (old = xf86findOption(head, name)) != NULL) {

+		cnew = old;

+		free(option->opt_name);

+		TestFree(option->opt_val);

+		TestFree(option->opt_comment);

+		free(option);

+	}

+	else

+		cnew = option;

+	

+	if (old == NULL)

+		return ((XF86OptionPtr)xf86addListItem((glp)head, (glp)cnew));

+

+	return head;

+}

+

+void

+xf86printOptionList(FILE *fp, XF86OptionPtr list, int tabs)

+{

+	int i;

+

+	if (!list)

+		return;

+	while (list) {

+		for (i = 0; i < tabs; i++)

+			fputc('\t', fp);

+		if (list->opt_val)

+			fprintf(fp, "Option	    \"%s\" \"%s\"", list->opt_name, list->opt_val);

+		else

+			fprintf(fp, "Option	    \"%s\"", list->opt_name);

+		if (list->opt_comment)

+			fprintf(fp, "%s", list->opt_comment);

+		else

+			fputc('\n', fp);

+		list = list->list.next;

+	}

+}

diff --git a/xorg-server/hw/xfree86/parser/Input.c b/xorg-server/hw/xfree86/parser/Input.c
index 8c8e46fb4..8adbee9ae 100644
--- a/xorg-server/hw/xfree86/parser/Input.c
+++ b/xorg-server/hw/xfree86/parser/Input.c
@@ -1,210 +1,210 @@
-/* 
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Parser.h"
-#include "xf86tokens.h"
-#include "Configint.h"
-
-extern LexRec val;
-
-static
-xf86ConfigSymTabRec InputTab[] =
-{
-	{ENDSECTION, "endsection"},
-	{IDENTIFIER, "identifier"},
-	{OPTION, "option"},
-	{DRIVER, "driver"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeInputList
-
-XF86ConfInputPtr
-xf86parseInputSection (void)
-{
-	int has_ident = FALSE;
-	int token;
-	parsePrologue (XF86ConfInputPtr, XF86ConfInputRec)
-
-	while ((token = xf86getToken (InputTab)) != ENDSECTION)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->inp_comment = xf86addComment(ptr->inp_comment, val.str);
-			break;
-		case IDENTIFIER:
-			if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
-				Error (QUOTE_MSG, "Identifier");
-			if (has_ident == TRUE)
-				Error (MULTIPLE_MSG, "Identifier");
-			ptr->inp_identifier = val.str;
-			has_ident = TRUE;
-			break;
-		case DRIVER:
-			if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
-				Error (QUOTE_MSG, "Driver");
-                        if (strcmp(val.str, "keyboard") == 0)
-                            ptr->inp_driver = "kbd";
-                        else
-			    ptr->inp_driver = val.str;
-			break;
-		case OPTION:
-			ptr->inp_option_lst = xf86parseOption(ptr->inp_option_lst);
-			break;
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-			break;
-		}
-	}
-
-	if (!has_ident)
-		Error (NO_IDENT_MSG, NULL);
-
-#ifdef DEBUG
-	printf ("InputDevice section parsed\n");
-#endif
-
-	return ptr;
-}
-
-#undef CLEANUP
-
-void
-xf86printInputSection (FILE * cf, XF86ConfInputPtr ptr)
-{
-	while (ptr)
-	{
-		fprintf (cf, "Section \"InputDevice\"\n");
-		if (ptr->inp_comment)
-			fprintf (cf, "%s", ptr->inp_comment);
-		if (ptr->inp_identifier)
-			fprintf (cf, "\tIdentifier  \"%s\"\n", ptr->inp_identifier);
-		if (ptr->inp_driver)
-			fprintf (cf, "\tDriver      \"%s\"\n", ptr->inp_driver);
-		xf86printOptionList(cf, ptr->inp_option_lst, 1);
-		fprintf (cf, "EndSection\n\n");
-		ptr = ptr->list.next;
-	}
-}
-
-void
-xf86freeInputList (XF86ConfInputPtr ptr)
-{
-	XF86ConfInputPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->inp_identifier);
-		TestFree (ptr->inp_driver);
-		TestFree (ptr->inp_comment);
-		xf86optionListFree (ptr->inp_option_lst);
-
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-int
-xf86validateInput (XF86ConfigPtr p)
-{
-	XF86ConfInputPtr input = p->conf_input_lst;
-
-	while (input) {
-		if (!input->inp_driver) {
-			xf86validationError (UNDEFINED_INPUTDRIVER_MSG, input->inp_identifier);
-			return (FALSE);
-		}
-		input = input->list.next;
-	}
-	return (TRUE);
-}
-
-XF86ConfInputPtr
-xf86findInput (const char *ident, XF86ConfInputPtr p)
-{
-	while (p)
-	{
-		if (xf86nameCompare (ident, p->inp_identifier) == 0)
-			return (p);
-
-		p = p->list.next;
-	}
-	return (NULL);
-}
-
-XF86ConfInputPtr
-xf86findInputByDriver (const char *driver, XF86ConfInputPtr p)
-{
-	while (p)
-	{
-		if (xf86nameCompare (driver, p->inp_driver) == 0)
-			return (p);
-
-		p = p->list.next;
-	}
-	return (NULL);
-}
-
+/* 

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86Parser.h"

+#include "xf86tokens.h"

+#include "Configint.h"

+

+extern LexRec val;

+

+static

+xf86ConfigSymTabRec InputTab[] =

+{

+	{ENDSECTION, "endsection"},

+	{IDENTIFIER, "identifier"},

+	{OPTION, "option"},

+	{DRIVER, "driver"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeInputList

+

+XF86ConfInputPtr

+xf86parseInputSection (void)

+{

+	int has_ident = FALSE;

+	int token;

+	parsePrologue (XF86ConfInputPtr, XF86ConfInputRec)

+

+	while ((token = xf86getToken (InputTab)) != ENDSECTION)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->inp_comment = xf86addComment(ptr->inp_comment, val.str);

+			break;

+		case IDENTIFIER:

+			if (xf86getSubToken (&(ptr->inp_comment)) != STRING)

+				Error (QUOTE_MSG, "Identifier");

+			if (has_ident == TRUE)

+				Error (MULTIPLE_MSG, "Identifier");

+			ptr->inp_identifier = val.str;

+			has_ident = TRUE;

+			break;

+		case DRIVER:

+			if (xf86getSubToken (&(ptr->inp_comment)) != STRING)

+				Error (QUOTE_MSG, "Driver");

+                        if (strcmp(val.str, "keyboard") == 0)

+                            ptr->inp_driver = "kbd";

+                        else

+			    ptr->inp_driver = val.str;

+			break;

+		case OPTION:

+			ptr->inp_option_lst = xf86parseOption(ptr->inp_option_lst);

+			break;

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+			break;

+		}

+	}

+

+	if (!has_ident)

+		Error (NO_IDENT_MSG, NULL);

+

+#ifdef DEBUG

+	printf ("InputDevice section parsed\n");

+#endif

+

+	return ptr;

+}

+

+#undef CLEANUP

+

+void

+xf86printInputSection (FILE * cf, XF86ConfInputPtr ptr)

+{

+	while (ptr)

+	{

+		fprintf (cf, "Section \"InputDevice\"\n");

+		if (ptr->inp_comment)

+			fprintf (cf, "%s", ptr->inp_comment);

+		if (ptr->inp_identifier)

+			fprintf (cf, "\tIdentifier  \"%s\"\n", ptr->inp_identifier);

+		if (ptr->inp_driver)

+			fprintf (cf, "\tDriver      \"%s\"\n", ptr->inp_driver);

+		xf86printOptionList(cf, ptr->inp_option_lst, 1);

+		fprintf (cf, "EndSection\n\n");

+		ptr = ptr->list.next;

+	}

+}

+

+void

+xf86freeInputList (XF86ConfInputPtr ptr)

+{

+	XF86ConfInputPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->inp_identifier);

+		TestFree (ptr->inp_driver);

+		TestFree (ptr->inp_comment);

+		xf86optionListFree (ptr->inp_option_lst);

+

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+int

+xf86validateInput (XF86ConfigPtr p)

+{

+	XF86ConfInputPtr input = p->conf_input_lst;

+

+	while (input) {

+		if (!input->inp_driver) {

+			xf86validationError (UNDEFINED_INPUTDRIVER_MSG, input->inp_identifier);

+			return FALSE;

+		}

+		input = input->list.next;

+	}

+	return TRUE;

+}

+

+XF86ConfInputPtr

+xf86findInput (const char *ident, XF86ConfInputPtr p)

+{

+	while (p)

+	{

+		if (xf86nameCompare (ident, p->inp_identifier) == 0)

+			return p;

+

+		p = p->list.next;

+	}

+	return NULL;

+}

+

+XF86ConfInputPtr

+xf86findInputByDriver (const char *driver, XF86ConfInputPtr p)

+{

+	while (p)

+	{

+		if (xf86nameCompare (driver, p->inp_driver) == 0)

+			return p;

+

+		p = p->list.next;

+	}

+	return NULL;

+}

+

diff --git a/xorg-server/hw/xfree86/parser/InputClass.c b/xorg-server/hw/xfree86/parser/InputClass.c
index 7fb2866cd..85161c38a 100644
--- a/xorg-server/hw/xfree86/parser/InputClass.c
+++ b/xorg-server/hw/xfree86/parser/InputClass.c
@@ -1,288 +1,401 @@
-/*
- * Copyright (c) 2009 Dan Nicholson
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <string.h>
-#include "os.h"
-#include "xf86Parser.h"
-#include "xf86tokens.h"
-#include "Configint.h"
-
-extern LexRec val;
-
-static
-xf86ConfigSymTabRec InputClassTab[] =
-{
-    {ENDSECTION, "endsection"},
-    {IDENTIFIER, "identifier"},
-    {OPTION, "option"},
-    {DRIVER, "driver"},
-    {MATCH_PRODUCT, "matchproduct"},
-    {MATCH_VENDOR, "matchvendor"},
-    {MATCH_DEVICE_PATH, "matchdevicepath"},
-    {MATCH_TAG, "matchtag"},
-    {MATCH_IS_KEYBOARD, "matchiskeyboard"},
-    {MATCH_IS_POINTER, "matchispointer"},
-    {MATCH_IS_JOYSTICK, "matchisjoystick"},
-    {MATCH_IS_TABLET, "matchistablet"},
-    {MATCH_IS_TOUCHPAD, "matchistouchpad"},
-    {MATCH_IS_TOUCHSCREEN, "matchistouchscreen"},
-    {-1, ""},
-};
-
-#define CLEANUP xf86freeInputClassList
-
-#define TOKEN_SEP "|"
-
-XF86ConfInputClassPtr
-xf86parseInputClassSection(void)
-{
-    int has_ident = FALSE;
-    int token;
-
-    parsePrologue(XF86ConfInputClassPtr, XF86ConfInputClassRec)
-
-    while ((token = xf86getToken(InputClassTab)) != ENDSECTION) {
-        switch (token) {
-        case COMMENT:
-            ptr->comment = xf86addComment(ptr->comment, val.str);
-            break;
-        case IDENTIFIER:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "Identifier");
-            if (has_ident == TRUE)
-                Error(MULTIPLE_MSG, "Identifier");
-            ptr->identifier = val.str;
-            has_ident = TRUE;
-            break;
-        case DRIVER:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "Driver");
-            if (strcmp(val.str, "keyboard") == 0)
-                ptr->driver = "kbd";
-            else
-                ptr->driver = val.str;
-            break;
-        case OPTION:
-            ptr->option_lst = xf86parseOption(ptr->option_lst);
-            break;
-        case MATCH_PRODUCT:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchProduct");
-            ptr->match_product = xstrtokenize(val.str, TOKEN_SEP);
-            break;
-        case MATCH_VENDOR:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchVendor");
-            ptr->match_vendor = xstrtokenize(val.str, TOKEN_SEP);
-            break;
-        case MATCH_DEVICE_PATH:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchDevicePath");
-            ptr->match_device = xstrtokenize(val.str, TOKEN_SEP);
-            break;
-        case MATCH_TAG:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchTag");
-            ptr->match_tag = xstrtokenize(val.str, TOKEN_SEP);
-            break;
-        case MATCH_IS_KEYBOARD:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchIsKeyboard");
-            ptr->is_keyboard.set = xf86getBoolValue(&ptr->is_keyboard.val,
-                                                    val.str);
-            if (!ptr->is_keyboard.set)
-                Error(BOOL_MSG, "MatchIsKeyboard");
-            break;
-        case MATCH_IS_POINTER:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchIsPointer");
-            ptr->is_pointer.set = xf86getBoolValue(&ptr->is_pointer.val,
-                                                   val.str);
-            if (!ptr->is_pointer.set)
-                Error(BOOL_MSG, "MatchIsPointer");
-            break;
-        case MATCH_IS_JOYSTICK:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchIsJoystick");
-            ptr->is_joystick.set = xf86getBoolValue(&ptr->is_joystick.val,
-                                                    val.str);
-            if (!ptr->is_joystick.set)
-                Error(BOOL_MSG, "MatchIsJoystick");
-            break;
-        case MATCH_IS_TABLET:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchIsTablet");
-            ptr->is_tablet.set = xf86getBoolValue(&ptr->is_tablet.val,
-                                                  val.str);
-            if (!ptr->is_tablet.set)
-                Error(BOOL_MSG, "MatchIsTablet");
-            break;
-        case MATCH_IS_TOUCHPAD:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchIsTouchpad");
-            ptr->is_touchpad.set = xf86getBoolValue(&ptr->is_touchpad.val,
-                                                    val.str);
-            if (!ptr->is_touchpad.set)
-                Error(BOOL_MSG, "MatchIsTouchpad");
-            break;
-        case MATCH_IS_TOUCHSCREEN:
-            if (xf86getSubToken(&(ptr->comment)) != STRING)
-                Error(QUOTE_MSG, "MatchIsTouchscreen");
-            ptr->is_touchscreen.set = xf86getBoolValue(&ptr->is_touchscreen.val,
-                                                       val.str);
-            if (!ptr->is_touchscreen.set)
-                Error(BOOL_MSG, "MatchIsTouchscreen");
-            break;
-        case EOF_TOKEN:
-            Error(UNEXPECTED_EOF_MSG, NULL);
-            break;
-        default:
-            Error(INVALID_KEYWORD_MSG, xf86tokenString ());
-            break;
-        }
-    }
-
-    if (!has_ident)
-        Error(NO_IDENT_MSG, NULL);
-
-#ifdef DEBUG
-    printf("InputClass section parsed\n");
-#endif
-
-    return ptr;
-}
-
-void
-xf86printInputClassSection (FILE * cf, XF86ConfInputClassPtr ptr)
-{
-    char **list;
-
-    while (ptr) {
-        fprintf(cf, "Section \"InputClass\"\n");
-        if (ptr->comment)
-            fprintf(cf, "%s", ptr->comment);
-        if (ptr->identifier)
-            fprintf(cf, "\tIdentifier      \"%s\"\n", ptr->identifier);
-        if (ptr->driver)
-            fprintf(cf, "\tDriver          \"%s\"\n", ptr->driver);
-        if (ptr->match_product) {
-            fprintf(cf, "\tMatchProduct    \"");
-            for (list = ptr->match_product; *list; list++)
-                fprintf(cf, "%s%s",
-                        list == ptr->match_product ? "" : TOKEN_SEP,
-                        *list);
-            fprintf(cf, "\"\n");
-        }
-        if (ptr->match_vendor) {
-            fprintf(cf, "\tMatchVendor     \"");
-            for (list = ptr->match_vendor; *list; list++)
-                fprintf(cf, "%s%s",
-                        list == ptr->match_vendor ? "" : TOKEN_SEP,
-                        *list);
-            fprintf(cf, "\"\n");
-        }
-        if (ptr->match_device) {
-            fprintf(cf, "\tMatchDevicePath \"");
-            for (list = ptr->match_device; *list; list++)
-                fprintf(cf, "%s%s",
-                        list == ptr->match_device ? "" : TOKEN_SEP,
-                        *list);
-            fprintf(cf, "\"\n");
-        }
-        if (ptr->match_tag) {
-            fprintf(cf, "\tMatchTag \"");
-            for (list = ptr->match_tag; *list; list++)
-                fprintf(cf, "%s%s",
-                        list == ptr->match_tag ? "" : TOKEN_SEP,
-                        *list);
-            fprintf(cf, "\"\n");
-        }
-        if (ptr->is_keyboard.set)
-            fprintf(cf, "\tIsKeyboard      \"%s\"\n",
-                    ptr->is_keyboard.val ? "yes" : "no");
-        if (ptr->is_pointer.set)
-            fprintf(cf, "\tIsPointer       \"%s\"\n",
-                    ptr->is_pointer.val ? "yes" : "no");
-        if (ptr->is_joystick.set)
-            fprintf(cf, "\tIsJoystick      \"%s\"\n",
-                    ptr->is_joystick.val ? "yes" : "no");
-        if (ptr->is_tablet.set)
-            fprintf(cf, "\tIsTablet        \"%s\"\n",
-                    ptr->is_tablet.val ? "yes" : "no");
-        if (ptr->is_touchpad.set)
-            fprintf(cf, "\tIsTouchpad      \"%s\"\n",
-                    ptr->is_touchpad.val ? "yes" : "no");
-        if (ptr->is_touchscreen.set)
-            fprintf(cf, "\tIsTouchscreen   \"%s\"\n",
-                    ptr->is_touchscreen.val ? "yes" : "no");
-        xf86printOptionList(cf, ptr->option_lst, 1);
-        fprintf(cf, "EndSection\n\n");
-        ptr = ptr->list.next;
-    }
-}
-
-void
-xf86freeInputClassList (XF86ConfInputClassPtr ptr)
-{
-    XF86ConfInputClassPtr prev;
-    char **list;
-
-    while (ptr) {
-        TestFree(ptr->identifier);
-        TestFree(ptr->driver);
-        if (ptr->match_product) {
-            for (list = ptr->match_product; *list; list++)
-                free(*list);
-            free(ptr->match_product);
-        }
-        if (ptr->match_vendor) {
-            for (list = ptr->match_vendor; *list; list++)
-                free(*list);
-            free(ptr->match_vendor);
-        }
-        if (ptr->match_device) {
-            for (list = ptr->match_device; *list; list++)
-                free(*list);
-            free(ptr->match_device);
-        }
-        if (ptr->match_tag) {
-            for (list = ptr->match_tag; *list; list++)
-                free(*list);
-            free(ptr->match_tag);
-        }
-        TestFree(ptr->comment);
-        xf86optionListFree(ptr->option_lst);
-
-        prev = ptr;
-        ptr = ptr->list.next;
-        free(prev);
-    }
-}
+/*

+ * Copyright (c) 2009 Dan Nicholson

+ *

+ * Permission is hereby granted, free of charge, to any person

+ * obtaining a copy of this software and associated documentation

+ * files (the "Software"), to deal in the Software without

+ * restriction, including without limitation the rights to use,

+ * copy, modify, merge, publish, distribute, sublicense, and/or sell

+ * copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following

+ * conditions:

+ *

+ * The above copyright notice and this permission notice shall be

+ * included in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ */

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <string.h>

+#include "os.h"

+#include "xf86Parser.h"

+#include "xf86tokens.h"

+#include "Configint.h"

+

+extern LexRec val;

+

+static

+xf86ConfigSymTabRec InputClassTab[] =

+{

+    {ENDSECTION, "endsection"},

+    {IDENTIFIER, "identifier"},

+    {OPTION, "option"},

+    {DRIVER, "driver"},

+    {MATCH_PRODUCT, "matchproduct"},

+    {MATCH_VENDOR, "matchvendor"},

+    {MATCH_DEVICE_PATH, "matchdevicepath"},

+    {MATCH_OS, "matchos"},

+    {MATCH_PNPID, "matchpnpid"},

+    {MATCH_USBID, "matchusbid"},

+    {MATCH_DRIVER, "matchdriver"},

+    {MATCH_TAG, "matchtag"},

+    {MATCH_IS_KEYBOARD, "matchiskeyboard"},

+    {MATCH_IS_POINTER, "matchispointer"},

+    {MATCH_IS_JOYSTICK, "matchisjoystick"},

+    {MATCH_IS_TABLET, "matchistablet"},

+    {MATCH_IS_TOUCHPAD, "matchistouchpad"},

+    {MATCH_IS_TOUCHSCREEN, "matchistouchscreen"},

+    {-1, ""},

+};

+

+#define CLEANUP xf86freeInputClassList

+

+#define TOKEN_SEP "|"

+

+static void

+add_group_entry(struct list *head, char **values)

+{

+    xf86MatchGroup *group;

+

+    group = malloc(sizeof(*group));

+    if (group) {

+        group->values = values;

+        list_add(&group->entry, head);

+    }

+}

+

+XF86ConfInputClassPtr

+xf86parseInputClassSection(void)

+{

+    int has_ident = FALSE;

+    int token;

+

+    parsePrologue(XF86ConfInputClassPtr, XF86ConfInputClassRec)

+

+    /* Initialize MatchGroup lists */

+    list_init(&ptr->match_product);

+    list_init(&ptr->match_vendor);

+    list_init(&ptr->match_device);

+    list_init(&ptr->match_os);

+    list_init(&ptr->match_pnpid);

+    list_init(&ptr->match_usbid);

+    list_init(&ptr->match_driver);

+    list_init(&ptr->match_tag);

+

+    while ((token = xf86getToken(InputClassTab)) != ENDSECTION) {

+        switch (token) {

+        case COMMENT:

+            ptr->comment = xf86addComment(ptr->comment, val.str);

+            break;

+        case IDENTIFIER:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "Identifier");

+            if (has_ident == TRUE)

+                Error(MULTIPLE_MSG, "Identifier");

+            ptr->identifier = val.str;

+            has_ident = TRUE;

+            break;

+        case DRIVER:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "Driver");

+            if (strcmp(val.str, "keyboard") == 0)

+                ptr->driver = "kbd";

+            else

+                ptr->driver = val.str;

+            break;

+        case OPTION:

+            ptr->option_lst = xf86parseOption(ptr->option_lst);

+            break;

+        case MATCH_PRODUCT:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchProduct");

+            add_group_entry(&ptr->match_product,

+                            xstrtokenize(val.str, TOKEN_SEP));

+            break;

+        case MATCH_VENDOR:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchVendor");

+            add_group_entry(&ptr->match_vendor,

+                            xstrtokenize(val.str, TOKEN_SEP));

+            break;

+        case MATCH_DEVICE_PATH:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchDevicePath");

+            add_group_entry(&ptr->match_device,

+                            xstrtokenize(val.str, TOKEN_SEP));

+            break;

+        case MATCH_OS:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchOS");

+            add_group_entry(&ptr->match_os,

+                            xstrtokenize(val.str, TOKEN_SEP));

+            break;

+        case MATCH_PNPID:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchPnPID");

+            add_group_entry(&ptr->match_pnpid,

+                            xstrtokenize(val.str, TOKEN_SEP));

+            break;

+        case MATCH_USBID:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchUSBID");

+            add_group_entry(&ptr->match_usbid,

+                            xstrtokenize(val.str, TOKEN_SEP));

+            break;

+        case MATCH_DRIVER:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchDriver");

+            add_group_entry(&ptr->match_driver,

+                            xstrtokenize(val.str, TOKEN_SEP));

+            break;

+        case MATCH_TAG:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchTag");

+            add_group_entry(&ptr->match_tag,

+                            xstrtokenize(val.str, TOKEN_SEP));

+            break;

+        case MATCH_IS_KEYBOARD:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchIsKeyboard");

+            ptr->is_keyboard.set = xf86getBoolValue(&ptr->is_keyboard.val,

+                                                    val.str);

+            if (!ptr->is_keyboard.set)

+                Error(BOOL_MSG, "MatchIsKeyboard");

+            break;

+        case MATCH_IS_POINTER:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchIsPointer");

+            ptr->is_pointer.set = xf86getBoolValue(&ptr->is_pointer.val,

+                                                   val.str);

+            if (!ptr->is_pointer.set)

+                Error(BOOL_MSG, "MatchIsPointer");

+            break;

+        case MATCH_IS_JOYSTICK:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchIsJoystick");

+            ptr->is_joystick.set = xf86getBoolValue(&ptr->is_joystick.val,

+                                                    val.str);

+            if (!ptr->is_joystick.set)

+                Error(BOOL_MSG, "MatchIsJoystick");

+            break;

+        case MATCH_IS_TABLET:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchIsTablet");

+            ptr->is_tablet.set = xf86getBoolValue(&ptr->is_tablet.val,

+                                                  val.str);

+            if (!ptr->is_tablet.set)

+                Error(BOOL_MSG, "MatchIsTablet");

+            break;

+        case MATCH_IS_TOUCHPAD:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchIsTouchpad");

+            ptr->is_touchpad.set = xf86getBoolValue(&ptr->is_touchpad.val,

+                                                    val.str);

+            if (!ptr->is_touchpad.set)

+                Error(BOOL_MSG, "MatchIsTouchpad");

+            break;

+        case MATCH_IS_TOUCHSCREEN:

+            if (xf86getSubToken(&(ptr->comment)) != STRING)

+                Error(QUOTE_MSG, "MatchIsTouchscreen");

+            ptr->is_touchscreen.set = xf86getBoolValue(&ptr->is_touchscreen.val,

+                                                       val.str);

+            if (!ptr->is_touchscreen.set)

+                Error(BOOL_MSG, "MatchIsTouchscreen");

+            break;

+        case EOF_TOKEN:

+            Error(UNEXPECTED_EOF_MSG, NULL);

+            break;

+        default:

+            Error(INVALID_KEYWORD_MSG, xf86tokenString ());

+            break;

+        }

+    }

+

+    if (!has_ident)

+        Error(NO_IDENT_MSG, NULL);

+

+#ifdef DEBUG

+    printf("InputClass section parsed\n");

+#endif

+

+    return ptr;

+}

+

+void

+xf86printInputClassSection (FILE * cf, XF86ConfInputClassPtr ptr)

+{

+    const xf86MatchGroup *group;

+    char * const *cur;

+

+    while (ptr) {

+        fprintf(cf, "Section \"InputClass\"\n");

+        if (ptr->comment)

+            fprintf(cf, "%s", ptr->comment);

+        if (ptr->identifier)

+            fprintf(cf, "\tIdentifier      \"%s\"\n", ptr->identifier);

+        if (ptr->driver)

+            fprintf(cf, "\tDriver          \"%s\"\n", ptr->driver);

+

+        list_for_each_entry(group, &ptr->match_product, entry) {

+            fprintf(cf, "\tMatchProduct    \"");

+            for (cur = group->values; *cur; cur++)

+                fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,

+                        *cur);

+            fprintf(cf, "\"\n");

+        }

+        list_for_each_entry(group, &ptr->match_vendor, entry) {

+            fprintf(cf, "\tMatchVendor     \"");

+            for (cur = group->values; *cur; cur++)

+                fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,

+                        *cur);

+            fprintf(cf, "\"\n");

+        }

+        list_for_each_entry(group, &ptr->match_device, entry) {

+            fprintf(cf, "\tMatchDevicePath \"");

+            for (cur = group->values; *cur; cur++)

+                fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,

+                        *cur);

+            fprintf(cf, "\"\n");

+        }

+        list_for_each_entry(group, &ptr->match_os, entry) {

+            fprintf(cf, "\tMatchOS         \"");

+            for (cur = group->values; *cur; cur++)

+                fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,

+                        *cur);

+            fprintf(cf, "\"\n");

+        }

+        list_for_each_entry(group, &ptr->match_pnpid, entry) {

+            fprintf(cf, "\tMatchPnPID      \"");

+            for (cur = group->values; *cur; cur++)

+                fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,

+                        *cur);

+            fprintf(cf, "\"\n");

+        }

+        list_for_each_entry(group, &ptr->match_usbid, entry) {

+            fprintf(cf, "\tMatchUSBID      \"");

+            for (cur = group->values; *cur; cur++)

+                fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,

+                        *cur);

+            fprintf(cf, "\"\n");

+        }

+        list_for_each_entry(group, &ptr->match_driver, entry) {

+            fprintf(cf, "\tMatchDriver     \"");

+            for (cur = group->values; *cur; cur++)

+                fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,

+                        *cur);

+            fprintf(cf, "\"\n");

+        }

+        list_for_each_entry(group, &ptr->match_tag, entry) {

+            fprintf(cf, "\tMatchTag        \"");

+            for (cur = group->values; *cur; cur++)

+                fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,

+                        *cur);

+            fprintf(cf, "\"\n");

+        }

+

+        if (ptr->is_keyboard.set)

+            fprintf(cf, "\tIsKeyboard      \"%s\"\n",

+                    ptr->is_keyboard.val ? "yes" : "no");

+        if (ptr->is_pointer.set)

+            fprintf(cf, "\tIsPointer       \"%s\"\n",

+                    ptr->is_pointer.val ? "yes" : "no");

+        if (ptr->is_joystick.set)

+            fprintf(cf, "\tIsJoystick      \"%s\"\n",

+                    ptr->is_joystick.val ? "yes" : "no");

+        if (ptr->is_tablet.set)

+            fprintf(cf, "\tIsTablet        \"%s\"\n",

+                    ptr->is_tablet.val ? "yes" : "no");

+        if (ptr->is_touchpad.set)

+            fprintf(cf, "\tIsTouchpad      \"%s\"\n",

+                    ptr->is_touchpad.val ? "yes" : "no");

+        if (ptr->is_touchscreen.set)

+            fprintf(cf, "\tIsTouchscreen   \"%s\"\n",

+                    ptr->is_touchscreen.val ? "yes" : "no");

+        xf86printOptionList(cf, ptr->option_lst, 1);

+        fprintf(cf, "EndSection\n\n");

+        ptr = ptr->list.next;

+    }

+}

+

+void

+xf86freeInputClassList (XF86ConfInputClassPtr ptr)

+{

+    XF86ConfInputClassPtr prev;

+

+    while (ptr) {

+        xf86MatchGroup *group, *next;

+        char **list;

+

+        TestFree(ptr->identifier);

+        TestFree(ptr->driver);

+

+        list_for_each_entry_safe(group, next, &ptr->match_product, entry) {

+            list_del(&group->entry);

+            for (list = group->values; *list; list++)

+                free(*list);

+            free(group);

+        }

+        list_for_each_entry_safe(group, next, &ptr->match_vendor, entry) {

+            list_del(&group->entry);

+            for (list = group->values; *list; list++)

+                free(*list);

+            free(group);

+        }

+        list_for_each_entry_safe(group, next, &ptr->match_device, entry) {

+            list_del(&group->entry);

+            for (list = group->values; *list; list++)

+                free(*list);

+            free(group);

+        }

+        list_for_each_entry_safe(group, next, &ptr->match_os, entry) {

+            list_del(&group->entry);

+            for (list = group->values; *list; list++)

+                free(*list);

+            free(group);

+        }

+        list_for_each_entry_safe(group, next, &ptr->match_pnpid, entry) {

+            list_del(&group->entry);

+            for (list = group->values; *list; list++)

+                free(*list);

+            free(group);

+        }

+        list_for_each_entry_safe(group, next, &ptr->match_usbid, entry) {

+            list_del(&group->entry);

+            for (list = group->values; *list; list++)

+                free(*list);

+            free(group);

+        }

+        list_for_each_entry_safe(group, next, &ptr->match_driver, entry) {

+            list_del(&group->entry);

+            for (list = group->values; *list; list++)

+                free(*list);

+            free(group);

+        }

+        list_for_each_entry_safe(group, next, &ptr->match_tag, entry) {

+            list_del(&group->entry);

+            for (list = group->values; *list; list++)

+                free(*list);

+            free(group);

+        }

+

+        TestFree(ptr->comment);

+        xf86optionListFree(ptr->option_lst);

+

+        prev = ptr;

+        ptr = ptr->list.next;

+        free(prev);

+    }

+}

diff --git a/xorg-server/hw/xfree86/parser/Layout.c b/xorg-server/hw/xfree86/parser/Layout.c
index 00c1e7d09..60e83390f 100644
--- a/xorg-server/hw/xfree86/parser/Layout.c
+++ b/xorg-server/hw/xfree86/parser/Layout.c
@@ -1,558 +1,558 @@
-/* 
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Parser.h"
-#include "xf86tokens.h"
-#include "Configint.h"
-#include <string.h>
-
-
-/* Needed for auto server layout */
-extern int xf86CheckBoolOption(void* optlist, const char *name, int deflt);
-
-extern LexRec val;
-
-static xf86ConfigSymTabRec LayoutTab[] =
-{
-	{ENDSECTION, "endsection"},
-	{SCREEN, "screen"},
-	{IDENTIFIER, "identifier"},
-	{INACTIVE, "inactive"},
-	{INPUTDEVICE, "inputdevice"},
-	{OPTION, "option"},
-	{-1, ""},
-};
-
-static xf86ConfigSymTabRec AdjTab[] =
-{
-	{RIGHTOF, "rightof"},
-	{LEFTOF, "leftof"},
-	{ABOVE, "above"},
-	{BELOW, "below"},
-	{RELATIVE, "relative"},
-	{ABSOLUTE, "absolute"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeLayoutList
-
-XF86ConfLayoutPtr
-xf86parseLayoutSection (void)
-{
-	int has_ident = FALSE;
-	int token;
-	parsePrologue (XF86ConfLayoutPtr, XF86ConfLayoutRec)
-
-	while ((token = xf86getToken (LayoutTab)) != ENDSECTION)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->lay_comment = xf86addComment(ptr->lay_comment, val.str);
-			break;
-		case IDENTIFIER:
-			if (xf86getSubToken (&(ptr->lay_comment)) != STRING)
-				Error (QUOTE_MSG, "Identifier");
-			if (has_ident == TRUE)
-				Error (MULTIPLE_MSG, "Identifier");
-			ptr->lay_identifier = val.str;
-			has_ident = TRUE;
-			break;
-		case INACTIVE:
-			{
-				XF86ConfInactivePtr iptr;
-
-				iptr = calloc (1, sizeof (XF86ConfInactiveRec));
-				iptr->list.next = NULL;
-				if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {
-					free (iptr);
-					Error (INACTIVE_MSG, NULL);
-				}
-				iptr->inactive_device_str = val.str;
-				ptr->lay_inactive_lst = (XF86ConfInactivePtr)
-					xf86addListItem ((glp) ptr->lay_inactive_lst, (glp) iptr);
-			}
-			break;
-		case SCREEN:
-			{
-				XF86ConfAdjacencyPtr aptr;
-				int absKeyword = 0;
-
-				aptr = calloc (1, sizeof (XF86ConfAdjacencyRec));
-				aptr->list.next = NULL;
-				aptr->adj_scrnum = -1;
-				aptr->adj_where = CONF_ADJ_OBSOLETE;
-				aptr->adj_x = 0;
-				aptr->adj_y = 0;
-				aptr->adj_refscreen = NULL;
-				if ((token = xf86getSubToken (&(ptr->lay_comment))) == NUMBER)
-					aptr->adj_scrnum = val.num;
-				else
-					xf86unGetToken (token);
-				token = xf86getSubToken(&(ptr->lay_comment));
-				if (token != STRING) {
-					free(aptr);
-					Error (SCREEN_MSG, NULL);
-				}
-				aptr->adj_screen_str = val.str;
-
-				token = xf86getSubTokenWithTab(&(ptr->lay_comment), AdjTab);
-				switch (token)
-				{
-				case RIGHTOF:
-					aptr->adj_where = CONF_ADJ_RIGHTOF;
-					break;
-				case LEFTOF:
-					aptr->adj_where = CONF_ADJ_LEFTOF;
-					break;
-				case ABOVE:
-					aptr->adj_where = CONF_ADJ_ABOVE;
-					break;
-				case BELOW:
-					aptr->adj_where = CONF_ADJ_BELOW;
-					break;
-				case RELATIVE:
-					aptr->adj_where = CONF_ADJ_RELATIVE;
-					break;
-				case ABSOLUTE:
-					aptr->adj_where = CONF_ADJ_ABSOLUTE;
-					absKeyword = 1;
-					break;
-				case EOF_TOKEN:
-					free(aptr);
-					Error (UNEXPECTED_EOF_MSG, NULL);
-					break;
-				default:
-					xf86unGetToken (token);
-					token = xf86getSubToken(&(ptr->lay_comment));
-					if (token == STRING)
-						aptr->adj_where = CONF_ADJ_OBSOLETE;
-					else
-						aptr->adj_where = CONF_ADJ_ABSOLUTE;
-				}
-				switch (aptr->adj_where)
-				{
-				case CONF_ADJ_ABSOLUTE:
-					if (absKeyword) 
-						token = xf86getSubToken(&(ptr->lay_comment));
-					if (token == NUMBER)
-					{
-						aptr->adj_x = val.num;
-						token = xf86getSubToken(&(ptr->lay_comment));
-						if (token != NUMBER) {
-							free(aptr);
-							Error(INVALID_SCR_MSG, NULL);
-						}
-						aptr->adj_y = val.num;
-					} else {
-						if (absKeyword) {
-							free(aptr);
-							Error(INVALID_SCR_MSG, NULL);
-						} else
-							xf86unGetToken (token);
-					}
-					break;
-				case CONF_ADJ_RIGHTOF:
-				case CONF_ADJ_LEFTOF:
-				case CONF_ADJ_ABOVE:
-				case CONF_ADJ_BELOW:
-				case CONF_ADJ_RELATIVE:
-					token = xf86getSubToken(&(ptr->lay_comment));
-					if (token != STRING) {
-						free(aptr);
-						Error(INVALID_SCR_MSG, NULL);
-					}
-					aptr->adj_refscreen = val.str;
-					if (aptr->adj_where == CONF_ADJ_RELATIVE)
-					{
-						token = xf86getSubToken(&(ptr->lay_comment));
-						if (token != NUMBER) {
-							free(aptr);
-							Error(INVALID_SCR_MSG, NULL);
-						}
-						aptr->adj_x = val.num;
-						token = xf86getSubToken(&(ptr->lay_comment));
-						if (token != NUMBER) {
-							free(aptr);
-							Error(INVALID_SCR_MSG, NULL);
-						}
-						aptr->adj_y = val.num;
-					}
-					break;
-				case CONF_ADJ_OBSOLETE:
-					/* top */
-					aptr->adj_top_str = val.str;
-
-					/* bottom */
-					if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {
-						free(aptr);
-						Error (SCREEN_MSG, NULL);
-					}
-					aptr->adj_bottom_str = val.str;
-
-					/* left */
-					if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {
-						free(aptr);
-						Error (SCREEN_MSG, NULL);
-					}
-					aptr->adj_left_str = val.str;
-
-					/* right */
-					if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {
-						free(aptr);
-						Error (SCREEN_MSG, NULL);
-					}
-					aptr->adj_right_str = val.str;
-
-				}
-				ptr->lay_adjacency_lst = (XF86ConfAdjacencyPtr)
-					xf86addListItem ((glp) ptr->lay_adjacency_lst, (glp) aptr);
-			}
-			break;
-		case INPUTDEVICE:
-			{
-				XF86ConfInputrefPtr iptr;
-
-				iptr = calloc (1, sizeof (XF86ConfInputrefRec));
-				iptr->list.next = NULL;
-				iptr->iref_option_lst = NULL;
-				if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {
-					free(iptr);
-					Error (INPUTDEV_MSG, NULL);
-				}
-				iptr->iref_inputdev_str = val.str;
-				while ((token = xf86getSubToken (&(ptr->lay_comment))) == STRING)
-				{
-					iptr->iref_option_lst =
-						xf86addNewOption (iptr->iref_option_lst, val.str, NULL);
-				}
-				xf86unGetToken (token);
-				ptr->lay_input_lst = (XF86ConfInputrefPtr)
-					xf86addListItem ((glp) ptr->lay_input_lst, (glp) iptr);
-			}
-			break;
-		case OPTION:
-			ptr->lay_option_lst = xf86parseOption(ptr->lay_option_lst);
-			break;
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-			break;
-		}
-	}
-
-	if (!has_ident)
-		Error (NO_IDENT_MSG, NULL);
-
-#ifdef DEBUG
-	printf ("Layout section parsed\n");
-#endif
-
-	return ptr;
-}
-
-#undef CLEANUP
-
-void
-xf86printLayoutSection (FILE * cf, XF86ConfLayoutPtr ptr)
-{
-	XF86ConfAdjacencyPtr aptr;
-	XF86ConfInactivePtr iptr;
-	XF86ConfInputrefPtr inptr;
-	XF86OptionPtr optr;
-
-	while (ptr)
-	{
-		fprintf (cf, "Section \"ServerLayout\"\n");
-		if (ptr->lay_comment)
-			fprintf (cf, "%s", ptr->lay_comment);
-		if (ptr->lay_identifier)
-			fprintf (cf, "\tIdentifier     \"%s\"\n", ptr->lay_identifier);
-
-		for (aptr = ptr->lay_adjacency_lst; aptr; aptr = aptr->list.next)
-		{
-			fprintf (cf, "\tScreen     ");
-			if (aptr->adj_scrnum >= 0)
-				fprintf (cf, "%2d", aptr->adj_scrnum);
-			else
-				fprintf (cf, "  ");
-			fprintf (cf, "  \"%s\"", aptr->adj_screen_str);
-			switch(aptr->adj_where)
-			{
-			case CONF_ADJ_OBSOLETE:
-				fprintf (cf, " \"%s\"", aptr->adj_top_str);
-				fprintf (cf, " \"%s\"", aptr->adj_bottom_str);
-				fprintf (cf, " \"%s\"", aptr->adj_right_str);
-				fprintf (cf, " \"%s\"\n", aptr->adj_left_str);
-				break;
-			case CONF_ADJ_ABSOLUTE:
-				if (aptr->adj_x != -1)
-					fprintf (cf, " %d %d\n", aptr->adj_x, aptr->adj_y);
-				else
-					fprintf (cf, "\n");
-				break;
-			case CONF_ADJ_RIGHTOF:
-				fprintf (cf, " RightOf \"%s\"\n", aptr->adj_refscreen);
-				break;
-			case CONF_ADJ_LEFTOF:
-				fprintf (cf, " LeftOf \"%s\"\n", aptr->adj_refscreen);
-				break;
-			case CONF_ADJ_ABOVE:
-				fprintf (cf, " Above \"%s\"\n", aptr->adj_refscreen);
-				break;
-			case CONF_ADJ_BELOW:
-				fprintf (cf, " Below \"%s\"\n", aptr->adj_refscreen);
-				break;
-			case CONF_ADJ_RELATIVE:
-				fprintf (cf, " Relative \"%s\" %d %d\n", aptr->adj_refscreen,
-						 aptr->adj_x, aptr->adj_y);
-				break;
-			}
-		}
-		for (iptr = ptr->lay_inactive_lst; iptr; iptr = iptr->list.next)
-			fprintf (cf, "\tInactive       \"%s\"\n", iptr->inactive_device_str);
-		for (inptr = ptr->lay_input_lst; inptr; inptr = inptr->list.next)
-		{
-			fprintf (cf, "\tInputDevice    \"%s\"", inptr->iref_inputdev_str);
-			for (optr = inptr->iref_option_lst; optr; optr = optr->list.next)
-			{
-				fprintf(cf, " \"%s\"", optr->opt_name);
-			}
-			fprintf(cf, "\n");
-		}
-		xf86printOptionList(cf, ptr->lay_option_lst, 1);
-		fprintf (cf, "EndSection\n\n");
-		ptr = ptr->list.next;
-	}
-}
-
-static void
-xf86freeAdjacencyList (XF86ConfAdjacencyPtr ptr)
-{
-	XF86ConfAdjacencyPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->adj_screen_str);
-		TestFree (ptr->adj_top_str);
-		TestFree (ptr->adj_bottom_str);
-		TestFree (ptr->adj_left_str);
-		TestFree (ptr->adj_right_str);
-
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-
-}
-
-static void
-xf86freeInputrefList (XF86ConfInputrefPtr ptr)
-{
-	XF86ConfInputrefPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->iref_inputdev_str);
-		xf86optionListFree (ptr->iref_option_lst);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-
-}
-
-void
-xf86freeLayoutList (XF86ConfLayoutPtr ptr)
-{
-	XF86ConfLayoutPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->lay_identifier);
-		TestFree (ptr->lay_comment);
-		xf86freeAdjacencyList (ptr->lay_adjacency_lst);
-		xf86freeInputrefList (ptr->lay_input_lst);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-int
-xf86layoutAddInputDevices(XF86ConfigPtr config, XF86ConfLayoutPtr layout)
-{
-    int count = 0;
-    XF86ConfInputPtr input = config->conf_input_lst;
-    XF86ConfInputrefPtr inptr;
-
-    /* add all AutoServerLayout devices to the server layout */
-    while (input)
-    {
-	if (xf86CheckBoolOption(input->inp_option_lst, "AutoServerLayout", FALSE))
-	{
-	    XF86ConfInputrefPtr iref = layout->lay_input_lst;
-
-	    /* avoid duplicates if referenced but lists AutoServerLayout too */
-	    while (iref)
-	    {
-		if (strcmp(iref->iref_inputdev_str, input->inp_identifier) == 0)
-		    break;
-		iref = iref->list.next;
-	    }
-
-	    if (!iref)
-	    {
-		XF86ConfInputrefPtr iptr;
-		iptr = calloc(1, sizeof(XF86ConfInputrefRec));
-		iptr->iref_inputdev_str = input->inp_identifier;
-		layout->lay_input_lst = (XF86ConfInputrefPtr)
-		    xf86addListItem((glp)layout->lay_input_lst, (glp)iptr);
-		count++;
-	    }
-	}
-	input = input->list.next;
-    }
-
-    inptr = layout->lay_input_lst;
-    while (inptr)
-    {
-	input = xf86findInput (inptr->iref_inputdev_str,
-		config->conf_input_lst);
-	if (!input)
-	{
-	    xf86validationError (UNDEFINED_INPUT_MSG,
-		    inptr->iref_inputdev_str, layout->lay_identifier);
-	    return -1;
-	}
-	else
-	    inptr->iref_inputdev = input;
-	inptr = inptr->list.next;
-    }
-
-    return count;
-}
-
-int
-xf86validateLayout (XF86ConfigPtr p)
-{
-	XF86ConfLayoutPtr layout = p->conf_layout_lst;
-	XF86ConfAdjacencyPtr adj;
-	XF86ConfInactivePtr iptr;
-	XF86ConfScreenPtr screen;
-	XF86ConfDevicePtr device;
-
-	while (layout)
-	{
-		adj = layout->lay_adjacency_lst;
-		while (adj)
-		{
-			/* the first one can't be "" but all others can */
-			screen = xf86findScreen (adj->adj_screen_str, p->conf_screen_lst);
-			if (!screen)
-			{
-				xf86validationError (UNDEFINED_SCREEN_MSG,
-							   adj->adj_screen_str, layout->lay_identifier);
-				return (FALSE);
-			}
-			else
-				adj->adj_screen = screen;
-
-			adj = adj->list.next;
-		}
-		iptr = layout->lay_inactive_lst;
-		while (iptr)
-		{
-			device = xf86findDevice (iptr->inactive_device_str,
-									p->conf_device_lst);
-			if (!device)
-			{
-				xf86validationError (UNDEFINED_DEVICE_LAY_MSG,
-						iptr->inactive_device_str, layout->lay_identifier);
-				return (FALSE);
-			}
-			else
-				iptr->inactive_device = device;
-			iptr = iptr->list.next;
-		}
-
-		if (xf86layoutAddInputDevices(p, layout) == -1)
-		    return FALSE;
-
-		layout = layout->list.next;
-	}
-	return (TRUE);
-}
-
-XF86ConfLayoutPtr
-xf86findLayout (const char *name, XF86ConfLayoutPtr list)
-{
-	while (list)
-	{
-		if (xf86nameCompare (list->lay_identifier, name) == 0)
-			return (list);
-		list = list->list.next;
-	}
-	return (NULL);
-}
-
+/* 

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86Parser.h"

+#include "xf86tokens.h"

+#include "Configint.h"

+#include <string.h>

+

+

+/* Needed for auto server layout */

+extern int xf86CheckBoolOption(void* optlist, const char *name, int deflt);

+

+extern LexRec val;

+

+static xf86ConfigSymTabRec LayoutTab[] =

+{

+	{ENDSECTION, "endsection"},

+	{SCREEN, "screen"},

+	{IDENTIFIER, "identifier"},

+	{INACTIVE, "inactive"},

+	{INPUTDEVICE, "inputdevice"},

+	{OPTION, "option"},

+	{-1, ""},

+};

+

+static xf86ConfigSymTabRec AdjTab[] =

+{

+	{RIGHTOF, "rightof"},

+	{LEFTOF, "leftof"},

+	{ABOVE, "above"},

+	{BELOW, "below"},

+	{RELATIVE, "relative"},

+	{ABSOLUTE, "absolute"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeLayoutList

+

+XF86ConfLayoutPtr

+xf86parseLayoutSection (void)

+{

+	int has_ident = FALSE;

+	int token;

+	parsePrologue (XF86ConfLayoutPtr, XF86ConfLayoutRec)

+

+	while ((token = xf86getToken (LayoutTab)) != ENDSECTION)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->lay_comment = xf86addComment(ptr->lay_comment, val.str);

+			break;

+		case IDENTIFIER:

+			if (xf86getSubToken (&(ptr->lay_comment)) != STRING)

+				Error (QUOTE_MSG, "Identifier");

+			if (has_ident == TRUE)

+				Error (MULTIPLE_MSG, "Identifier");

+			ptr->lay_identifier = val.str;

+			has_ident = TRUE;

+			break;

+		case INACTIVE:

+			{

+				XF86ConfInactivePtr iptr;

+

+				iptr = calloc (1, sizeof (XF86ConfInactiveRec));

+				iptr->list.next = NULL;

+				if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {

+					free (iptr);

+					Error (INACTIVE_MSG, NULL);

+				}

+				iptr->inactive_device_str = val.str;

+				ptr->lay_inactive_lst = (XF86ConfInactivePtr)

+					xf86addListItem ((glp) ptr->lay_inactive_lst, (glp) iptr);

+			}

+			break;

+		case SCREEN:

+			{

+				XF86ConfAdjacencyPtr aptr;

+				int absKeyword = 0;

+

+				aptr = calloc (1, sizeof (XF86ConfAdjacencyRec));

+				aptr->list.next = NULL;

+				aptr->adj_scrnum = -1;

+				aptr->adj_where = CONF_ADJ_OBSOLETE;

+				aptr->adj_x = 0;

+				aptr->adj_y = 0;

+				aptr->adj_refscreen = NULL;

+				if ((token = xf86getSubToken (&(ptr->lay_comment))) == NUMBER)

+					aptr->adj_scrnum = val.num;

+				else

+					xf86unGetToken (token);

+				token = xf86getSubToken(&(ptr->lay_comment));

+				if (token != STRING) {

+					free(aptr);

+					Error (SCREEN_MSG, NULL);

+				}

+				aptr->adj_screen_str = val.str;

+

+				token = xf86getSubTokenWithTab(&(ptr->lay_comment), AdjTab);

+				switch (token)

+				{

+				case RIGHTOF:

+					aptr->adj_where = CONF_ADJ_RIGHTOF;

+					break;

+				case LEFTOF:

+					aptr->adj_where = CONF_ADJ_LEFTOF;

+					break;

+				case ABOVE:

+					aptr->adj_where = CONF_ADJ_ABOVE;

+					break;

+				case BELOW:

+					aptr->adj_where = CONF_ADJ_BELOW;

+					break;

+				case RELATIVE:

+					aptr->adj_where = CONF_ADJ_RELATIVE;

+					break;

+				case ABSOLUTE:

+					aptr->adj_where = CONF_ADJ_ABSOLUTE;

+					absKeyword = 1;

+					break;

+				case EOF_TOKEN:

+					free(aptr);

+					Error (UNEXPECTED_EOF_MSG, NULL);

+					break;

+				default:

+					xf86unGetToken (token);

+					token = xf86getSubToken(&(ptr->lay_comment));

+					if (token == STRING)

+						aptr->adj_where = CONF_ADJ_OBSOLETE;

+					else

+						aptr->adj_where = CONF_ADJ_ABSOLUTE;

+				}

+				switch (aptr->adj_where)

+				{

+				case CONF_ADJ_ABSOLUTE:

+					if (absKeyword) 

+						token = xf86getSubToken(&(ptr->lay_comment));

+					if (token == NUMBER)

+					{

+						aptr->adj_x = val.num;

+						token = xf86getSubToken(&(ptr->lay_comment));

+						if (token != NUMBER) {

+							free(aptr);

+							Error(INVALID_SCR_MSG, NULL);

+						}

+						aptr->adj_y = val.num;

+					} else {

+						if (absKeyword) {

+							free(aptr);

+							Error(INVALID_SCR_MSG, NULL);

+						} else

+							xf86unGetToken (token);

+					}

+					break;

+				case CONF_ADJ_RIGHTOF:

+				case CONF_ADJ_LEFTOF:

+				case CONF_ADJ_ABOVE:

+				case CONF_ADJ_BELOW:

+				case CONF_ADJ_RELATIVE:

+					token = xf86getSubToken(&(ptr->lay_comment));

+					if (token != STRING) {

+						free(aptr);

+						Error(INVALID_SCR_MSG, NULL);

+					}

+					aptr->adj_refscreen = val.str;

+					if (aptr->adj_where == CONF_ADJ_RELATIVE)

+					{

+						token = xf86getSubToken(&(ptr->lay_comment));

+						if (token != NUMBER) {

+							free(aptr);

+							Error(INVALID_SCR_MSG, NULL);

+						}

+						aptr->adj_x = val.num;

+						token = xf86getSubToken(&(ptr->lay_comment));

+						if (token != NUMBER) {

+							free(aptr);

+							Error(INVALID_SCR_MSG, NULL);

+						}

+						aptr->adj_y = val.num;

+					}

+					break;

+				case CONF_ADJ_OBSOLETE:

+					/* top */

+					aptr->adj_top_str = val.str;

+

+					/* bottom */

+					if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {

+						free(aptr);

+						Error (SCREEN_MSG, NULL);

+					}

+					aptr->adj_bottom_str = val.str;

+

+					/* left */

+					if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {

+						free(aptr);

+						Error (SCREEN_MSG, NULL);

+					}

+					aptr->adj_left_str = val.str;

+

+					/* right */

+					if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {

+						free(aptr);

+						Error (SCREEN_MSG, NULL);

+					}

+					aptr->adj_right_str = val.str;

+

+				}

+				ptr->lay_adjacency_lst = (XF86ConfAdjacencyPtr)

+					xf86addListItem ((glp) ptr->lay_adjacency_lst, (glp) aptr);

+			}

+			break;

+		case INPUTDEVICE:

+			{

+				XF86ConfInputrefPtr iptr;

+

+				iptr = calloc (1, sizeof (XF86ConfInputrefRec));

+				iptr->list.next = NULL;

+				iptr->iref_option_lst = NULL;

+				if (xf86getSubToken (&(ptr->lay_comment)) != STRING) {

+					free(iptr);

+					Error (INPUTDEV_MSG, NULL);

+				}

+				iptr->iref_inputdev_str = val.str;

+				while ((token = xf86getSubToken (&(ptr->lay_comment))) == STRING)

+				{

+					iptr->iref_option_lst =

+						xf86addNewOption (iptr->iref_option_lst, val.str, NULL);

+				}

+				xf86unGetToken (token);

+				ptr->lay_input_lst = (XF86ConfInputrefPtr)

+					xf86addListItem ((glp) ptr->lay_input_lst, (glp) iptr);

+			}

+			break;

+		case OPTION:

+			ptr->lay_option_lst = xf86parseOption(ptr->lay_option_lst);

+			break;

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+			break;

+		}

+	}

+

+	if (!has_ident)

+		Error (NO_IDENT_MSG, NULL);

+

+#ifdef DEBUG

+	printf ("Layout section parsed\n");

+#endif

+

+	return ptr;

+}

+

+#undef CLEANUP

+

+void

+xf86printLayoutSection (FILE * cf, XF86ConfLayoutPtr ptr)

+{

+	XF86ConfAdjacencyPtr aptr;

+	XF86ConfInactivePtr iptr;

+	XF86ConfInputrefPtr inptr;

+	XF86OptionPtr optr;

+

+	while (ptr)

+	{

+		fprintf (cf, "Section \"ServerLayout\"\n");

+		if (ptr->lay_comment)

+			fprintf (cf, "%s", ptr->lay_comment);

+		if (ptr->lay_identifier)

+			fprintf (cf, "\tIdentifier     \"%s\"\n", ptr->lay_identifier);

+

+		for (aptr = ptr->lay_adjacency_lst; aptr; aptr = aptr->list.next)

+		{

+			fprintf (cf, "\tScreen     ");

+			if (aptr->adj_scrnum >= 0)

+				fprintf (cf, "%2d", aptr->adj_scrnum);

+			else

+				fprintf (cf, "  ");

+			fprintf (cf, "  \"%s\"", aptr->adj_screen_str);

+			switch(aptr->adj_where)

+			{

+			case CONF_ADJ_OBSOLETE:

+				fprintf (cf, " \"%s\"", aptr->adj_top_str);

+				fprintf (cf, " \"%s\"", aptr->adj_bottom_str);

+				fprintf (cf, " \"%s\"", aptr->adj_right_str);

+				fprintf (cf, " \"%s\"\n", aptr->adj_left_str);

+				break;

+			case CONF_ADJ_ABSOLUTE:

+				if (aptr->adj_x != -1)

+					fprintf (cf, " %d %d\n", aptr->adj_x, aptr->adj_y);

+				else

+					fprintf (cf, "\n");

+				break;

+			case CONF_ADJ_RIGHTOF:

+				fprintf (cf, " RightOf \"%s\"\n", aptr->adj_refscreen);

+				break;

+			case CONF_ADJ_LEFTOF:

+				fprintf (cf, " LeftOf \"%s\"\n", aptr->adj_refscreen);

+				break;

+			case CONF_ADJ_ABOVE:

+				fprintf (cf, " Above \"%s\"\n", aptr->adj_refscreen);

+				break;

+			case CONF_ADJ_BELOW:

+				fprintf (cf, " Below \"%s\"\n", aptr->adj_refscreen);

+				break;

+			case CONF_ADJ_RELATIVE:

+				fprintf (cf, " Relative \"%s\" %d %d\n", aptr->adj_refscreen,

+						 aptr->adj_x, aptr->adj_y);

+				break;

+			}

+		}

+		for (iptr = ptr->lay_inactive_lst; iptr; iptr = iptr->list.next)

+			fprintf (cf, "\tInactive       \"%s\"\n", iptr->inactive_device_str);

+		for (inptr = ptr->lay_input_lst; inptr; inptr = inptr->list.next)

+		{

+			fprintf (cf, "\tInputDevice    \"%s\"", inptr->iref_inputdev_str);

+			for (optr = inptr->iref_option_lst; optr; optr = optr->list.next)

+			{

+				fprintf(cf, " \"%s\"", optr->opt_name);

+			}

+			fprintf(cf, "\n");

+		}

+		xf86printOptionList(cf, ptr->lay_option_lst, 1);

+		fprintf (cf, "EndSection\n\n");

+		ptr = ptr->list.next;

+	}

+}

+

+static void

+xf86freeAdjacencyList (XF86ConfAdjacencyPtr ptr)

+{

+	XF86ConfAdjacencyPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->adj_screen_str);

+		TestFree (ptr->adj_top_str);

+		TestFree (ptr->adj_bottom_str);

+		TestFree (ptr->adj_left_str);

+		TestFree (ptr->adj_right_str);

+

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+

+}

+

+static void

+xf86freeInputrefList (XF86ConfInputrefPtr ptr)

+{

+	XF86ConfInputrefPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->iref_inputdev_str);

+		xf86optionListFree (ptr->iref_option_lst);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+

+}

+

+void

+xf86freeLayoutList (XF86ConfLayoutPtr ptr)

+{

+	XF86ConfLayoutPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->lay_identifier);

+		TestFree (ptr->lay_comment);

+		xf86freeAdjacencyList (ptr->lay_adjacency_lst);

+		xf86freeInputrefList (ptr->lay_input_lst);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+int

+xf86layoutAddInputDevices(XF86ConfigPtr config, XF86ConfLayoutPtr layout)

+{

+    int count = 0;

+    XF86ConfInputPtr input = config->conf_input_lst;

+    XF86ConfInputrefPtr inptr;

+

+    /* add all AutoServerLayout devices to the server layout */

+    while (input)

+    {

+	if (xf86CheckBoolOption(input->inp_option_lst, "AutoServerLayout", FALSE))

+	{

+	    XF86ConfInputrefPtr iref = layout->lay_input_lst;

+

+	    /* avoid duplicates if referenced but lists AutoServerLayout too */

+	    while (iref)

+	    {

+		if (strcmp(iref->iref_inputdev_str, input->inp_identifier) == 0)

+		    break;

+		iref = iref->list.next;

+	    }

+

+	    if (!iref)

+	    {

+		XF86ConfInputrefPtr iptr;

+		iptr = calloc(1, sizeof(XF86ConfInputrefRec));

+		iptr->iref_inputdev_str = input->inp_identifier;

+		layout->lay_input_lst = (XF86ConfInputrefPtr)

+		    xf86addListItem((glp)layout->lay_input_lst, (glp)iptr);

+		count++;

+	    }

+	}

+	input = input->list.next;

+    }

+

+    inptr = layout->lay_input_lst;

+    while (inptr)

+    {

+	input = xf86findInput (inptr->iref_inputdev_str,

+		config->conf_input_lst);

+	if (!input)

+	{

+	    xf86validationError (UNDEFINED_INPUT_MSG,

+		    inptr->iref_inputdev_str, layout->lay_identifier);

+	    return -1;

+	}

+	else

+	    inptr->iref_inputdev = input;

+	inptr = inptr->list.next;

+    }

+

+    return count;

+}

+

+int

+xf86validateLayout (XF86ConfigPtr p)

+{

+	XF86ConfLayoutPtr layout = p->conf_layout_lst;

+	XF86ConfAdjacencyPtr adj;

+	XF86ConfInactivePtr iptr;

+	XF86ConfScreenPtr screen;

+	XF86ConfDevicePtr device;

+

+	while (layout)

+	{

+		adj = layout->lay_adjacency_lst;

+		while (adj)

+		{

+			/* the first one can't be "" but all others can */

+			screen = xf86findScreen (adj->adj_screen_str, p->conf_screen_lst);

+			if (!screen)

+			{

+				xf86validationError (UNDEFINED_SCREEN_MSG,

+							   adj->adj_screen_str, layout->lay_identifier);

+				return FALSE;

+			}

+			else

+				adj->adj_screen = screen;

+

+			adj = adj->list.next;

+		}

+		iptr = layout->lay_inactive_lst;

+		while (iptr)

+		{

+			device = xf86findDevice (iptr->inactive_device_str,

+									p->conf_device_lst);

+			if (!device)

+			{

+				xf86validationError (UNDEFINED_DEVICE_LAY_MSG,

+						iptr->inactive_device_str, layout->lay_identifier);

+				return FALSE;

+			}

+			else

+				iptr->inactive_device = device;

+			iptr = iptr->list.next;

+		}

+

+		if (xf86layoutAddInputDevices(p, layout) == -1)

+		    return FALSE;

+

+		layout = layout->list.next;

+	}

+	return TRUE;

+}

+

+XF86ConfLayoutPtr

+xf86findLayout (const char *name, XF86ConfLayoutPtr list)

+{

+	while (list)

+	{

+		if (xf86nameCompare (list->lay_identifier, name) == 0)

+			return list;

+		list = list->list.next;

+	}

+	return NULL;

+}

+

diff --git a/xorg-server/hw/xfree86/parser/Monitor.c b/xorg-server/hw/xfree86/parser/Monitor.c
index 50de091fc..8ad7c2e79 100644
--- a/xorg-server/hw/xfree86/parser/Monitor.c
+++ b/xorg-server/hw/xfree86/parser/Monitor.c
@@ -1,904 +1,904 @@
-/* 
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Parser.h"
-#include "xf86tokens.h"
-#include "Configint.h"
-
-extern LexRec val;
-
-static xf86ConfigSymTabRec MonitorTab[] =
-{
-	{ENDSECTION, "endsection"},
-	{IDENTIFIER, "identifier"},
-	{VENDOR, "vendorname"},
-	{MODEL, "modelname"},
-	{USEMODES, "usemodes"},
-	{MODELINE, "modeline"},
-	{DISPLAYSIZE, "displaysize"},
-	{HORIZSYNC, "horizsync"},
-	{VERTREFRESH, "vertrefresh"},
-	{MODE, "mode"},
-	{GAMMA, "gamma"},
-	{OPTION, "option"},
-	{-1, ""},
-};
-
-static xf86ConfigSymTabRec ModesTab[] =
-{
-	{ENDSECTION, "endsection"},
-	{IDENTIFIER, "identifier"},
-	{MODELINE, "modeline"},
-	{MODE, "mode"},
-	{-1, ""},
-};
-
-static xf86ConfigSymTabRec TimingTab[] =
-{
-	{TT_INTERLACE, "interlace"},
-	{TT_PHSYNC, "+hsync"},
-	{TT_NHSYNC, "-hsync"},
-	{TT_PVSYNC, "+vsync"},
-	{TT_NVSYNC, "-vsync"},
-	{TT_CSYNC, "composite"},
-	{TT_PCSYNC, "+csync"},
-	{TT_NCSYNC, "-csync"},
-	{TT_DBLSCAN, "doublescan"},
-	{TT_HSKEW, "hskew"},
-	{TT_BCAST, "bcast"},
-	{TT_VSCAN, "vscan"},
-	{TT_CUSTOM, "CUSTOM"},
-	{-1, ""},
-};
-
-static xf86ConfigSymTabRec ModeTab[] =
-{
-	{DOTCLOCK, "dotclock"},
-	{HTIMINGS, "htimings"},
-	{VTIMINGS, "vtimings"},
-	{FLAGS, "flags"},
-	{HSKEW, "hskew"},
-	{BCAST, "bcast"},
-	{VSCAN, "vscan"},
-	{ENDMODE, "endmode"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeModeLineList
-
-static void
-xf86freeModeLineList (XF86ConfModeLinePtr ptr)
-{
-	XF86ConfModeLinePtr prev;
-	while (ptr)
-	{
-		TestFree (ptr->ml_identifier);
-		TestFree (ptr->ml_comment);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-static XF86ConfModeLinePtr
-xf86parseModeLine (void)
-{
-	int token;
-	parsePrologue (XF86ConfModeLinePtr, XF86ConfModeLineRec)
-
-	/* Identifier */
-	if (xf86getSubToken (&(ptr->ml_comment)) != STRING)
-		Error ("ModeLine identifier expected", NULL);
-	ptr->ml_identifier = val.str;
-
-	/* DotClock */
-	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-		Error ("ModeLine dotclock expected", NULL);
-	ptr->ml_clock = (int) (val.realnum * 1000.0 + 0.5);
-
-	/* HDisplay */
-	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-		Error ("ModeLine Hdisplay expected", NULL);
-	ptr->ml_hdisplay = val.num;
-
-	/* HSyncStart */
-	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-		Error ("ModeLine HSyncStart expected", NULL);
-	ptr->ml_hsyncstart = val.num;
-
-	/* HSyncEnd */
-	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-		Error ("ModeLine HSyncEnd expected", NULL);
-	ptr->ml_hsyncend = val.num;
-
-	/* HTotal */
-	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-		Error ("ModeLine HTotal expected", NULL);
-	ptr->ml_htotal = val.num;
-
-	/* VDisplay */
-	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-		Error ("ModeLine Vdisplay expected", NULL);
-	ptr->ml_vdisplay = val.num;
-
-	/* VSyncStart */
-	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-		Error ("ModeLine VSyncStart expected", NULL);
-	ptr->ml_vsyncstart = val.num;
-
-	/* VSyncEnd */
-	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-		Error ("ModeLine VSyncEnd expected", NULL);
-	ptr->ml_vsyncend = val.num;
-
-	/* VTotal */
-	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-		Error ("ModeLine VTotal expected", NULL);
-	ptr->ml_vtotal = val.num;
-
-	token = xf86getSubTokenWithTab (&(ptr->ml_comment), TimingTab);
-	while ((token == TT_INTERLACE) || (token == TT_PHSYNC) ||
-		   (token == TT_NHSYNC) || (token == TT_PVSYNC) ||
-		   (token == TT_NVSYNC) || (token == TT_CSYNC) ||
-		   (token == TT_PCSYNC) || (token == TT_NCSYNC) ||
-		   (token == TT_DBLSCAN) || (token == TT_HSKEW) ||
-		   (token == TT_VSCAN) || (token == TT_BCAST))
-	{
-		switch (token)
-		{
-
-		case TT_INTERLACE:
-			ptr->ml_flags |= XF86CONF_INTERLACE;
-			break;
-		case TT_PHSYNC:
-			ptr->ml_flags |= XF86CONF_PHSYNC;
-			break;
-		case TT_NHSYNC:
-			ptr->ml_flags |= XF86CONF_NHSYNC;
-			break;
-		case TT_PVSYNC:
-			ptr->ml_flags |= XF86CONF_PVSYNC;
-			break;
-		case TT_NVSYNC:
-			ptr->ml_flags |= XF86CONF_NVSYNC;
-			break;
-		case TT_CSYNC:
-			ptr->ml_flags |= XF86CONF_CSYNC;
-			break;
-		case TT_PCSYNC:
-			ptr->ml_flags |= XF86CONF_PCSYNC;
-			break;
-		case TT_NCSYNC:
-			ptr->ml_flags |= XF86CONF_NCSYNC;
-			break;
-		case TT_DBLSCAN:
-			ptr->ml_flags |= XF86CONF_DBLSCAN;
-			break;
-		case TT_HSKEW:
-			if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-				Error (NUMBER_MSG, "Hskew");
-			ptr->ml_hskew = val.num;
-			ptr->ml_flags |= XF86CONF_HSKEW;
-			break;
-		case TT_BCAST:
-			ptr->ml_flags |= XF86CONF_BCAST;
-			break;
-		case TT_VSCAN:
-			if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-				Error (NUMBER_MSG, "Vscan");
-			ptr->ml_vscan = val.num;
-			ptr->ml_flags |= XF86CONF_VSCAN;
-			break;
-		case TT_CUSTOM:
-			ptr->ml_flags |= XF86CONF_CUSTOM;
-			break;
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-			break;
-		}
-		token = xf86getSubTokenWithTab (&(ptr->ml_comment), TimingTab);
-	}
-	xf86unGetToken (token);
-
-#ifdef DEBUG
-	printf ("ModeLine parsed\n");
-#endif
-	return (ptr);
-}
-
-static XF86ConfModeLinePtr
-xf86parseVerboseMode (void)
-{
-	int token, token2;
-	int had_dotclock = 0, had_htimings = 0, had_vtimings = 0;
-	parsePrologue (XF86ConfModeLinePtr, XF86ConfModeLineRec)
-
-		if (xf86getSubToken (&(ptr->ml_comment)) != STRING)
-		Error ("Mode name expected", NULL);
-	ptr->ml_identifier = val.str;
-	while ((token = xf86getToken (ModeTab)) != ENDMODE)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->ml_comment = xf86addComment(ptr->ml_comment, val.str);
-			break;
-		case DOTCLOCK:
-			if ((token = xf86getSubToken (&(ptr->ml_comment))) != NUMBER)
-				Error (NUMBER_MSG, "DotClock");
-			ptr->ml_clock = (int) (val.realnum * 1000.0 + 0.5);
-			had_dotclock = 1;
-			break;
-		case HTIMINGS:
-			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)
-				ptr->ml_hdisplay = val.num;
-			else
-				Error ("Horizontal display expected", NULL);
-
-			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)
-				ptr->ml_hsyncstart = val.num;
-			else
-				Error ("Horizontal sync start expected", NULL);
-
-			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)
-				ptr->ml_hsyncend = val.num;
-			else
-				Error ("Horizontal sync end expected", NULL);
-
-			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)
-				ptr->ml_htotal = val.num;
-			else
-				Error ("Horizontal total expected", NULL);
-			had_htimings = 1;
-			break;
-		case VTIMINGS:
-			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)
-				ptr->ml_vdisplay = val.num;
-			else
-				Error ("Vertical display expected", NULL);
-
-			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)
-				ptr->ml_vsyncstart = val.num;
-			else
-				Error ("Vertical sync start expected", NULL);
-
-			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)
-				ptr->ml_vsyncend = val.num;
-			else
-				Error ("Vertical sync end expected", NULL);
-
-			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)
-				ptr->ml_vtotal = val.num;
-			else
-				Error ("Vertical total expected", NULL);
-			had_vtimings = 1;
-			break;
-		case FLAGS:
-			token = xf86getSubToken (&(ptr->ml_comment));
-			if (token != STRING)
-				Error (QUOTE_MSG, "Flags");
-			while (token == STRING)
-			{
-				token2 = xf86getStringToken (TimingTab);
-				switch (token2)
-				{
-				case TT_INTERLACE:
-					ptr->ml_flags |= XF86CONF_INTERLACE;
-					break;
-				case TT_PHSYNC:
-					ptr->ml_flags |= XF86CONF_PHSYNC;
-					break;
-				case TT_NHSYNC:
-					ptr->ml_flags |= XF86CONF_NHSYNC;
-					break;
-				case TT_PVSYNC:
-					ptr->ml_flags |= XF86CONF_PVSYNC;
-					break;
-				case TT_NVSYNC:
-					ptr->ml_flags |= XF86CONF_NVSYNC;
-					break;
-				case TT_CSYNC:
-					ptr->ml_flags |= XF86CONF_CSYNC;
-					break;
-				case TT_PCSYNC:
-					ptr->ml_flags |= XF86CONF_PCSYNC;
-					break;
-				case TT_NCSYNC:
-					ptr->ml_flags |= XF86CONF_NCSYNC;
-					break;
-				case TT_DBLSCAN:
-					ptr->ml_flags |= XF86CONF_DBLSCAN;
-					break;
-				case TT_CUSTOM:
-					ptr->ml_flags |= XF86CONF_CUSTOM;
-					break;
-				case EOF_TOKEN:
-					Error (UNEXPECTED_EOF_MSG, NULL);
-					break;
-				default:
-					Error ("Unknown flag string", NULL);
-					break;
-				}
-				token = xf86getSubToken (&(ptr->ml_comment));
-			}
-			xf86unGetToken (token);
-			break;
-		case HSKEW:
-			if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-				Error ("Horizontal skew expected", NULL);
-			ptr->ml_flags |= XF86CONF_HSKEW;
-			ptr->ml_hskew = val.num;
-			break;
-		case VSCAN:
-			if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)
-				Error ("Vertical scan count expected", NULL);
-			ptr->ml_flags |= XF86CONF_VSCAN;
-			ptr->ml_vscan = val.num;
-			break;
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error ("Unexepcted token in verbose \"Mode\" entry\n", NULL);
-		}
-	}
-	if (!had_dotclock)
-		Error ("the dotclock is missing", NULL);
-	if (!had_htimings)
-		Error ("the horizontal timings are missing", NULL);
-	if (!had_vtimings)
-		Error ("the vertical timings are missing", NULL);
-
-#ifdef DEBUG
-	printf ("Verbose Mode parsed\n");
-#endif
-	return (ptr);
-}
-
-#undef CLEANUP
-
-#define CLEANUP xf86freeMonitorList
-
-XF86ConfMonitorPtr
-xf86parseMonitorSection (void)
-{
-	int has_ident = FALSE;
-	int token;
-	parsePrologue (XF86ConfMonitorPtr, XF86ConfMonitorRec)
-
-		while ((token = xf86getToken (MonitorTab)) != ENDSECTION)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->mon_comment = xf86addComment(ptr->mon_comment, val.str);
-			break;
-		case IDENTIFIER:
-			if (xf86getSubToken (&(ptr->mon_comment)) != STRING)
-				Error (QUOTE_MSG, "Identifier");
-			if (has_ident == TRUE)
-				Error (MULTIPLE_MSG, "Identifier");
-			ptr->mon_identifier = val.str;
-			has_ident = TRUE;
-			break;
-		case VENDOR:
-			if (xf86getSubToken (&(ptr->mon_comment)) != STRING)
-				Error (QUOTE_MSG, "Vendor");
-			ptr->mon_vendor = val.str;
-			break;
-		case MODEL:
-			if (xf86getSubToken (&(ptr->mon_comment)) != STRING)
-				Error (QUOTE_MSG, "ModelName");
-			ptr->mon_modelname = val.str;
-			break;
-		case MODE:
-			HANDLE_LIST (mon_modeline_lst, xf86parseVerboseMode,
-						 XF86ConfModeLinePtr);
-			break;
-		case MODELINE:
-			HANDLE_LIST (mon_modeline_lst, xf86parseModeLine,
-						 XF86ConfModeLinePtr);
-			break;
-		case DISPLAYSIZE:
-			if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER)
-				Error (DISPLAYSIZE_MSG, NULL);
-			ptr->mon_width = val.realnum;
-			if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER)
-				Error (DISPLAYSIZE_MSG, NULL);
-			ptr->mon_height = val.realnum;
-			break;
-
-		case HORIZSYNC:
-			if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER)
-				Error (HORIZSYNC_MSG, NULL);
-			do {
-				if (ptr->mon_n_hsync >= CONF_MAX_HSYNC)
-					Error ("Sorry. Too many horizontal sync intervals.", NULL);
-				ptr->mon_hsync[ptr->mon_n_hsync].lo = val.realnum;
-				switch (token = xf86getSubToken (&(ptr->mon_comment)))
-				{
-					case COMMA:
-						ptr->mon_hsync[ptr->mon_n_hsync].hi =
-						ptr->mon_hsync[ptr->mon_n_hsync].lo;
-						break;
-					case DASH:
-						if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER ||
-						    (float)val.realnum < ptr->mon_hsync[ptr->mon_n_hsync].lo)
-							Error (HORIZSYNC_MSG, NULL);
-						ptr->mon_hsync[ptr->mon_n_hsync].hi = val.realnum;
-						if ((token = xf86getSubToken (&(ptr->mon_comment))) == COMMA)
-							break;
-						ptr->mon_n_hsync++;
-						goto HorizDone;
-					default:
-						/* We cannot currently know if a '\n' was found,
-						 * or this is a real error
-						 */
-						ptr->mon_hsync[ptr->mon_n_hsync].hi =
-						ptr->mon_hsync[ptr->mon_n_hsync].lo;
-						ptr->mon_n_hsync++;
-						goto HorizDone;
-				}
-				ptr->mon_n_hsync++;
-			} while ((token = xf86getSubToken (&(ptr->mon_comment))) == NUMBER);
-HorizDone:
-			xf86unGetToken (token);
-			break;
-
-		case VERTREFRESH:
-			if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER)
-				Error (VERTREFRESH_MSG, NULL);
-			do {
-				ptr->mon_vrefresh[ptr->mon_n_vrefresh].lo = val.realnum;
-				switch (token = xf86getSubToken (&(ptr->mon_comment)))
-				{
-					case COMMA:
-						ptr->mon_vrefresh[ptr->mon_n_vrefresh].hi =
-						ptr->mon_vrefresh[ptr->mon_n_vrefresh].lo;
-						break;
-					case DASH:
-						if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER ||
-						    (float)val.realnum < ptr->mon_vrefresh[ptr->mon_n_vrefresh].lo)
-							Error (VERTREFRESH_MSG, NULL);
-						ptr->mon_vrefresh[ptr->mon_n_vrefresh].hi = val.realnum;
-						if ((token = xf86getSubToken (&(ptr->mon_comment))) == COMMA)
-							break;
-						ptr->mon_n_vrefresh++;
-						goto VertDone;
-					default:
-						/* We cannot currently know if a '\n' was found,
-						 * or this is a real error
-						 */
-						ptr->mon_vrefresh[ptr->mon_n_vrefresh].hi =
-						ptr->mon_vrefresh[ptr->mon_n_vrefresh].lo;
-						ptr->mon_n_vrefresh++;
-						goto VertDone;
-				}
-				if (ptr->mon_n_vrefresh >= CONF_MAX_VREFRESH)
-					Error ("Sorry. Too many vertical refresh intervals.", NULL);
-				ptr->mon_n_vrefresh++;
-			} while ((token = xf86getSubToken (&(ptr->mon_comment))) == NUMBER);
-VertDone:
-			xf86unGetToken (token);
-			break;
-
-		case GAMMA:
-			if( xf86getSubToken (&(ptr->mon_comment)) != NUMBER )
-			{
-				Error (INVALID_GAMMA_MSG, NULL);
-			}
-			else
-			{
-				ptr->mon_gamma_red = ptr->mon_gamma_green =
-					ptr->mon_gamma_blue = val.realnum;
-				if( xf86getSubToken (&(ptr->mon_comment)) == NUMBER )
-				{
-					ptr->mon_gamma_green = val.realnum;
-					if( xf86getSubToken (&(ptr->mon_comment)) == NUMBER )
-					{
-						ptr->mon_gamma_blue = val.realnum;
-					}
-					else
-					{
-						Error (INVALID_GAMMA_MSG, NULL);
-					}
-				}
-				else
-					xf86unGetToken (token);
-			}
-			break;
-		case OPTION:
-			ptr->mon_option_lst = xf86parseOption(ptr->mon_option_lst);
-			break;
-		case USEMODES:
-		        {
-				XF86ConfModesLinkPtr mptr;
-
-				if ((token = xf86getSubToken (&(ptr->mon_comment))) != STRING)
-					Error (QUOTE_MSG, "UseModes");
-
-				/* add to the end of the list of modes sections 
-				   referenced here */
-				mptr = calloc (1, sizeof (XF86ConfModesLinkRec));
-				mptr->list.next = NULL;
-				mptr->ml_modes_str = val.str;
-				mptr->ml_modes = NULL;
-				ptr->mon_modes_sect_lst = (XF86ConfModesLinkPtr)
-					xf86addListItem((GenericListPtr)ptr->mon_modes_sect_lst,
-						    (GenericListPtr)mptr);
-			}
-			break;
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			xf86parseError (INVALID_KEYWORD_MSG, xf86tokenString ());
-			CLEANUP (ptr);
-			return NULL;
-			break;
-		}
-	}
-
-	if (!has_ident)
-		Error (NO_IDENT_MSG, NULL);
-
-#ifdef DEBUG
-	printf ("Monitor section parsed\n");
-#endif
-	return ptr;
-}
-
-#undef CLEANUP
-#define CLEANUP xf86freeModesList
-
-XF86ConfModesPtr
-xf86parseModesSection (void)
-{
-	int has_ident = FALSE;
-	int token;
-	parsePrologue (XF86ConfModesPtr, XF86ConfModesRec)
-
-	while ((token = xf86getToken (ModesTab)) != ENDSECTION)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->modes_comment = xf86addComment(ptr->modes_comment, val.str);
-			break;
-		case IDENTIFIER:
-			if (xf86getSubToken (&(ptr->modes_comment)) != STRING)
-				Error (QUOTE_MSG, "Identifier");
-			if (has_ident == TRUE)
-				Error (MULTIPLE_MSG, "Identifier");
-			ptr->modes_identifier = val.str;
-			has_ident = TRUE;
-			break;
-		case MODE:
-			HANDLE_LIST (mon_modeline_lst, xf86parseVerboseMode,
-						 XF86ConfModeLinePtr);
-			break;
-		case MODELINE:
-			HANDLE_LIST (mon_modeline_lst, xf86parseModeLine,
-						 XF86ConfModeLinePtr);
-			break;
-		default:
-			xf86parseError (INVALID_KEYWORD_MSG, xf86tokenString ());
-			CLEANUP (ptr);
-			return NULL;
-			break;
-		}
-	}
-
-	if (!has_ident)
-		Error (NO_IDENT_MSG, NULL);
-
-#ifdef DEBUG
-	printf ("Modes section parsed\n");
-#endif
-	return ptr;
-}
-
-#undef CLEANUP
-
-void
-xf86printMonitorSection (FILE * cf, XF86ConfMonitorPtr ptr)
-{
-	int i;
-	XF86ConfModeLinePtr mlptr;
-	XF86ConfModesLinkPtr mptr;
-
-	while (ptr)
-	{
-		mptr = ptr->mon_modes_sect_lst;
-		fprintf (cf, "Section \"Monitor\"\n");
-		if (ptr->mon_comment)
-			fprintf (cf, "%s", ptr->mon_comment);
-		if (ptr->mon_identifier)
-			fprintf (cf, "\tIdentifier   \"%s\"\n", ptr->mon_identifier);
-		if (ptr->mon_vendor)
-			fprintf (cf, "\tVendorName   \"%s\"\n", ptr->mon_vendor);
-		if (ptr->mon_modelname)
-			fprintf (cf, "\tModelName    \"%s\"\n", ptr->mon_modelname);
-		while (mptr) {
-			fprintf (cf, "\tUseModes     \"%s\"\n", mptr->ml_modes_str);
-			mptr = mptr->list.next;
-		}
-		if (ptr->mon_width)
-			fprintf (cf, "\tDisplaySize  %d\t%d\n",
-					 ptr->mon_width,
-					 ptr->mon_height);
-		for (i = 0; i < ptr->mon_n_hsync; i++)
-		{
-			fprintf (cf, "\tHorizSync    %2.1f - %2.1f\n",
-					 ptr->mon_hsync[i].lo,
-					 ptr->mon_hsync[i].hi);
-		}
-		for (i = 0; i < ptr->mon_n_vrefresh; i++)
-		{
-			fprintf (cf, "\tVertRefresh  %2.1f - %2.1f\n",
-					 ptr->mon_vrefresh[i].lo,
-					 ptr->mon_vrefresh[i].hi);
-		}
-		if (ptr->mon_gamma_red) {
-			if (ptr->mon_gamma_red == ptr->mon_gamma_green
-				&& ptr->mon_gamma_red == ptr->mon_gamma_blue)
-			{
-				fprintf (cf, "\tGamma        %.4g\n",
-					ptr->mon_gamma_red);
-			} else {
-				fprintf (cf, "\tGamma        %.4g %.4g %.4g\n",
-					ptr->mon_gamma_red,
-					ptr->mon_gamma_green,
-					ptr->mon_gamma_blue);
-			}
-		}
-		for (mlptr = ptr->mon_modeline_lst; mlptr; mlptr = mlptr->list.next)
-		{
-			fprintf (cf, "\tModeLine     \"%s\" %2.1f ",
-					 mlptr->ml_identifier, mlptr->ml_clock / 1000.0);
-			fprintf (cf, "%d %d %d %d %d %d %d %d",
-					 mlptr->ml_hdisplay, mlptr->ml_hsyncstart,
-					 mlptr->ml_hsyncend, mlptr->ml_htotal,
-					 mlptr->ml_vdisplay, mlptr->ml_vsyncstart,
-					 mlptr->ml_vsyncend, mlptr->ml_vtotal);
-			if (mlptr->ml_flags & XF86CONF_PHSYNC)
-				fprintf (cf, " +hsync");
-			if (mlptr->ml_flags & XF86CONF_NHSYNC)
-				fprintf (cf, " -hsync");
-			if (mlptr->ml_flags & XF86CONF_PVSYNC)
-				fprintf (cf, " +vsync");
-			if (mlptr->ml_flags & XF86CONF_NVSYNC)
-				fprintf (cf, " -vsync");
-			if (mlptr->ml_flags & XF86CONF_INTERLACE)
-				fprintf (cf, " interlace");
-			if (mlptr->ml_flags & XF86CONF_CSYNC)
-				fprintf (cf, " composite");
-			if (mlptr->ml_flags & XF86CONF_PCSYNC)
-				fprintf (cf, " +csync");
-			if (mlptr->ml_flags & XF86CONF_NCSYNC)
-				fprintf (cf, " -csync");
-			if (mlptr->ml_flags & XF86CONF_DBLSCAN)
-				fprintf (cf, " doublescan");
-			if (mlptr->ml_flags & XF86CONF_HSKEW)
-				fprintf (cf, " hskew %d", mlptr->ml_hskew);
-			if (mlptr->ml_flags & XF86CONF_BCAST)
-				fprintf (cf, " bcast");
-			fprintf (cf, "\n");
-		}
-		xf86printOptionList(cf, ptr->mon_option_lst, 1);
-		fprintf (cf, "EndSection\n\n");
-		ptr = ptr->list.next;
-	}
-}
-
-void
-xf86printModesSection (FILE * cf, XF86ConfModesPtr ptr)
-{
-	XF86ConfModeLinePtr mlptr;
-
-	while (ptr)
-	{
-		fprintf (cf, "Section \"Modes\"\n");
-		if (ptr->modes_comment)
-			fprintf (cf, "%s", ptr->modes_comment);
-		if (ptr->modes_identifier)
-			fprintf (cf, "\tIdentifier     \"%s\"\n", ptr->modes_identifier);
-		for (mlptr = ptr->mon_modeline_lst; mlptr; mlptr = mlptr->list.next)
-		{
-			fprintf (cf, "\tModeLine     \"%s\" %2.1f ",
-					 mlptr->ml_identifier, mlptr->ml_clock / 1000.0);
-			fprintf (cf, "%d %d %d %d %d %d %d %d",
-					 mlptr->ml_hdisplay, mlptr->ml_hsyncstart,
-					 mlptr->ml_hsyncend, mlptr->ml_htotal,
-					 mlptr->ml_vdisplay, mlptr->ml_vsyncstart,
-					 mlptr->ml_vsyncend, mlptr->ml_vtotal);
-			if (mlptr->ml_flags & XF86CONF_PHSYNC)
-				fprintf (cf, " +hsync");
-			if (mlptr->ml_flags & XF86CONF_NHSYNC)
-				fprintf (cf, " -hsync");
-			if (mlptr->ml_flags & XF86CONF_PVSYNC)
-				fprintf (cf, " +vsync");
-			if (mlptr->ml_flags & XF86CONF_NVSYNC)
-				fprintf (cf, " -vsync");
-			if (mlptr->ml_flags & XF86CONF_INTERLACE)
-				fprintf (cf, " interlace");
-			if (mlptr->ml_flags & XF86CONF_CSYNC)
-				fprintf (cf, " composite");
-			if (mlptr->ml_flags & XF86CONF_PCSYNC)
-				fprintf (cf, " +csync");
-			if (mlptr->ml_flags & XF86CONF_NCSYNC)
-				fprintf (cf, " -csync");
-			if (mlptr->ml_flags & XF86CONF_DBLSCAN)
-				fprintf (cf, " doublescan");
-			if (mlptr->ml_flags & XF86CONF_HSKEW)
-				fprintf (cf, " hskew %d", mlptr->ml_hskew);
-			if (mlptr->ml_flags & XF86CONF_VSCAN)
-				fprintf (cf, " vscan %d", mlptr->ml_vscan);
-			if (mlptr->ml_flags & XF86CONF_BCAST)
-				fprintf (cf, " bcast");
-			if (mlptr->ml_comment)
-				fprintf (cf, "%s", mlptr->ml_comment);
-			else
-				fprintf (cf, "\n");
-		}
-		fprintf (cf, "EndSection\n\n");
-		ptr = ptr->list.next;
-	}
-}
-
-void
-xf86freeMonitorList (XF86ConfMonitorPtr ptr)
-{
-	XF86ConfMonitorPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->mon_identifier);
-		TestFree (ptr->mon_vendor);
-		TestFree (ptr->mon_modelname);
-		TestFree (ptr->mon_comment);
-		xf86optionListFree (ptr->mon_option_lst);
-		xf86freeModeLineList (ptr->mon_modeline_lst);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-void
-xf86freeModesList (XF86ConfModesPtr ptr)
-{
-	XF86ConfModesPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->modes_identifier);
-		TestFree (ptr->modes_comment);
-		xf86freeModeLineList (ptr->mon_modeline_lst);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-XF86ConfMonitorPtr
-xf86findMonitor (const char *ident, XF86ConfMonitorPtr p)
-{
-	while (p)
-	{
-		if (xf86nameCompare (ident, p->mon_identifier) == 0)
-			return (p);
-
-		p = p->list.next;
-	}
-	return (NULL);
-}
-
-XF86ConfModesPtr
-xf86findModes (const char *ident, XF86ConfModesPtr p)
-{
-	while (p)
-	{
-		if (xf86nameCompare (ident, p->modes_identifier) == 0)
-			return (p);
-
-		p = p->list.next;
-	}
-	return (NULL);
-}
-
-XF86ConfModeLinePtr
-xf86findModeLine (const char *ident, XF86ConfModeLinePtr p)
-{
-	while (p)
-	{
-		if (xf86nameCompare (ident, p->ml_identifier) == 0)
-			return (p);
-
-		p = p->list.next;
-	}
-	return (NULL);
-}
-
-int
-xf86validateMonitor (XF86ConfigPtr p, XF86ConfScreenPtr screen)
-{
-	XF86ConfMonitorPtr monitor = screen->scrn_monitor;
-	XF86ConfModesLinkPtr modeslnk = monitor->mon_modes_sect_lst;
-	XF86ConfModesPtr modes;
-	while(modeslnk)
-	{
-		modes = xf86findModes (modeslnk->ml_modes_str, p->conf_modes_lst);
-		if (!modes)
-		{
-			xf86validationError (UNDEFINED_MODES_MSG, 
-					     modeslnk->ml_modes_str, 
-					     screen->scrn_identifier);
-			return (FALSE);
-		}
-		modeslnk->ml_modes = modes;
-		modeslnk = modeslnk->list.next;
-	}
-	return (TRUE);
-}
+/* 

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86Parser.h"

+#include "xf86tokens.h"

+#include "Configint.h"

+

+extern LexRec val;

+

+static xf86ConfigSymTabRec MonitorTab[] =

+{

+	{ENDSECTION, "endsection"},

+	{IDENTIFIER, "identifier"},

+	{VENDOR, "vendorname"},

+	{MODEL, "modelname"},

+	{USEMODES, "usemodes"},

+	{MODELINE, "modeline"},

+	{DISPLAYSIZE, "displaysize"},

+	{HORIZSYNC, "horizsync"},

+	{VERTREFRESH, "vertrefresh"},

+	{MODE, "mode"},

+	{GAMMA, "gamma"},

+	{OPTION, "option"},

+	{-1, ""},

+};

+

+static xf86ConfigSymTabRec ModesTab[] =

+{

+	{ENDSECTION, "endsection"},

+	{IDENTIFIER, "identifier"},

+	{MODELINE, "modeline"},

+	{MODE, "mode"},

+	{-1, ""},

+};

+

+static xf86ConfigSymTabRec TimingTab[] =

+{

+	{TT_INTERLACE, "interlace"},

+	{TT_PHSYNC, "+hsync"},

+	{TT_NHSYNC, "-hsync"},

+	{TT_PVSYNC, "+vsync"},

+	{TT_NVSYNC, "-vsync"},

+	{TT_CSYNC, "composite"},

+	{TT_PCSYNC, "+csync"},

+	{TT_NCSYNC, "-csync"},

+	{TT_DBLSCAN, "doublescan"},

+	{TT_HSKEW, "hskew"},

+	{TT_BCAST, "bcast"},

+	{TT_VSCAN, "vscan"},

+	{TT_CUSTOM, "CUSTOM"},

+	{-1, ""},

+};

+

+static xf86ConfigSymTabRec ModeTab[] =

+{

+	{DOTCLOCK, "dotclock"},

+	{HTIMINGS, "htimings"},

+	{VTIMINGS, "vtimings"},

+	{FLAGS, "flags"},

+	{HSKEW, "hskew"},

+	{BCAST, "bcast"},

+	{VSCAN, "vscan"},

+	{ENDMODE, "endmode"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeModeLineList

+

+static void

+xf86freeModeLineList (XF86ConfModeLinePtr ptr)

+{

+	XF86ConfModeLinePtr prev;

+	while (ptr)

+	{

+		TestFree (ptr->ml_identifier);

+		TestFree (ptr->ml_comment);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+static XF86ConfModeLinePtr

+xf86parseModeLine (void)

+{

+	int token;

+	parsePrologue (XF86ConfModeLinePtr, XF86ConfModeLineRec)

+

+	/* Identifier */

+	if (xf86getSubToken (&(ptr->ml_comment)) != STRING)

+		Error ("ModeLine identifier expected", NULL);

+	ptr->ml_identifier = val.str;

+

+	/* DotClock */

+	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+		Error ("ModeLine dotclock expected", NULL);

+	ptr->ml_clock = (int) (val.realnum * 1000.0 + 0.5);

+

+	/* HDisplay */

+	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+		Error ("ModeLine Hdisplay expected", NULL);

+	ptr->ml_hdisplay = val.num;

+

+	/* HSyncStart */

+	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+		Error ("ModeLine HSyncStart expected", NULL);

+	ptr->ml_hsyncstart = val.num;

+

+	/* HSyncEnd */

+	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+		Error ("ModeLine HSyncEnd expected", NULL);

+	ptr->ml_hsyncend = val.num;

+

+	/* HTotal */

+	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+		Error ("ModeLine HTotal expected", NULL);

+	ptr->ml_htotal = val.num;

+

+	/* VDisplay */

+	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+		Error ("ModeLine Vdisplay expected", NULL);

+	ptr->ml_vdisplay = val.num;

+

+	/* VSyncStart */

+	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+		Error ("ModeLine VSyncStart expected", NULL);

+	ptr->ml_vsyncstart = val.num;

+

+	/* VSyncEnd */

+	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+		Error ("ModeLine VSyncEnd expected", NULL);

+	ptr->ml_vsyncend = val.num;

+

+	/* VTotal */

+	if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+		Error ("ModeLine VTotal expected", NULL);

+	ptr->ml_vtotal = val.num;

+

+	token = xf86getSubTokenWithTab (&(ptr->ml_comment), TimingTab);

+	while ((token == TT_INTERLACE) || (token == TT_PHSYNC) ||

+		   (token == TT_NHSYNC) || (token == TT_PVSYNC) ||

+		   (token == TT_NVSYNC) || (token == TT_CSYNC) ||

+		   (token == TT_PCSYNC) || (token == TT_NCSYNC) ||

+		   (token == TT_DBLSCAN) || (token == TT_HSKEW) ||

+		   (token == TT_VSCAN) || (token == TT_BCAST))

+	{

+		switch (token)

+		{

+

+		case TT_INTERLACE:

+			ptr->ml_flags |= XF86CONF_INTERLACE;

+			break;

+		case TT_PHSYNC:

+			ptr->ml_flags |= XF86CONF_PHSYNC;

+			break;

+		case TT_NHSYNC:

+			ptr->ml_flags |= XF86CONF_NHSYNC;

+			break;

+		case TT_PVSYNC:

+			ptr->ml_flags |= XF86CONF_PVSYNC;

+			break;

+		case TT_NVSYNC:

+			ptr->ml_flags |= XF86CONF_NVSYNC;

+			break;

+		case TT_CSYNC:

+			ptr->ml_flags |= XF86CONF_CSYNC;

+			break;

+		case TT_PCSYNC:

+			ptr->ml_flags |= XF86CONF_PCSYNC;

+			break;

+		case TT_NCSYNC:

+			ptr->ml_flags |= XF86CONF_NCSYNC;

+			break;

+		case TT_DBLSCAN:

+			ptr->ml_flags |= XF86CONF_DBLSCAN;

+			break;

+		case TT_HSKEW:

+			if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+				Error (NUMBER_MSG, "Hskew");

+			ptr->ml_hskew = val.num;

+			ptr->ml_flags |= XF86CONF_HSKEW;

+			break;

+		case TT_BCAST:

+			ptr->ml_flags |= XF86CONF_BCAST;

+			break;

+		case TT_VSCAN:

+			if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+				Error (NUMBER_MSG, "Vscan");

+			ptr->ml_vscan = val.num;

+			ptr->ml_flags |= XF86CONF_VSCAN;

+			break;

+		case TT_CUSTOM:

+			ptr->ml_flags |= XF86CONF_CUSTOM;

+			break;

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+			break;

+		}

+		token = xf86getSubTokenWithTab (&(ptr->ml_comment), TimingTab);

+	}

+	xf86unGetToken (token);

+

+#ifdef DEBUG

+	printf ("ModeLine parsed\n");

+#endif

+	return ptr;

+}

+

+static XF86ConfModeLinePtr

+xf86parseVerboseMode (void)

+{

+	int token, token2;

+	int had_dotclock = 0, had_htimings = 0, had_vtimings = 0;

+	parsePrologue (XF86ConfModeLinePtr, XF86ConfModeLineRec)

+

+		if (xf86getSubToken (&(ptr->ml_comment)) != STRING)

+		Error ("Mode name expected", NULL);

+	ptr->ml_identifier = val.str;

+	while ((token = xf86getToken (ModeTab)) != ENDMODE)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->ml_comment = xf86addComment(ptr->ml_comment, val.str);

+			break;

+		case DOTCLOCK:

+			if ((token = xf86getSubToken (&(ptr->ml_comment))) != NUMBER)

+				Error (NUMBER_MSG, "DotClock");

+			ptr->ml_clock = (int) (val.realnum * 1000.0 + 0.5);

+			had_dotclock = 1;

+			break;

+		case HTIMINGS:

+			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)

+				ptr->ml_hdisplay = val.num;

+			else

+				Error ("Horizontal display expected", NULL);

+

+			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)

+				ptr->ml_hsyncstart = val.num;

+			else

+				Error ("Horizontal sync start expected", NULL);

+

+			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)

+				ptr->ml_hsyncend = val.num;

+			else

+				Error ("Horizontal sync end expected", NULL);

+

+			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)

+				ptr->ml_htotal = val.num;

+			else

+				Error ("Horizontal total expected", NULL);

+			had_htimings = 1;

+			break;

+		case VTIMINGS:

+			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)

+				ptr->ml_vdisplay = val.num;

+			else

+				Error ("Vertical display expected", NULL);

+

+			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)

+				ptr->ml_vsyncstart = val.num;

+			else

+				Error ("Vertical sync start expected", NULL);

+

+			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)

+				ptr->ml_vsyncend = val.num;

+			else

+				Error ("Vertical sync end expected", NULL);

+

+			if (xf86getSubToken (&(ptr->ml_comment)) == NUMBER)

+				ptr->ml_vtotal = val.num;

+			else

+				Error ("Vertical total expected", NULL);

+			had_vtimings = 1;

+			break;

+		case FLAGS:

+			token = xf86getSubToken (&(ptr->ml_comment));

+			if (token != STRING)

+				Error (QUOTE_MSG, "Flags");

+			while (token == STRING)

+			{

+				token2 = xf86getStringToken (TimingTab);

+				switch (token2)

+				{

+				case TT_INTERLACE:

+					ptr->ml_flags |= XF86CONF_INTERLACE;

+					break;

+				case TT_PHSYNC:

+					ptr->ml_flags |= XF86CONF_PHSYNC;

+					break;

+				case TT_NHSYNC:

+					ptr->ml_flags |= XF86CONF_NHSYNC;

+					break;

+				case TT_PVSYNC:

+					ptr->ml_flags |= XF86CONF_PVSYNC;

+					break;

+				case TT_NVSYNC:

+					ptr->ml_flags |= XF86CONF_NVSYNC;

+					break;

+				case TT_CSYNC:

+					ptr->ml_flags |= XF86CONF_CSYNC;

+					break;

+				case TT_PCSYNC:

+					ptr->ml_flags |= XF86CONF_PCSYNC;

+					break;

+				case TT_NCSYNC:

+					ptr->ml_flags |= XF86CONF_NCSYNC;

+					break;

+				case TT_DBLSCAN:

+					ptr->ml_flags |= XF86CONF_DBLSCAN;

+					break;

+				case TT_CUSTOM:

+					ptr->ml_flags |= XF86CONF_CUSTOM;

+					break;

+				case EOF_TOKEN:

+					Error (UNEXPECTED_EOF_MSG, NULL);

+					break;

+				default:

+					Error ("Unknown flag string", NULL);

+					break;

+				}

+				token = xf86getSubToken (&(ptr->ml_comment));

+			}

+			xf86unGetToken (token);

+			break;

+		case HSKEW:

+			if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+				Error ("Horizontal skew expected", NULL);

+			ptr->ml_flags |= XF86CONF_HSKEW;

+			ptr->ml_hskew = val.num;

+			break;

+		case VSCAN:

+			if (xf86getSubToken (&(ptr->ml_comment)) != NUMBER)

+				Error ("Vertical scan count expected", NULL);

+			ptr->ml_flags |= XF86CONF_VSCAN;

+			ptr->ml_vscan = val.num;

+			break;

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error ("Unexepcted token in verbose \"Mode\" entry\n", NULL);

+		}

+	}

+	if (!had_dotclock)

+		Error ("the dotclock is missing", NULL);

+	if (!had_htimings)

+		Error ("the horizontal timings are missing", NULL);

+	if (!had_vtimings)

+		Error ("the vertical timings are missing", NULL);

+

+#ifdef DEBUG

+	printf ("Verbose Mode parsed\n");

+#endif

+	return ptr;

+}

+

+#undef CLEANUP

+

+#define CLEANUP xf86freeMonitorList

+

+XF86ConfMonitorPtr

+xf86parseMonitorSection (void)

+{

+	int has_ident = FALSE;

+	int token;

+	parsePrologue (XF86ConfMonitorPtr, XF86ConfMonitorRec)

+

+		while ((token = xf86getToken (MonitorTab)) != ENDSECTION)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->mon_comment = xf86addComment(ptr->mon_comment, val.str);

+			break;

+		case IDENTIFIER:

+			if (xf86getSubToken (&(ptr->mon_comment)) != STRING)

+				Error (QUOTE_MSG, "Identifier");

+			if (has_ident == TRUE)

+				Error (MULTIPLE_MSG, "Identifier");

+			ptr->mon_identifier = val.str;

+			has_ident = TRUE;

+			break;

+		case VENDOR:

+			if (xf86getSubToken (&(ptr->mon_comment)) != STRING)

+				Error (QUOTE_MSG, "Vendor");

+			ptr->mon_vendor = val.str;

+			break;

+		case MODEL:

+			if (xf86getSubToken (&(ptr->mon_comment)) != STRING)

+				Error (QUOTE_MSG, "ModelName");

+			ptr->mon_modelname = val.str;

+			break;

+		case MODE:

+			HANDLE_LIST (mon_modeline_lst, xf86parseVerboseMode,

+						 XF86ConfModeLinePtr);

+			break;

+		case MODELINE:

+			HANDLE_LIST (mon_modeline_lst, xf86parseModeLine,

+						 XF86ConfModeLinePtr);

+			break;

+		case DISPLAYSIZE:

+			if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER)

+				Error (DISPLAYSIZE_MSG, NULL);

+			ptr->mon_width = val.realnum;

+			if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER)

+				Error (DISPLAYSIZE_MSG, NULL);

+			ptr->mon_height = val.realnum;

+			break;

+

+		case HORIZSYNC:

+			if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER)

+				Error (HORIZSYNC_MSG, NULL);

+			do {

+				if (ptr->mon_n_hsync >= CONF_MAX_HSYNC)

+					Error ("Sorry. Too many horizontal sync intervals.", NULL);

+				ptr->mon_hsync[ptr->mon_n_hsync].lo = val.realnum;

+				switch (token = xf86getSubToken (&(ptr->mon_comment)))

+				{

+					case COMMA:

+						ptr->mon_hsync[ptr->mon_n_hsync].hi =

+						ptr->mon_hsync[ptr->mon_n_hsync].lo;

+						break;

+					case DASH:

+						if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER ||

+						    (float)val.realnum < ptr->mon_hsync[ptr->mon_n_hsync].lo)

+							Error (HORIZSYNC_MSG, NULL);

+						ptr->mon_hsync[ptr->mon_n_hsync].hi = val.realnum;

+						if ((token = xf86getSubToken (&(ptr->mon_comment))) == COMMA)

+							break;

+						ptr->mon_n_hsync++;

+						goto HorizDone;

+					default:

+						/* We cannot currently know if a '\n' was found,

+						 * or this is a real error

+						 */

+						ptr->mon_hsync[ptr->mon_n_hsync].hi =

+						ptr->mon_hsync[ptr->mon_n_hsync].lo;

+						ptr->mon_n_hsync++;

+						goto HorizDone;

+				}

+				ptr->mon_n_hsync++;

+			} while ((token = xf86getSubToken (&(ptr->mon_comment))) == NUMBER);

+HorizDone:

+			xf86unGetToken (token);

+			break;

+

+		case VERTREFRESH:

+			if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER)

+				Error (VERTREFRESH_MSG, NULL);

+			do {

+				ptr->mon_vrefresh[ptr->mon_n_vrefresh].lo = val.realnum;

+				switch (token = xf86getSubToken (&(ptr->mon_comment)))

+				{

+					case COMMA:

+						ptr->mon_vrefresh[ptr->mon_n_vrefresh].hi =

+						ptr->mon_vrefresh[ptr->mon_n_vrefresh].lo;

+						break;

+					case DASH:

+						if (xf86getSubToken (&(ptr->mon_comment)) != NUMBER ||

+						    (float)val.realnum < ptr->mon_vrefresh[ptr->mon_n_vrefresh].lo)

+							Error (VERTREFRESH_MSG, NULL);

+						ptr->mon_vrefresh[ptr->mon_n_vrefresh].hi = val.realnum;

+						if ((token = xf86getSubToken (&(ptr->mon_comment))) == COMMA)

+							break;

+						ptr->mon_n_vrefresh++;

+						goto VertDone;

+					default:

+						/* We cannot currently know if a '\n' was found,

+						 * or this is a real error

+						 */

+						ptr->mon_vrefresh[ptr->mon_n_vrefresh].hi =

+						ptr->mon_vrefresh[ptr->mon_n_vrefresh].lo;

+						ptr->mon_n_vrefresh++;

+						goto VertDone;

+				}

+				if (ptr->mon_n_vrefresh >= CONF_MAX_VREFRESH)

+					Error ("Sorry. Too many vertical refresh intervals.", NULL);

+				ptr->mon_n_vrefresh++;

+			} while ((token = xf86getSubToken (&(ptr->mon_comment))) == NUMBER);

+VertDone:

+			xf86unGetToken (token);

+			break;

+

+		case GAMMA:

+			if( xf86getSubToken (&(ptr->mon_comment)) != NUMBER )

+			{

+				Error (INVALID_GAMMA_MSG, NULL);

+			}

+			else

+			{

+				ptr->mon_gamma_red = ptr->mon_gamma_green =

+					ptr->mon_gamma_blue = val.realnum;

+				if( xf86getSubToken (&(ptr->mon_comment)) == NUMBER )

+				{

+					ptr->mon_gamma_green = val.realnum;

+					if( xf86getSubToken (&(ptr->mon_comment)) == NUMBER )

+					{

+						ptr->mon_gamma_blue = val.realnum;

+					}

+					else

+					{

+						Error (INVALID_GAMMA_MSG, NULL);

+					}

+				}

+				else

+					xf86unGetToken (token);

+			}

+			break;

+		case OPTION:

+			ptr->mon_option_lst = xf86parseOption(ptr->mon_option_lst);

+			break;

+		case USEMODES:

+		        {

+				XF86ConfModesLinkPtr mptr;

+

+				if ((token = xf86getSubToken (&(ptr->mon_comment))) != STRING)

+					Error (QUOTE_MSG, "UseModes");

+

+				/* add to the end of the list of modes sections 

+				   referenced here */

+				mptr = calloc (1, sizeof (XF86ConfModesLinkRec));

+				mptr->list.next = NULL;

+				mptr->ml_modes_str = val.str;

+				mptr->ml_modes = NULL;

+				ptr->mon_modes_sect_lst = (XF86ConfModesLinkPtr)

+					xf86addListItem((GenericListPtr)ptr->mon_modes_sect_lst,

+						    (GenericListPtr)mptr);

+			}

+			break;

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			xf86parseError (INVALID_KEYWORD_MSG, xf86tokenString ());

+			CLEANUP (ptr);

+			return NULL;

+			break;

+		}

+	}

+

+	if (!has_ident)

+		Error (NO_IDENT_MSG, NULL);

+

+#ifdef DEBUG

+	printf ("Monitor section parsed\n");

+#endif

+	return ptr;

+}

+

+#undef CLEANUP

+#define CLEANUP xf86freeModesList

+

+XF86ConfModesPtr

+xf86parseModesSection (void)

+{

+	int has_ident = FALSE;

+	int token;

+	parsePrologue (XF86ConfModesPtr, XF86ConfModesRec)

+

+	while ((token = xf86getToken (ModesTab)) != ENDSECTION)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->modes_comment = xf86addComment(ptr->modes_comment, val.str);

+			break;

+		case IDENTIFIER:

+			if (xf86getSubToken (&(ptr->modes_comment)) != STRING)

+				Error (QUOTE_MSG, "Identifier");

+			if (has_ident == TRUE)

+				Error (MULTIPLE_MSG, "Identifier");

+			ptr->modes_identifier = val.str;

+			has_ident = TRUE;

+			break;

+		case MODE:

+			HANDLE_LIST (mon_modeline_lst, xf86parseVerboseMode,

+						 XF86ConfModeLinePtr);

+			break;

+		case MODELINE:

+			HANDLE_LIST (mon_modeline_lst, xf86parseModeLine,

+						 XF86ConfModeLinePtr);

+			break;

+		default:

+			xf86parseError (INVALID_KEYWORD_MSG, xf86tokenString ());

+			CLEANUP (ptr);

+			return NULL;

+			break;

+		}

+	}

+

+	if (!has_ident)

+		Error (NO_IDENT_MSG, NULL);

+

+#ifdef DEBUG

+	printf ("Modes section parsed\n");

+#endif

+	return ptr;

+}

+

+#undef CLEANUP

+

+void

+xf86printMonitorSection (FILE * cf, XF86ConfMonitorPtr ptr)

+{

+	int i;

+	XF86ConfModeLinePtr mlptr;

+	XF86ConfModesLinkPtr mptr;

+

+	while (ptr)

+	{

+		mptr = ptr->mon_modes_sect_lst;

+		fprintf (cf, "Section \"Monitor\"\n");

+		if (ptr->mon_comment)

+			fprintf (cf, "%s", ptr->mon_comment);

+		if (ptr->mon_identifier)

+			fprintf (cf, "\tIdentifier   \"%s\"\n", ptr->mon_identifier);

+		if (ptr->mon_vendor)

+			fprintf (cf, "\tVendorName   \"%s\"\n", ptr->mon_vendor);

+		if (ptr->mon_modelname)

+			fprintf (cf, "\tModelName    \"%s\"\n", ptr->mon_modelname);

+		while (mptr) {

+			fprintf (cf, "\tUseModes     \"%s\"\n", mptr->ml_modes_str);

+			mptr = mptr->list.next;

+		}

+		if (ptr->mon_width)

+			fprintf (cf, "\tDisplaySize  %d\t%d\n",

+					 ptr->mon_width,

+					 ptr->mon_height);

+		for (i = 0; i < ptr->mon_n_hsync; i++)

+		{

+			fprintf (cf, "\tHorizSync    %2.1f - %2.1f\n",

+					 ptr->mon_hsync[i].lo,

+					 ptr->mon_hsync[i].hi);

+		}

+		for (i = 0; i < ptr->mon_n_vrefresh; i++)

+		{

+			fprintf (cf, "\tVertRefresh  %2.1f - %2.1f\n",

+					 ptr->mon_vrefresh[i].lo,

+					 ptr->mon_vrefresh[i].hi);

+		}

+		if (ptr->mon_gamma_red) {

+			if (ptr->mon_gamma_red == ptr->mon_gamma_green

+				&& ptr->mon_gamma_red == ptr->mon_gamma_blue)

+			{

+				fprintf (cf, "\tGamma        %.4g\n",

+					ptr->mon_gamma_red);

+			} else {

+				fprintf (cf, "\tGamma        %.4g %.4g %.4g\n",

+					ptr->mon_gamma_red,

+					ptr->mon_gamma_green,

+					ptr->mon_gamma_blue);

+			}

+		}

+		for (mlptr = ptr->mon_modeline_lst; mlptr; mlptr = mlptr->list.next)

+		{

+			fprintf (cf, "\tModeLine     \"%s\" %2.1f ",

+					 mlptr->ml_identifier, mlptr->ml_clock / 1000.0);

+			fprintf (cf, "%d %d %d %d %d %d %d %d",

+					 mlptr->ml_hdisplay, mlptr->ml_hsyncstart,

+					 mlptr->ml_hsyncend, mlptr->ml_htotal,

+					 mlptr->ml_vdisplay, mlptr->ml_vsyncstart,

+					 mlptr->ml_vsyncend, mlptr->ml_vtotal);

+			if (mlptr->ml_flags & XF86CONF_PHSYNC)

+				fprintf (cf, " +hsync");

+			if (mlptr->ml_flags & XF86CONF_NHSYNC)

+				fprintf (cf, " -hsync");

+			if (mlptr->ml_flags & XF86CONF_PVSYNC)

+				fprintf (cf, " +vsync");

+			if (mlptr->ml_flags & XF86CONF_NVSYNC)

+				fprintf (cf, " -vsync");

+			if (mlptr->ml_flags & XF86CONF_INTERLACE)

+				fprintf (cf, " interlace");

+			if (mlptr->ml_flags & XF86CONF_CSYNC)

+				fprintf (cf, " composite");

+			if (mlptr->ml_flags & XF86CONF_PCSYNC)

+				fprintf (cf, " +csync");

+			if (mlptr->ml_flags & XF86CONF_NCSYNC)

+				fprintf (cf, " -csync");

+			if (mlptr->ml_flags & XF86CONF_DBLSCAN)

+				fprintf (cf, " doublescan");

+			if (mlptr->ml_flags & XF86CONF_HSKEW)

+				fprintf (cf, " hskew %d", mlptr->ml_hskew);

+			if (mlptr->ml_flags & XF86CONF_BCAST)

+				fprintf (cf, " bcast");

+			fprintf (cf, "\n");

+		}

+		xf86printOptionList(cf, ptr->mon_option_lst, 1);

+		fprintf (cf, "EndSection\n\n");

+		ptr = ptr->list.next;

+	}

+}

+

+void

+xf86printModesSection (FILE * cf, XF86ConfModesPtr ptr)

+{

+	XF86ConfModeLinePtr mlptr;

+

+	while (ptr)

+	{

+		fprintf (cf, "Section \"Modes\"\n");

+		if (ptr->modes_comment)

+			fprintf (cf, "%s", ptr->modes_comment);

+		if (ptr->modes_identifier)

+			fprintf (cf, "\tIdentifier     \"%s\"\n", ptr->modes_identifier);

+		for (mlptr = ptr->mon_modeline_lst; mlptr; mlptr = mlptr->list.next)

+		{

+			fprintf (cf, "\tModeLine     \"%s\" %2.1f ",

+					 mlptr->ml_identifier, mlptr->ml_clock / 1000.0);

+			fprintf (cf, "%d %d %d %d %d %d %d %d",

+					 mlptr->ml_hdisplay, mlptr->ml_hsyncstart,

+					 mlptr->ml_hsyncend, mlptr->ml_htotal,

+					 mlptr->ml_vdisplay, mlptr->ml_vsyncstart,

+					 mlptr->ml_vsyncend, mlptr->ml_vtotal);

+			if (mlptr->ml_flags & XF86CONF_PHSYNC)

+				fprintf (cf, " +hsync");

+			if (mlptr->ml_flags & XF86CONF_NHSYNC)

+				fprintf (cf, " -hsync");

+			if (mlptr->ml_flags & XF86CONF_PVSYNC)

+				fprintf (cf, " +vsync");

+			if (mlptr->ml_flags & XF86CONF_NVSYNC)

+				fprintf (cf, " -vsync");

+			if (mlptr->ml_flags & XF86CONF_INTERLACE)

+				fprintf (cf, " interlace");

+			if (mlptr->ml_flags & XF86CONF_CSYNC)

+				fprintf (cf, " composite");

+			if (mlptr->ml_flags & XF86CONF_PCSYNC)

+				fprintf (cf, " +csync");

+			if (mlptr->ml_flags & XF86CONF_NCSYNC)

+				fprintf (cf, " -csync");

+			if (mlptr->ml_flags & XF86CONF_DBLSCAN)

+				fprintf (cf, " doublescan");

+			if (mlptr->ml_flags & XF86CONF_HSKEW)

+				fprintf (cf, " hskew %d", mlptr->ml_hskew);

+			if (mlptr->ml_flags & XF86CONF_VSCAN)

+				fprintf (cf, " vscan %d", mlptr->ml_vscan);

+			if (mlptr->ml_flags & XF86CONF_BCAST)

+				fprintf (cf, " bcast");

+			if (mlptr->ml_comment)

+				fprintf (cf, "%s", mlptr->ml_comment);

+			else

+				fprintf (cf, "\n");

+		}

+		fprintf (cf, "EndSection\n\n");

+		ptr = ptr->list.next;

+	}

+}

+

+void

+xf86freeMonitorList (XF86ConfMonitorPtr ptr)

+{

+	XF86ConfMonitorPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->mon_identifier);

+		TestFree (ptr->mon_vendor);

+		TestFree (ptr->mon_modelname);

+		TestFree (ptr->mon_comment);

+		xf86optionListFree (ptr->mon_option_lst);

+		xf86freeModeLineList (ptr->mon_modeline_lst);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+void

+xf86freeModesList (XF86ConfModesPtr ptr)

+{

+	XF86ConfModesPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->modes_identifier);

+		TestFree (ptr->modes_comment);

+		xf86freeModeLineList (ptr->mon_modeline_lst);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+XF86ConfMonitorPtr

+xf86findMonitor (const char *ident, XF86ConfMonitorPtr p)

+{

+	while (p)

+	{

+		if (xf86nameCompare (ident, p->mon_identifier) == 0)

+			return p;

+

+		p = p->list.next;

+	}

+	return NULL;

+}

+

+XF86ConfModesPtr

+xf86findModes (const char *ident, XF86ConfModesPtr p)

+{

+	while (p)

+	{

+		if (xf86nameCompare (ident, p->modes_identifier) == 0)

+			return p;

+

+		p = p->list.next;

+	}

+	return NULL;

+}

+

+XF86ConfModeLinePtr

+xf86findModeLine (const char *ident, XF86ConfModeLinePtr p)

+{

+	while (p)

+	{

+		if (xf86nameCompare (ident, p->ml_identifier) == 0)

+			return p;

+

+		p = p->list.next;

+	}

+	return NULL;

+}

+

+int

+xf86validateMonitor (XF86ConfigPtr p, XF86ConfScreenPtr screen)

+{

+	XF86ConfMonitorPtr monitor = screen->scrn_monitor;

+	XF86ConfModesLinkPtr modeslnk = monitor->mon_modes_sect_lst;

+	XF86ConfModesPtr modes;

+	while(modeslnk)

+	{

+		modes = xf86findModes (modeslnk->ml_modes_str, p->conf_modes_lst);

+		if (!modes)

+		{

+			xf86validationError (UNDEFINED_MODES_MSG, 

+					     modeslnk->ml_modes_str, 

+					     screen->scrn_identifier);

+			return FALSE;

+		}

+		modeslnk->ml_modes = modes;

+		modeslnk = modeslnk->list.next;

+	}

+	return TRUE;

+}

diff --git a/xorg-server/hw/xfree86/parser/Screen.c b/xorg-server/hw/xfree86/parser/Screen.c
index b3b004df6..b5667a79e 100644
--- a/xorg-server/hw/xfree86/parser/Screen.c
+++ b/xorg-server/hw/xfree86/parser/Screen.c
@@ -1,569 +1,569 @@
-/* 
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Parser.h"
-#include "xf86tokens.h"
-#include "Configint.h"
-
-extern LexRec val;
-
-static xf86ConfigSymTabRec DisplayTab[] =
-{
-	{ENDSUBSECTION, "endsubsection"},
-	{MODES, "modes"},
-	{VIEWPORT, "viewport"},
-	{VIRTUAL, "virtual"},
-	{VISUAL, "visual"},
-	{BLACK_TOK, "black"},
-	{WHITE_TOK, "white"},
-	{DEPTH, "depth"},
-	{BPP, "fbbpp"},
-	{WEIGHT, "weight"},
-	{OPTION, "option"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeDisplayList
-
-static XF86ConfDisplayPtr
-xf86parseDisplaySubSection (void)
-{
-	int token;
-	parsePrologue (XF86ConfDisplayPtr, XF86ConfDisplayRec)
-
-	ptr->disp_black.red = ptr->disp_black.green = ptr->disp_black.blue = -1;
-	ptr->disp_white.red = ptr->disp_white.green = ptr->disp_white.blue = -1;
-	ptr->disp_frameX0 = ptr->disp_frameY0 = -1;
-	while ((token = xf86getToken (DisplayTab)) != ENDSUBSECTION)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->disp_comment = xf86addComment(ptr->disp_comment, val.str);
-			break;
-		case VIEWPORT:
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (VIEWPORT_MSG, NULL);
-			ptr->disp_frameX0 = val.num;
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (VIEWPORT_MSG, NULL);
-			ptr->disp_frameY0 = val.num;
-			break;
-		case VIRTUAL:
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (VIRTUAL_MSG, NULL);
-			ptr->disp_virtualX = val.num;
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (VIRTUAL_MSG, NULL);
-			ptr->disp_virtualY = val.num;
-			break;
-		case DEPTH:
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (NUMBER_MSG, "Display");
-			ptr->disp_depth = val.num;
-			break;
-		case BPP:
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (NUMBER_MSG, "Display");
-			ptr->disp_bpp = val.num;
-			break;
-		case VISUAL:
-			if (xf86getSubToken (&(ptr->disp_comment)) != STRING)
-				Error (QUOTE_MSG, "Display");
-			ptr->disp_visual = val.str;
-			break;
-		case WEIGHT:
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (WEIGHT_MSG, NULL);
-			ptr->disp_weight.red = val.num;
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (WEIGHT_MSG, NULL);
-			ptr->disp_weight.green = val.num;
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (WEIGHT_MSG, NULL);
-			ptr->disp_weight.blue = val.num;
-			break;
-		case BLACK_TOK:
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (BLACK_MSG, NULL);
-			ptr->disp_black.red = val.num;
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (BLACK_MSG, NULL);
-			ptr->disp_black.green = val.num;
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (BLACK_MSG, NULL);
-			ptr->disp_black.blue = val.num;
-			break;
-		case WHITE_TOK:
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (WHITE_MSG, NULL);
-			ptr->disp_white.red = val.num;
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (WHITE_MSG, NULL);
-			ptr->disp_white.green = val.num;
-			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)
-				Error (WHITE_MSG, NULL);
-			ptr->disp_white.blue = val.num;
-			break;
-		case MODES:
-			{
-				XF86ModePtr mptr;
-
-				while ((token = xf86getSubTokenWithTab (&(ptr->disp_comment), DisplayTab)) == STRING)
-				{
-					mptr = calloc (1, sizeof (XF86ModeRec));
-					mptr->mode_name = val.str;
-					mptr->list.next = NULL;
-					ptr->disp_mode_lst = (XF86ModePtr)
-						xf86addListItem ((glp) ptr->disp_mode_lst, (glp) mptr);
-				}
-				xf86unGetToken (token);
-			}
-			break;
-		case OPTION:
-			ptr->disp_option_lst = xf86parseOption(ptr->disp_option_lst);
-			break;
-			
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-			break;
-		}
-	}
-
-#ifdef DEBUG
-	printf ("Display subsection parsed\n");
-#endif
-
-	return ptr;
-}
-
-#undef CLEANUP
-
-static xf86ConfigSymTabRec ScreenTab[] =
-{
-	{ENDSECTION, "endsection"},
-	{IDENTIFIER, "identifier"},
-	{OBSDRIVER, "driver"},
-	{MDEVICE, "device"},
-	{MONITOR, "monitor"},
-	{VIDEOADAPTOR, "videoadaptor"},
-	{SCREENNO, "screenno"},
-	{SUBSECTION, "subsection"},
-	{DEFAULTDEPTH, "defaultcolordepth"},
-	{DEFAULTDEPTH, "defaultdepth"},
-	{DEFAULTBPP, "defaultbpp"},
-	{DEFAULTFBBPP, "defaultfbbpp"},
-	{VIRTUAL, "virtual"},
-	{OPTION, "option"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeScreenList
-XF86ConfScreenPtr
-xf86parseScreenSection (void)
-{
-	int has_ident = FALSE;
-	int has_driver= FALSE;
-	int token;
-
-	parsePrologue (XF86ConfScreenPtr, XF86ConfScreenRec)
-
-		while ((token = xf86getToken (ScreenTab)) != ENDSECTION)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->scrn_comment = xf86addComment(ptr->scrn_comment, val.str);
-			break;
-		case IDENTIFIER:
-			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)
-				Error (QUOTE_MSG, "Identifier");
-			ptr->scrn_identifier = val.str;
-			if (has_ident || has_driver)
-				Error (ONLY_ONE_MSG,"Identifier or Driver");
-			has_ident = TRUE;
-			break;
-		case OBSDRIVER:
-			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)
-				Error (QUOTE_MSG, "Driver");
-			ptr->scrn_obso_driver = val.str;
-			if (has_ident || has_driver)
-				Error (ONLY_ONE_MSG,"Identifier or Driver");
-			has_driver = TRUE;
-			break;
-		case DEFAULTDEPTH:
-			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)
-				Error (NUMBER_MSG, "DefaultDepth");
-			ptr->scrn_defaultdepth = val.num;
-			break;
-		case DEFAULTBPP:
-			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)
-				Error (NUMBER_MSG, "DefaultBPP");
-			ptr->scrn_defaultbpp = val.num;
-			break;
-		case DEFAULTFBBPP:
-			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)
-				Error (NUMBER_MSG, "DefaultFbBPP");
-			ptr->scrn_defaultfbbpp = val.num;
-			break;
-		case MDEVICE:
-			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)
-				Error (QUOTE_MSG, "Device");
-			ptr->scrn_device_str = val.str;
-			break;
-		case MONITOR:
-			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)
-				Error (QUOTE_MSG, "Monitor");
-			ptr->scrn_monitor_str = val.str;
-			break;
-		case VIDEOADAPTOR:
-			{
-				XF86ConfAdaptorLinkPtr aptr;
-
-				if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)
-					Error (QUOTE_MSG, "VideoAdaptor");
-
-				/* Don't allow duplicates */
-				for (aptr = ptr->scrn_adaptor_lst; aptr; 
-					aptr = (XF86ConfAdaptorLinkPtr) aptr->list.next)
-					if (xf86nameCompare (val.str, aptr->al_adaptor_str) == 0)
-						break;
-
-				if (aptr == NULL)
-				{
-					aptr = calloc (1, sizeof (XF86ConfAdaptorLinkRec));
-					aptr->list.next = NULL;
-					aptr->al_adaptor_str = val.str;
-					ptr->scrn_adaptor_lst = (XF86ConfAdaptorLinkPtr)
-						xf86addListItem ((glp) ptr->scrn_adaptor_lst, (glp) aptr);
-				}
-			}
-			break;
-		case VIRTUAL:
-			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)
-				Error (VIRTUAL_MSG, NULL);
-			ptr->scrn_virtualX = val.num;
-			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)
-				Error (VIRTUAL_MSG, NULL);
-			ptr->scrn_virtualY = val.num;
-			break;
-		case OPTION:
-			ptr->scrn_option_lst = xf86parseOption(ptr->scrn_option_lst);
-			break;
-		case SUBSECTION:
-			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)
-				Error (QUOTE_MSG, "SubSection");
-			{
-				free(val.str);
-				HANDLE_LIST (scrn_display_lst, xf86parseDisplaySubSection,
-							 XF86ConfDisplayPtr);
-			}
-			break;
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-			break;
-		}
-	}
-
-	if (!has_ident && !has_driver)
-		Error (NO_IDENT_MSG, NULL);
-
-#ifdef DEBUG
-	printf ("Screen section parsed\n");
-#endif
-
-	return ptr;
-}
-
-void
-xf86printScreenSection (FILE * cf, XF86ConfScreenPtr ptr)
-{
-	XF86ConfAdaptorLinkPtr aptr;
-	XF86ConfDisplayPtr dptr;
-	XF86ModePtr mptr;
-
-	while (ptr)
-	{
-		fprintf (cf, "Section \"Screen\"\n");
-		if (ptr->scrn_comment)
-			fprintf (cf, "%s", ptr->scrn_comment);
-		if (ptr->scrn_identifier)
-			fprintf (cf, "\tIdentifier \"%s\"\n", ptr->scrn_identifier);
-		if (ptr->scrn_obso_driver)
-			fprintf (cf, "\tDriver     \"%s\"\n", ptr->scrn_obso_driver);
-		if (ptr->scrn_device_str)
-			fprintf (cf, "\tDevice     \"%s\"\n", ptr->scrn_device_str);
-		if (ptr->scrn_monitor_str)
-			fprintf (cf, "\tMonitor    \"%s\"\n", ptr->scrn_monitor_str);
-		if (ptr->scrn_defaultdepth)
-			fprintf (cf, "\tDefaultDepth     %d\n",
-					 ptr->scrn_defaultdepth);
-		if (ptr->scrn_defaultbpp)
-			fprintf (cf, "\tDefaultBPP     %d\n",
-					 ptr->scrn_defaultbpp);
-		if (ptr->scrn_defaultfbbpp)
-			fprintf (cf, "\tDefaultFbBPP     %d\n",
-					 ptr->scrn_defaultfbbpp);
-		xf86printOptionList(cf, ptr->scrn_option_lst, 1);
-		for (aptr = ptr->scrn_adaptor_lst; aptr; aptr = aptr->list.next)
-		{
-			fprintf (cf, "\tVideoAdaptor \"%s\"\n", aptr->al_adaptor_str);
-		}
-		if (ptr->scrn_virtualX && ptr->scrn_virtualY)
-			fprintf (cf, "\tVirtual     %d %d\n",
-				 ptr->scrn_virtualX,
-				 ptr->scrn_virtualY);
-		for (dptr = ptr->scrn_display_lst; dptr; dptr = dptr->list.next)
-		{
-			fprintf (cf, "\tSubSection \"Display\"\n");
-			if (dptr->disp_comment)
-				fprintf (cf, "%s", dptr->disp_comment);
-			if (dptr->disp_frameX0 >= 0 || dptr->disp_frameY0 >= 0)
-			{
-				fprintf (cf, "\t\tViewport   %d %d\n",
-						 dptr->disp_frameX0, dptr->disp_frameY0);
-			}
-			if (dptr->disp_virtualX != 0 || dptr->disp_virtualY != 0)
-			{
-				fprintf (cf, "\t\tVirtual   %d %d\n",
-						 dptr->disp_virtualX, dptr->disp_virtualY);
-			}
-			if (dptr->disp_depth)
-			{
-				fprintf (cf, "\t\tDepth     %d\n", dptr->disp_depth);
-			}
-			if (dptr->disp_bpp)
-			{
-				fprintf (cf, "\t\tFbBPP     %d\n", dptr->disp_bpp);
-			}
-			if (dptr->disp_visual)
-			{
-				fprintf (cf, "\t\tVisual    \"%s\"\n", dptr->disp_visual);
-			}
-			if (dptr->disp_weight.red != 0)
-			{
-				fprintf (cf, "\t\tWeight    %d %d %d\n",
-					 dptr->disp_weight.red, dptr->disp_weight.green, dptr->disp_weight.blue);
-			}
-			if (dptr->disp_black.red != -1)
-			{
-				fprintf (cf, "\t\tBlack     0x%04x 0x%04x 0x%04x\n",
-					  dptr->disp_black.red, dptr->disp_black.green, dptr->disp_black.blue);
-			}
-			if (dptr->disp_white.red != -1)
-			{
-				fprintf (cf, "\t\tWhite     0x%04x 0x%04x 0x%04x\n",
-					  dptr->disp_white.red, dptr->disp_white.green, dptr->disp_white.blue);
-			}
-			if (dptr->disp_mode_lst)
-			{
-				fprintf (cf, "\t\tModes   ");
-			}
-			for (mptr = dptr->disp_mode_lst; mptr; mptr = mptr->list.next)
-			{
-				fprintf (cf, " \"%s\"", mptr->mode_name);
-			}
-			if (dptr->disp_mode_lst)
-			{
-				fprintf (cf, "\n");
-			}
-			xf86printOptionList(cf, dptr->disp_option_lst, 2);
-			fprintf (cf, "\tEndSubSection\n");
-		}
-		fprintf (cf, "EndSection\n\n");
-		ptr = ptr->list.next;
-	}
-
-}
-
-void
-xf86freeScreenList (XF86ConfScreenPtr ptr)
-{
-	XF86ConfScreenPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->scrn_identifier);
-		TestFree (ptr->scrn_monitor_str);
-		TestFree (ptr->scrn_device_str);
-		TestFree (ptr->scrn_comment);
-		xf86optionListFree (ptr->scrn_option_lst);
-		xf86freeAdaptorLinkList (ptr->scrn_adaptor_lst);
-		xf86freeDisplayList (ptr->scrn_display_lst);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-void
-xf86freeAdaptorLinkList (XF86ConfAdaptorLinkPtr ptr)
-{
-	XF86ConfAdaptorLinkPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->al_adaptor_str);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-void
-xf86freeDisplayList (XF86ConfDisplayPtr ptr)
-{
-	XF86ConfDisplayPtr prev;
-
-	while (ptr)
-	{
-		xf86freeModeList (ptr->disp_mode_lst);
-		xf86optionListFree (ptr->disp_option_lst);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-void
-xf86freeModeList (XF86ModePtr ptr)
-{
-	XF86ModePtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->mode_name);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-int
-xf86validateScreen (XF86ConfigPtr p)
-{
-	XF86ConfScreenPtr screen = p->conf_screen_lst;
-	XF86ConfMonitorPtr monitor;
-	XF86ConfAdaptorLinkPtr adaptor;
-
-	while (screen)
-	{
-		if (screen->scrn_obso_driver && !screen->scrn_identifier)
-			screen->scrn_identifier = screen->scrn_obso_driver;
-
-		monitor = xf86findMonitor (screen->scrn_monitor_str, p->conf_monitor_lst);
-		if (screen->scrn_monitor_str)
-		{
-			if (monitor)
-			{
-				screen->scrn_monitor = monitor;
-				if (!xf86validateMonitor(p, screen))
-					return (FALSE);
-			}
-		}
-
-		screen->scrn_device= xf86findDevice (screen->scrn_device_str, p->conf_device_lst);
-
-		adaptor = screen->scrn_adaptor_lst;
-		while (adaptor)
-		{
-			adaptor->al_adaptor = xf86findVideoAdaptor (adaptor->al_adaptor_str, p->conf_videoadaptor_lst);
-			if (!adaptor->al_adaptor)
-			{
-				xf86validationError (UNDEFINED_ADAPTOR_MSG, adaptor->al_adaptor_str, screen->scrn_identifier);
-				return (FALSE);
-			}
-			else if (adaptor->al_adaptor->va_fwdref)
-			{
-				xf86validationError (ADAPTOR_REF_TWICE_MSG, adaptor->al_adaptor_str,
-						     adaptor->al_adaptor->va_fwdref);
-				return (FALSE);
-			}
-
-			adaptor->al_adaptor->va_fwdref = strdup(screen->scrn_identifier);
-			adaptor = adaptor->list.next;
-		}
-
-		screen = screen->list.next;
-	}
-
-	return (TRUE);
-}
-
-XF86ConfScreenPtr
-xf86findScreen (const char *ident, XF86ConfScreenPtr p)
-{
-	while (p)
-	{
-		if (xf86nameCompare (ident, p->scrn_identifier) == 0)
-			return (p);
-
-		p = p->list.next;
-	}
-	return (NULL);
-}
-
+/* 

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86Parser.h"

+#include "xf86tokens.h"

+#include "Configint.h"

+

+extern LexRec val;

+

+static xf86ConfigSymTabRec DisplayTab[] =

+{

+	{ENDSUBSECTION, "endsubsection"},

+	{MODES, "modes"},

+	{VIEWPORT, "viewport"},

+	{VIRTUAL, "virtual"},

+	{VISUAL, "visual"},

+	{BLACK_TOK, "black"},

+	{WHITE_TOK, "white"},

+	{DEPTH, "depth"},

+	{BPP, "fbbpp"},

+	{WEIGHT, "weight"},

+	{OPTION, "option"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeDisplayList

+

+static XF86ConfDisplayPtr

+xf86parseDisplaySubSection (void)

+{

+	int token;

+	parsePrologue (XF86ConfDisplayPtr, XF86ConfDisplayRec)

+

+	ptr->disp_black.red = ptr->disp_black.green = ptr->disp_black.blue = -1;

+	ptr->disp_white.red = ptr->disp_white.green = ptr->disp_white.blue = -1;

+	ptr->disp_frameX0 = ptr->disp_frameY0 = -1;

+	while ((token = xf86getToken (DisplayTab)) != ENDSUBSECTION)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->disp_comment = xf86addComment(ptr->disp_comment, val.str);

+			break;

+		case VIEWPORT:

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (VIEWPORT_MSG, NULL);

+			ptr->disp_frameX0 = val.num;

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (VIEWPORT_MSG, NULL);

+			ptr->disp_frameY0 = val.num;

+			break;

+		case VIRTUAL:

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (VIRTUAL_MSG, NULL);

+			ptr->disp_virtualX = val.num;

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (VIRTUAL_MSG, NULL);

+			ptr->disp_virtualY = val.num;

+			break;

+		case DEPTH:

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (NUMBER_MSG, "Display");

+			ptr->disp_depth = val.num;

+			break;

+		case BPP:

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (NUMBER_MSG, "Display");

+			ptr->disp_bpp = val.num;

+			break;

+		case VISUAL:

+			if (xf86getSubToken (&(ptr->disp_comment)) != STRING)

+				Error (QUOTE_MSG, "Display");

+			ptr->disp_visual = val.str;

+			break;

+		case WEIGHT:

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (WEIGHT_MSG, NULL);

+			ptr->disp_weight.red = val.num;

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (WEIGHT_MSG, NULL);

+			ptr->disp_weight.green = val.num;

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (WEIGHT_MSG, NULL);

+			ptr->disp_weight.blue = val.num;

+			break;

+		case BLACK_TOK:

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (BLACK_MSG, NULL);

+			ptr->disp_black.red = val.num;

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (BLACK_MSG, NULL);

+			ptr->disp_black.green = val.num;

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (BLACK_MSG, NULL);

+			ptr->disp_black.blue = val.num;

+			break;

+		case WHITE_TOK:

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (WHITE_MSG, NULL);

+			ptr->disp_white.red = val.num;

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (WHITE_MSG, NULL);

+			ptr->disp_white.green = val.num;

+			if (xf86getSubToken (&(ptr->disp_comment)) != NUMBER)

+				Error (WHITE_MSG, NULL);

+			ptr->disp_white.blue = val.num;

+			break;

+		case MODES:

+			{

+				XF86ModePtr mptr;

+

+				while ((token = xf86getSubTokenWithTab (&(ptr->disp_comment), DisplayTab)) == STRING)

+				{

+					mptr = calloc (1, sizeof (XF86ModeRec));

+					mptr->mode_name = val.str;

+					mptr->list.next = NULL;

+					ptr->disp_mode_lst = (XF86ModePtr)

+						xf86addListItem ((glp) ptr->disp_mode_lst, (glp) mptr);

+				}

+				xf86unGetToken (token);

+			}

+			break;

+		case OPTION:

+			ptr->disp_option_lst = xf86parseOption(ptr->disp_option_lst);

+			break;

+			

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+			break;

+		}

+	}

+

+#ifdef DEBUG

+	printf ("Display subsection parsed\n");

+#endif

+

+	return ptr;

+}

+

+#undef CLEANUP

+

+static xf86ConfigSymTabRec ScreenTab[] =

+{

+	{ENDSECTION, "endsection"},

+	{IDENTIFIER, "identifier"},

+	{OBSDRIVER, "driver"},

+	{MDEVICE, "device"},

+	{MONITOR, "monitor"},

+	{VIDEOADAPTOR, "videoadaptor"},

+	{SCREENNO, "screenno"},

+	{SUBSECTION, "subsection"},

+	{DEFAULTDEPTH, "defaultcolordepth"},

+	{DEFAULTDEPTH, "defaultdepth"},

+	{DEFAULTBPP, "defaultbpp"},

+	{DEFAULTFBBPP, "defaultfbbpp"},

+	{VIRTUAL, "virtual"},

+	{OPTION, "option"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeScreenList

+XF86ConfScreenPtr

+xf86parseScreenSection (void)

+{

+	int has_ident = FALSE;

+	int has_driver= FALSE;

+	int token;

+

+	parsePrologue (XF86ConfScreenPtr, XF86ConfScreenRec)

+

+		while ((token = xf86getToken (ScreenTab)) != ENDSECTION)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->scrn_comment = xf86addComment(ptr->scrn_comment, val.str);

+			break;

+		case IDENTIFIER:

+			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)

+				Error (QUOTE_MSG, "Identifier");

+			ptr->scrn_identifier = val.str;

+			if (has_ident || has_driver)

+				Error (ONLY_ONE_MSG,"Identifier or Driver");

+			has_ident = TRUE;

+			break;

+		case OBSDRIVER:

+			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)

+				Error (QUOTE_MSG, "Driver");

+			ptr->scrn_obso_driver = val.str;

+			if (has_ident || has_driver)

+				Error (ONLY_ONE_MSG,"Identifier or Driver");

+			has_driver = TRUE;

+			break;

+		case DEFAULTDEPTH:

+			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)

+				Error (NUMBER_MSG, "DefaultDepth");

+			ptr->scrn_defaultdepth = val.num;

+			break;

+		case DEFAULTBPP:

+			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)

+				Error (NUMBER_MSG, "DefaultBPP");

+			ptr->scrn_defaultbpp = val.num;

+			break;

+		case DEFAULTFBBPP:

+			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)

+				Error (NUMBER_MSG, "DefaultFbBPP");

+			ptr->scrn_defaultfbbpp = val.num;

+			break;

+		case MDEVICE:

+			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)

+				Error (QUOTE_MSG, "Device");

+			ptr->scrn_device_str = val.str;

+			break;

+		case MONITOR:

+			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)

+				Error (QUOTE_MSG, "Monitor");

+			ptr->scrn_monitor_str = val.str;

+			break;

+		case VIDEOADAPTOR:

+			{

+				XF86ConfAdaptorLinkPtr aptr;

+

+				if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)

+					Error (QUOTE_MSG, "VideoAdaptor");

+

+				/* Don't allow duplicates */

+				for (aptr = ptr->scrn_adaptor_lst; aptr; 

+					aptr = (XF86ConfAdaptorLinkPtr) aptr->list.next)

+					if (xf86nameCompare (val.str, aptr->al_adaptor_str) == 0)

+						break;

+

+				if (aptr == NULL)

+				{

+					aptr = calloc (1, sizeof (XF86ConfAdaptorLinkRec));

+					aptr->list.next = NULL;

+					aptr->al_adaptor_str = val.str;

+					ptr->scrn_adaptor_lst = (XF86ConfAdaptorLinkPtr)

+						xf86addListItem ((glp) ptr->scrn_adaptor_lst, (glp) aptr);

+				}

+			}

+			break;

+		case VIRTUAL:

+			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)

+				Error (VIRTUAL_MSG, NULL);

+			ptr->scrn_virtualX = val.num;

+			if (xf86getSubToken (&(ptr->scrn_comment)) != NUMBER)

+				Error (VIRTUAL_MSG, NULL);

+			ptr->scrn_virtualY = val.num;

+			break;

+		case OPTION:

+			ptr->scrn_option_lst = xf86parseOption(ptr->scrn_option_lst);

+			break;

+		case SUBSECTION:

+			if (xf86getSubToken (&(ptr->scrn_comment)) != STRING)

+				Error (QUOTE_MSG, "SubSection");

+			{

+				free(val.str);

+				HANDLE_LIST (scrn_display_lst, xf86parseDisplaySubSection,

+							 XF86ConfDisplayPtr);

+			}

+			break;

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+			break;

+		}

+	}

+

+	if (!has_ident && !has_driver)

+		Error (NO_IDENT_MSG, NULL);

+

+#ifdef DEBUG

+	printf ("Screen section parsed\n");

+#endif

+

+	return ptr;

+}

+

+void

+xf86printScreenSection (FILE * cf, XF86ConfScreenPtr ptr)

+{

+	XF86ConfAdaptorLinkPtr aptr;

+	XF86ConfDisplayPtr dptr;

+	XF86ModePtr mptr;

+

+	while (ptr)

+	{

+		fprintf (cf, "Section \"Screen\"\n");

+		if (ptr->scrn_comment)

+			fprintf (cf, "%s", ptr->scrn_comment);

+		if (ptr->scrn_identifier)

+			fprintf (cf, "\tIdentifier \"%s\"\n", ptr->scrn_identifier);

+		if (ptr->scrn_obso_driver)

+			fprintf (cf, "\tDriver     \"%s\"\n", ptr->scrn_obso_driver);

+		if (ptr->scrn_device_str)

+			fprintf (cf, "\tDevice     \"%s\"\n", ptr->scrn_device_str);

+		if (ptr->scrn_monitor_str)

+			fprintf (cf, "\tMonitor    \"%s\"\n", ptr->scrn_monitor_str);

+		if (ptr->scrn_defaultdepth)

+			fprintf (cf, "\tDefaultDepth     %d\n",

+					 ptr->scrn_defaultdepth);

+		if (ptr->scrn_defaultbpp)

+			fprintf (cf, "\tDefaultBPP     %d\n",

+					 ptr->scrn_defaultbpp);

+		if (ptr->scrn_defaultfbbpp)

+			fprintf (cf, "\tDefaultFbBPP     %d\n",

+					 ptr->scrn_defaultfbbpp);

+		xf86printOptionList(cf, ptr->scrn_option_lst, 1);

+		for (aptr = ptr->scrn_adaptor_lst; aptr; aptr = aptr->list.next)

+		{

+			fprintf (cf, "\tVideoAdaptor \"%s\"\n", aptr->al_adaptor_str);

+		}

+		if (ptr->scrn_virtualX && ptr->scrn_virtualY)

+			fprintf (cf, "\tVirtual     %d %d\n",

+				 ptr->scrn_virtualX,

+				 ptr->scrn_virtualY);

+		for (dptr = ptr->scrn_display_lst; dptr; dptr = dptr->list.next)

+		{

+			fprintf (cf, "\tSubSection \"Display\"\n");

+			if (dptr->disp_comment)

+				fprintf (cf, "%s", dptr->disp_comment);

+			if (dptr->disp_frameX0 >= 0 || dptr->disp_frameY0 >= 0)

+			{

+				fprintf (cf, "\t\tViewport   %d %d\n",

+						 dptr->disp_frameX0, dptr->disp_frameY0);

+			}

+			if (dptr->disp_virtualX != 0 || dptr->disp_virtualY != 0)

+			{

+				fprintf (cf, "\t\tVirtual   %d %d\n",

+						 dptr->disp_virtualX, dptr->disp_virtualY);

+			}

+			if (dptr->disp_depth)

+			{

+				fprintf (cf, "\t\tDepth     %d\n", dptr->disp_depth);

+			}

+			if (dptr->disp_bpp)

+			{

+				fprintf (cf, "\t\tFbBPP     %d\n", dptr->disp_bpp);

+			}

+			if (dptr->disp_visual)

+			{

+				fprintf (cf, "\t\tVisual    \"%s\"\n", dptr->disp_visual);

+			}

+			if (dptr->disp_weight.red != 0)

+			{

+				fprintf (cf, "\t\tWeight    %d %d %d\n",

+					 dptr->disp_weight.red, dptr->disp_weight.green, dptr->disp_weight.blue);

+			}

+			if (dptr->disp_black.red != -1)

+			{

+				fprintf (cf, "\t\tBlack     0x%04x 0x%04x 0x%04x\n",

+					  dptr->disp_black.red, dptr->disp_black.green, dptr->disp_black.blue);

+			}

+			if (dptr->disp_white.red != -1)

+			{

+				fprintf (cf, "\t\tWhite     0x%04x 0x%04x 0x%04x\n",

+					  dptr->disp_white.red, dptr->disp_white.green, dptr->disp_white.blue);

+			}

+			if (dptr->disp_mode_lst)

+			{

+				fprintf (cf, "\t\tModes   ");

+			}

+			for (mptr = dptr->disp_mode_lst; mptr; mptr = mptr->list.next)

+			{

+				fprintf (cf, " \"%s\"", mptr->mode_name);

+			}

+			if (dptr->disp_mode_lst)

+			{

+				fprintf (cf, "\n");

+			}

+			xf86printOptionList(cf, dptr->disp_option_lst, 2);

+			fprintf (cf, "\tEndSubSection\n");

+		}

+		fprintf (cf, "EndSection\n\n");

+		ptr = ptr->list.next;

+	}

+

+}

+

+void

+xf86freeScreenList (XF86ConfScreenPtr ptr)

+{

+	XF86ConfScreenPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->scrn_identifier);

+		TestFree (ptr->scrn_monitor_str);

+		TestFree (ptr->scrn_device_str);

+		TestFree (ptr->scrn_comment);

+		xf86optionListFree (ptr->scrn_option_lst);

+		xf86freeAdaptorLinkList (ptr->scrn_adaptor_lst);

+		xf86freeDisplayList (ptr->scrn_display_lst);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+void

+xf86freeAdaptorLinkList (XF86ConfAdaptorLinkPtr ptr)

+{

+	XF86ConfAdaptorLinkPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->al_adaptor_str);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+void

+xf86freeDisplayList (XF86ConfDisplayPtr ptr)

+{

+	XF86ConfDisplayPtr prev;

+

+	while (ptr)

+	{

+		xf86freeModeList (ptr->disp_mode_lst);

+		xf86optionListFree (ptr->disp_option_lst);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+void

+xf86freeModeList (XF86ModePtr ptr)

+{

+	XF86ModePtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->mode_name);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+int

+xf86validateScreen (XF86ConfigPtr p)

+{

+	XF86ConfScreenPtr screen = p->conf_screen_lst;

+	XF86ConfMonitorPtr monitor;

+	XF86ConfAdaptorLinkPtr adaptor;

+

+	while (screen)

+	{

+		if (screen->scrn_obso_driver && !screen->scrn_identifier)

+			screen->scrn_identifier = screen->scrn_obso_driver;

+

+		monitor = xf86findMonitor (screen->scrn_monitor_str, p->conf_monitor_lst);

+		if (screen->scrn_monitor_str)

+		{

+			if (monitor)

+			{

+				screen->scrn_monitor = monitor;

+				if (!xf86validateMonitor(p, screen))

+					return FALSE;

+			}

+		}

+

+		screen->scrn_device= xf86findDevice (screen->scrn_device_str, p->conf_device_lst);

+

+		adaptor = screen->scrn_adaptor_lst;

+		while (adaptor)

+		{

+			adaptor->al_adaptor = xf86findVideoAdaptor (adaptor->al_adaptor_str, p->conf_videoadaptor_lst);

+			if (!adaptor->al_adaptor)

+			{

+				xf86validationError (UNDEFINED_ADAPTOR_MSG, adaptor->al_adaptor_str, screen->scrn_identifier);

+				return FALSE;

+			}

+			else if (adaptor->al_adaptor->va_fwdref)

+			{

+				xf86validationError (ADAPTOR_REF_TWICE_MSG, adaptor->al_adaptor_str,

+						     adaptor->al_adaptor->va_fwdref);

+				return FALSE;

+			}

+

+			adaptor->al_adaptor->va_fwdref = strdup(screen->scrn_identifier);

+			adaptor = adaptor->list.next;

+		}

+

+		screen = screen->list.next;

+	}

+

+	return TRUE;

+}

+

+XF86ConfScreenPtr

+xf86findScreen (const char *ident, XF86ConfScreenPtr p)

+{

+	while (p)

+	{

+		if (xf86nameCompare (ident, p->scrn_identifier) == 0)

+			return p;

+

+		p = p->list.next;

+	}

+	return NULL;

+}

+

diff --git a/xorg-server/hw/xfree86/parser/Video.c b/xorg-server/hw/xfree86/parser/Video.c
index beeb43e4f..40a909707 100644
--- a/xorg-server/hw/xfree86/parser/Video.c
+++ b/xorg-server/hw/xfree86/parser/Video.c
@@ -1,296 +1,296 @@
-/* 
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Parser.h"
-#include "xf86tokens.h"
-#include "Configint.h"
-
-extern LexRec val;
-
-static xf86ConfigSymTabRec VideoPortTab[] =
-{
-	{ENDSUBSECTION, "endsubsection"},
-	{IDENTIFIER, "identifier"},
-	{OPTION, "option"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeVideoPortList
-
-static void
-xf86freeVideoPortList (XF86ConfVideoPortPtr ptr)
-{
-	XF86ConfVideoPortPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->vp_identifier);
-		TestFree (ptr->vp_comment);
-		xf86optionListFree (ptr->vp_option_lst);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-static XF86ConfVideoPortPtr
-xf86parseVideoPortSubSection (void)
-{
-	int has_ident = FALSE;
-	int token;
-	parsePrologue (XF86ConfVideoPortPtr, XF86ConfVideoPortRec)
-
-	while ((token = xf86getToken (VideoPortTab)) != ENDSUBSECTION)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->vp_comment = xf86addComment(ptr->vp_comment, val.str);
-			break;
-		case IDENTIFIER:
-			if (xf86getSubToken (&(ptr->vp_comment)) != STRING)
-				Error (QUOTE_MSG, "Identifier");
-			if (has_ident == TRUE)
-				Error (MULTIPLE_MSG, "Identifier");
-			ptr->vp_identifier = val.str;
-			has_ident = TRUE;
-			break;
-		case OPTION:
-			ptr->vp_option_lst = xf86parseOption(ptr->vp_option_lst);
-			break;
-
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-			break;
-		}
-	}
-
-#ifdef DEBUG
-	printf ("VideoPort subsection parsed\n");
-#endif
-
-	return ptr;
-}
-
-#undef CLEANUP
-
-static xf86ConfigSymTabRec VideoAdaptorTab[] =
-{
-	{ENDSECTION, "endsection"},
-	{IDENTIFIER, "identifier"},
-	{VENDOR, "vendorname"},
-	{BOARD, "boardname"},
-	{BUSID, "busid"},
-	{DRIVER, "driver"},
-	{OPTION, "option"},
-	{SUBSECTION, "subsection"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeVideoAdaptorList
-
-XF86ConfVideoAdaptorPtr
-xf86parseVideoAdaptorSection (void)
-{
-	int has_ident = FALSE;
-	int token;
-
-	parsePrologue (XF86ConfVideoAdaptorPtr, XF86ConfVideoAdaptorRec)
-
-	while ((token = xf86getToken (VideoAdaptorTab)) != ENDSECTION)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->va_comment = xf86addComment(ptr->va_comment, val.str);
-			break;
-		case IDENTIFIER:
-			if (xf86getSubToken (&(ptr->va_comment)) != STRING)
-				Error (QUOTE_MSG, "Identifier");
-			ptr->va_identifier = val.str;
-			if (has_ident == TRUE)
-				Error (MULTIPLE_MSG, "Identifier");
-			has_ident = TRUE;
-			break;
-		case VENDOR:
-			if (xf86getSubToken (&(ptr->va_comment)) != STRING)
-				Error (QUOTE_MSG, "Vendor");
-			ptr->va_vendor = val.str;
-			break;
-		case BOARD:
-			if (xf86getSubToken (&(ptr->va_comment)) != STRING)
-				Error (QUOTE_MSG, "Board");
-			ptr->va_board = val.str;
-			break;
-		case BUSID:
-			if (xf86getSubToken (&(ptr->va_comment)) != STRING)
-				Error (QUOTE_MSG, "BusID");
-			ptr->va_busid = val.str;
-			break;
-		case DRIVER:
-			if (xf86getSubToken (&(ptr->va_comment)) != STRING)
-				Error (QUOTE_MSG, "Driver");
-			ptr->va_driver = val.str;
-			break;
-		case OPTION:
-			ptr->va_option_lst = xf86parseOption(ptr->va_option_lst);
-			break;
-		case SUBSECTION:
-			if (xf86getSubToken (&(ptr->va_comment)) != STRING)
-				Error (QUOTE_MSG, "SubSection");
-			{
-				HANDLE_LIST (va_port_lst, xf86parseVideoPortSubSection,
-							 XF86ConfVideoPortPtr);
-			}
-			break;
-
-		case EOF_TOKEN:
-			Error (UNEXPECTED_EOF_MSG, NULL);
-			break;
-		default:
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-			break;
-		}
-	}
-
-	if (!has_ident)
-		Error (NO_IDENT_MSG, NULL);
-
-#ifdef DEBUG
-	printf ("VideoAdaptor section parsed\n");
-#endif
-
-	return ptr;
-}
-
-void
-xf86printVideoAdaptorSection (FILE * cf, XF86ConfVideoAdaptorPtr ptr)
-{
-	XF86ConfVideoPortPtr pptr;
-
-	while (ptr)
-	{
-		fprintf (cf, "Section \"VideoAdaptor\"\n");
-		if (ptr->va_comment)
-			fprintf (cf, "%s", ptr->va_comment);
-		if (ptr->va_identifier)
-			fprintf (cf, "\tIdentifier  \"%s\"\n", ptr->va_identifier);
-		if (ptr->va_vendor)
-			fprintf (cf, "\tVendorName  \"%s\"\n", ptr->va_vendor);
-		if (ptr->va_board)
-			fprintf (cf, "\tBoardName   \"%s\"\n", ptr->va_board);
-		if (ptr->va_busid)
-			fprintf (cf, "\tBusID       \"%s\"\n", ptr->va_busid);
-		if (ptr->va_driver)
-			fprintf (cf, "\tDriver      \"%s\"\n", ptr->va_driver);
-		xf86printOptionList(cf, ptr->va_option_lst, 1);
-		for (pptr = ptr->va_port_lst; pptr; pptr = pptr->list.next)
-		{
-			fprintf (cf, "\tSubSection \"VideoPort\"\n");
-			if (pptr->vp_comment)
-				fprintf (cf, "%s", pptr->vp_comment);
-			if (pptr->vp_identifier)
-				fprintf (cf, "\t\tIdentifier \"%s\"\n", pptr->vp_identifier);
-			xf86printOptionList(cf, pptr->vp_option_lst, 2);
-			fprintf (cf, "\tEndSubSection\n");
-		}
-		fprintf (cf, "EndSection\n\n");
-		ptr = ptr->list.next;
-	}
-
-}
-
-void
-xf86freeVideoAdaptorList (XF86ConfVideoAdaptorPtr ptr)
-{
-	XF86ConfVideoAdaptorPtr prev;
-
-	while (ptr)
-	{
-		TestFree (ptr->va_identifier);
-		TestFree (ptr->va_vendor);
-		TestFree (ptr->va_board);
-		TestFree (ptr->va_busid);
-		TestFree (ptr->va_driver);
-		TestFree (ptr->va_fwdref);
-		TestFree (ptr->va_comment);
-		xf86freeVideoPortList (ptr->va_port_lst);
-		xf86optionListFree (ptr->va_option_lst);
-		prev = ptr;
-		ptr = ptr->list.next;
-		free (prev);
-	}
-}
-
-XF86ConfVideoAdaptorPtr
-xf86findVideoAdaptor (const char *ident, XF86ConfVideoAdaptorPtr p)
-{
-	while (p)
-	{
-		if (xf86nameCompare (ident, p->va_identifier) == 0)
-			return (p);
-
-		p = p->list.next;
-	}
-	return (NULL);
-}
+/* 

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86Parser.h"

+#include "xf86tokens.h"

+#include "Configint.h"

+

+extern LexRec val;

+

+static xf86ConfigSymTabRec VideoPortTab[] =

+{

+	{ENDSUBSECTION, "endsubsection"},

+	{IDENTIFIER, "identifier"},

+	{OPTION, "option"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeVideoPortList

+

+static void

+xf86freeVideoPortList (XF86ConfVideoPortPtr ptr)

+{

+	XF86ConfVideoPortPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->vp_identifier);

+		TestFree (ptr->vp_comment);

+		xf86optionListFree (ptr->vp_option_lst);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+static XF86ConfVideoPortPtr

+xf86parseVideoPortSubSection (void)

+{

+	int has_ident = FALSE;

+	int token;

+	parsePrologue (XF86ConfVideoPortPtr, XF86ConfVideoPortRec)

+

+	while ((token = xf86getToken (VideoPortTab)) != ENDSUBSECTION)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->vp_comment = xf86addComment(ptr->vp_comment, val.str);

+			break;

+		case IDENTIFIER:

+			if (xf86getSubToken (&(ptr->vp_comment)) != STRING)

+				Error (QUOTE_MSG, "Identifier");

+			if (has_ident == TRUE)

+				Error (MULTIPLE_MSG, "Identifier");

+			ptr->vp_identifier = val.str;

+			has_ident = TRUE;

+			break;

+		case OPTION:

+			ptr->vp_option_lst = xf86parseOption(ptr->vp_option_lst);

+			break;

+

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+			break;

+		}

+	}

+

+#ifdef DEBUG

+	printf ("VideoPort subsection parsed\n");

+#endif

+

+	return ptr;

+}

+

+#undef CLEANUP

+

+static xf86ConfigSymTabRec VideoAdaptorTab[] =

+{

+	{ENDSECTION, "endsection"},

+	{IDENTIFIER, "identifier"},

+	{VENDOR, "vendorname"},

+	{BOARD, "boardname"},

+	{BUSID, "busid"},

+	{DRIVER, "driver"},

+	{OPTION, "option"},

+	{SUBSECTION, "subsection"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeVideoAdaptorList

+

+XF86ConfVideoAdaptorPtr

+xf86parseVideoAdaptorSection (void)

+{

+	int has_ident = FALSE;

+	int token;

+

+	parsePrologue (XF86ConfVideoAdaptorPtr, XF86ConfVideoAdaptorRec)

+

+	while ((token = xf86getToken (VideoAdaptorTab)) != ENDSECTION)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->va_comment = xf86addComment(ptr->va_comment, val.str);

+			break;

+		case IDENTIFIER:

+			if (xf86getSubToken (&(ptr->va_comment)) != STRING)

+				Error (QUOTE_MSG, "Identifier");

+			ptr->va_identifier = val.str;

+			if (has_ident == TRUE)

+				Error (MULTIPLE_MSG, "Identifier");

+			has_ident = TRUE;

+			break;

+		case VENDOR:

+			if (xf86getSubToken (&(ptr->va_comment)) != STRING)

+				Error (QUOTE_MSG, "Vendor");

+			ptr->va_vendor = val.str;

+			break;

+		case BOARD:

+			if (xf86getSubToken (&(ptr->va_comment)) != STRING)

+				Error (QUOTE_MSG, "Board");

+			ptr->va_board = val.str;

+			break;

+		case BUSID:

+			if (xf86getSubToken (&(ptr->va_comment)) != STRING)

+				Error (QUOTE_MSG, "BusID");

+			ptr->va_busid = val.str;

+			break;

+		case DRIVER:

+			if (xf86getSubToken (&(ptr->va_comment)) != STRING)

+				Error (QUOTE_MSG, "Driver");

+			ptr->va_driver = val.str;

+			break;

+		case OPTION:

+			ptr->va_option_lst = xf86parseOption(ptr->va_option_lst);

+			break;

+		case SUBSECTION:

+			if (xf86getSubToken (&(ptr->va_comment)) != STRING)

+				Error (QUOTE_MSG, "SubSection");

+			{

+				HANDLE_LIST (va_port_lst, xf86parseVideoPortSubSection,

+							 XF86ConfVideoPortPtr);

+			}

+			break;

+

+		case EOF_TOKEN:

+			Error (UNEXPECTED_EOF_MSG, NULL);

+			break;

+		default:

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+			break;

+		}

+	}

+

+	if (!has_ident)

+		Error (NO_IDENT_MSG, NULL);

+

+#ifdef DEBUG

+	printf ("VideoAdaptor section parsed\n");

+#endif

+

+	return ptr;

+}

+

+void

+xf86printVideoAdaptorSection (FILE * cf, XF86ConfVideoAdaptorPtr ptr)

+{

+	XF86ConfVideoPortPtr pptr;

+

+	while (ptr)

+	{

+		fprintf (cf, "Section \"VideoAdaptor\"\n");

+		if (ptr->va_comment)

+			fprintf (cf, "%s", ptr->va_comment);

+		if (ptr->va_identifier)

+			fprintf (cf, "\tIdentifier  \"%s\"\n", ptr->va_identifier);

+		if (ptr->va_vendor)

+			fprintf (cf, "\tVendorName  \"%s\"\n", ptr->va_vendor);

+		if (ptr->va_board)

+			fprintf (cf, "\tBoardName   \"%s\"\n", ptr->va_board);

+		if (ptr->va_busid)

+			fprintf (cf, "\tBusID       \"%s\"\n", ptr->va_busid);

+		if (ptr->va_driver)

+			fprintf (cf, "\tDriver      \"%s\"\n", ptr->va_driver);

+		xf86printOptionList(cf, ptr->va_option_lst, 1);

+		for (pptr = ptr->va_port_lst; pptr; pptr = pptr->list.next)

+		{

+			fprintf (cf, "\tSubSection \"VideoPort\"\n");

+			if (pptr->vp_comment)

+				fprintf (cf, "%s", pptr->vp_comment);

+			if (pptr->vp_identifier)

+				fprintf (cf, "\t\tIdentifier \"%s\"\n", pptr->vp_identifier);

+			xf86printOptionList(cf, pptr->vp_option_lst, 2);

+			fprintf (cf, "\tEndSubSection\n");

+		}

+		fprintf (cf, "EndSection\n\n");

+		ptr = ptr->list.next;

+	}

+

+}

+

+void

+xf86freeVideoAdaptorList (XF86ConfVideoAdaptorPtr ptr)

+{

+	XF86ConfVideoAdaptorPtr prev;

+

+	while (ptr)

+	{

+		TestFree (ptr->va_identifier);

+		TestFree (ptr->va_vendor);

+		TestFree (ptr->va_board);

+		TestFree (ptr->va_busid);

+		TestFree (ptr->va_driver);

+		TestFree (ptr->va_fwdref);

+		TestFree (ptr->va_comment);

+		xf86freeVideoPortList (ptr->va_port_lst);

+		xf86optionListFree (ptr->va_option_lst);

+		prev = ptr;

+		ptr = ptr->list.next;

+		free (prev);

+	}

+}

+

+XF86ConfVideoAdaptorPtr

+xf86findVideoAdaptor (const char *ident, XF86ConfVideoAdaptorPtr p)

+{

+	while (p)

+	{

+		if (xf86nameCompare (ident, p->va_identifier) == 0)

+			return p;

+

+		p = p->list.next;

+	}

+	return NULL;

+}

diff --git a/xorg-server/hw/xfree86/parser/read.c b/xorg-server/hw/xfree86/parser/read.c
index 4e42b24f0..715626c53 100644
--- a/xorg-server/hw/xfree86/parser/read.c
+++ b/xorg-server/hw/xfree86/parser/read.c
@@ -1,318 +1,318 @@
-/* 
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Parser.h"
-#include "xf86tokens.h"
-#include "Configint.h"
-
-extern LexRec val;
-
-static xf86ConfigSymTabRec TopLevelTab[] =
-{
-	{SECTION, "section"},
-	{-1, ""},
-};
-
-#define CLEANUP xf86freeConfig
-
-/* 
- * This function resolves name references and reports errors if the named
- * objects cannot be found.
- */
-static int
-xf86validateConfig (XF86ConfigPtr p)
-{
-	if (!xf86validateScreen (p))
-		return FALSE;
-	if (!xf86validateInput (p))
-		return FALSE;
-	if (!xf86validateLayout (p))
-		return FALSE;
-
-	return (TRUE);
-}
-
-XF86ConfigPtr
-xf86readConfigFile (void)
-{
-	int token;
-	XF86ConfigPtr ptr = NULL;
-
-	if ((ptr = calloc (1, sizeof (XF86ConfigRec))) == NULL)
-	{
-		return NULL;
-	}
-
-	while ((token = xf86getToken (TopLevelTab)) != EOF_TOKEN)
-	{
-		switch (token)
-		{
-		case COMMENT:
-			ptr->conf_comment = xf86addComment(ptr->conf_comment, val.str);
-			break;
-		case SECTION:
-			if (xf86getSubToken (&(ptr->conf_comment)) != STRING)
-			{
-				xf86parseError (QUOTE_MSG, "Section");
-				CLEANUP (ptr);
-				return (NULL);
-			}
-			xf86setSection (val.str);
-			if (xf86nameCompare (val.str, "files") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_RETURN (conf_files, xf86parseFilesSection ());
-			}
-			else if (xf86nameCompare (val.str, "serverflags") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_RETURN (conf_flags, xf86parseFlagsSection ());
-			}
-			else if (xf86nameCompare (val.str, "pointer") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_input_lst, xf86parsePointerSection,
-							 XF86ConfInputPtr);
-			}
-			else if (xf86nameCompare (val.str, "videoadaptor") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_videoadaptor_lst, xf86parseVideoAdaptorSection,
-							 XF86ConfVideoAdaptorPtr);
-			}
-			else if (xf86nameCompare (val.str, "device") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_device_lst, xf86parseDeviceSection,
-							 XF86ConfDevicePtr);
-			}
-			else if (xf86nameCompare (val.str, "monitor") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_monitor_lst, xf86parseMonitorSection,
-							 XF86ConfMonitorPtr);
-			}
-			else if (xf86nameCompare (val.str, "modes") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_modes_lst, xf86parseModesSection,
-							 XF86ConfModesPtr);
-			}
-			else if (xf86nameCompare (val.str, "screen") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_screen_lst, xf86parseScreenSection,
-							 XF86ConfScreenPtr);
-			}
-			else if (xf86nameCompare(val.str, "inputdevice") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_input_lst, xf86parseInputSection,
-							 XF86ConfInputPtr);
-			}
-			else if (xf86nameCompare(val.str, "inputclass") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_inputclass_lst,
-						xf86parseInputClassSection,
-						XF86ConfInputClassPtr);
-			}
-			else if (xf86nameCompare (val.str, "module") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_RETURN (conf_modules, xf86parseModuleSection ());
-			}
-			else if (xf86nameCompare (val.str, "serverlayout") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_layout_lst, xf86parseLayoutSection,
-							 XF86ConfLayoutPtr);
-			}
-			else if (xf86nameCompare (val.str, "vendor") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_LIST (conf_vendor_lst, xf86parseVendorSection,
-							 XF86ConfVendorPtr);
-			}
-			else if (xf86nameCompare (val.str, "dri") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_RETURN (conf_dri, xf86parseDRISection ());
-			}
-			else if (xf86nameCompare (val.str, "extensions") == 0)
-			{
-				free(val.str);
-				val.str = NULL;
-				HANDLE_RETURN (conf_extensions, xf86parseExtensionsSection ());
-			}
-			else
-			{
-				free(val.str);
-				val.str = NULL;
-				Error (INVALID_SECTION_MSG, xf86tokenString ());
-			}
-			break;
-		default:
-			free(val.str);
-			val.str = NULL;
-			Error (INVALID_KEYWORD_MSG, xf86tokenString ());
-		}
-	}
-
-	if (xf86validateConfig (ptr))
-		return (ptr);
-	else
-	{
-		CLEANUP (ptr);
-		return (NULL);
-	}
-}
-
-#undef CLEANUP
-
-/* 
- * adds an item to the end of the linked list. Any record whose first field
- * is a GenericListRec can be cast to this type and used with this function.
- * A pointer to the head of the list is returned to handle the addition of
- * the first item.
- */
-GenericListPtr
-xf86addListItem (GenericListPtr head, GenericListPtr new)
-{
-	GenericListPtr p = head;
-	GenericListPtr last = NULL;
-
-	while (p)
-	{
-		last = p;
-		p = p->next;
-	}
-
-	if (last)
-	{
-		last->next = new;
-		return (head);
-	}
-	else
-		return (new);
-}
-
-/* 
- * Test if one chained list contains the other.
- * In this case both list have the same endpoint (provided they don't loop)
- */
-int
-xf86itemNotSublist(GenericListPtr list_1, GenericListPtr list_2)
-{
-	GenericListPtr p = list_1;
-	GenericListPtr last_1 = NULL, last_2 = NULL;
-
-	while (p) {
-		last_1 = p;
-		p = p->next;
-	}
-
-	p = list_2;
-	while (p) {
-		last_2 = p;
-		p = p->next;
-	}
-
-	return (!(last_1 == last_2));
-}
-
-void
-xf86freeConfig (XF86ConfigPtr p)
-{
-	if (p == NULL)
-		return;
-
-	xf86freeFiles (p->conf_files);
-	xf86freeModules (p->conf_modules);
-	xf86freeFlags (p->conf_flags);
-	xf86freeMonitorList (p->conf_monitor_lst);
-	xf86freeModesList (p->conf_modes_lst);
-	xf86freeVideoAdaptorList (p->conf_videoadaptor_lst);
-	xf86freeDeviceList (p->conf_device_lst);
-	xf86freeScreenList (p->conf_screen_lst);
-	xf86freeLayoutList (p->conf_layout_lst);
-	xf86freeInputList (p->conf_input_lst);
-	xf86freeVendorList (p->conf_vendor_lst);
-	xf86freeDRI (p->conf_dri);
-	xf86freeExtensions (p->conf_extensions);
-	TestFree(p->conf_comment);
-
-	free (p);
-}
+/* 

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86Parser.h"

+#include "xf86tokens.h"

+#include "Configint.h"

+

+extern LexRec val;

+

+static xf86ConfigSymTabRec TopLevelTab[] =

+{

+	{SECTION, "section"},

+	{-1, ""},

+};

+

+#define CLEANUP xf86freeConfig

+

+/* 

+ * This function resolves name references and reports errors if the named

+ * objects cannot be found.

+ */

+static int

+xf86validateConfig (XF86ConfigPtr p)

+{

+	if (!xf86validateScreen (p))

+		return FALSE;

+	if (!xf86validateInput (p))

+		return FALSE;

+	if (!xf86validateLayout (p))

+		return FALSE;

+

+	return TRUE;

+}

+

+XF86ConfigPtr

+xf86readConfigFile (void)

+{

+	int token;

+	XF86ConfigPtr ptr = NULL;

+

+	if ((ptr = calloc (1, sizeof (XF86ConfigRec))) == NULL)

+	{

+		return NULL;

+	}

+

+	while ((token = xf86getToken (TopLevelTab)) != EOF_TOKEN)

+	{

+		switch (token)

+		{

+		case COMMENT:

+			ptr->conf_comment = xf86addComment(ptr->conf_comment, val.str);

+			break;

+		case SECTION:

+			if (xf86getSubToken (&(ptr->conf_comment)) != STRING)

+			{

+				xf86parseError (QUOTE_MSG, "Section");

+				CLEANUP (ptr);

+				return NULL;

+			}

+			xf86setSection (val.str);

+			if (xf86nameCompare (val.str, "files") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_RETURN (conf_files, xf86parseFilesSection ());

+			}

+			else if (xf86nameCompare (val.str, "serverflags") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_RETURN (conf_flags, xf86parseFlagsSection ());

+			}

+			else if (xf86nameCompare (val.str, "pointer") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_input_lst, xf86parsePointerSection,

+							 XF86ConfInputPtr);

+			}

+			else if (xf86nameCompare (val.str, "videoadaptor") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_videoadaptor_lst, xf86parseVideoAdaptorSection,

+							 XF86ConfVideoAdaptorPtr);

+			}

+			else if (xf86nameCompare (val.str, "device") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_device_lst, xf86parseDeviceSection,

+							 XF86ConfDevicePtr);

+			}

+			else if (xf86nameCompare (val.str, "monitor") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_monitor_lst, xf86parseMonitorSection,

+							 XF86ConfMonitorPtr);

+			}

+			else if (xf86nameCompare (val.str, "modes") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_modes_lst, xf86parseModesSection,

+							 XF86ConfModesPtr);

+			}

+			else if (xf86nameCompare (val.str, "screen") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_screen_lst, xf86parseScreenSection,

+							 XF86ConfScreenPtr);

+			}

+			else if (xf86nameCompare(val.str, "inputdevice") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_input_lst, xf86parseInputSection,

+							 XF86ConfInputPtr);

+			}

+			else if (xf86nameCompare(val.str, "inputclass") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_inputclass_lst,

+						xf86parseInputClassSection,

+						XF86ConfInputClassPtr);

+			}

+			else if (xf86nameCompare (val.str, "module") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_RETURN (conf_modules, xf86parseModuleSection ());

+			}

+			else if (xf86nameCompare (val.str, "serverlayout") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_layout_lst, xf86parseLayoutSection,

+							 XF86ConfLayoutPtr);

+			}

+			else if (xf86nameCompare (val.str, "vendor") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_LIST (conf_vendor_lst, xf86parseVendorSection,

+							 XF86ConfVendorPtr);

+			}

+			else if (xf86nameCompare (val.str, "dri") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_RETURN (conf_dri, xf86parseDRISection ());

+			}

+			else if (xf86nameCompare (val.str, "extensions") == 0)

+			{

+				free(val.str);

+				val.str = NULL;

+				HANDLE_RETURN (conf_extensions, xf86parseExtensionsSection ());

+			}

+			else

+			{

+				free(val.str);

+				val.str = NULL;

+				Error (INVALID_SECTION_MSG, xf86tokenString ());

+			}

+			break;

+		default:

+			free(val.str);

+			val.str = NULL;

+			Error (INVALID_KEYWORD_MSG, xf86tokenString ());

+		}

+	}

+

+	if (xf86validateConfig (ptr))

+		return ptr;

+	else

+	{

+		CLEANUP (ptr);

+		return NULL;

+	}

+}

+

+#undef CLEANUP

+

+/* 

+ * adds an item to the end of the linked list. Any record whose first field

+ * is a GenericListRec can be cast to this type and used with this function.

+ * A pointer to the head of the list is returned to handle the addition of

+ * the first item.

+ */

+GenericListPtr

+xf86addListItem (GenericListPtr head, GenericListPtr new)

+{

+	GenericListPtr p = head;

+	GenericListPtr last = NULL;

+

+	while (p)

+	{

+		last = p;

+		p = p->next;

+	}

+

+	if (last)

+	{

+		last->next = new;

+		return head;

+	}

+	else

+		return new;

+}

+

+/* 

+ * Test if one chained list contains the other.

+ * In this case both list have the same endpoint (provided they don't loop)

+ */

+int

+xf86itemNotSublist(GenericListPtr list_1, GenericListPtr list_2)

+{

+	GenericListPtr p = list_1;

+	GenericListPtr last_1 = NULL, last_2 = NULL;

+

+	while (p) {

+		last_1 = p;

+		p = p->next;

+	}

+

+	p = list_2;

+	while (p) {

+		last_2 = p;

+		p = p->next;

+	}

+

+	return (!(last_1 == last_2));

+}

+

+void

+xf86freeConfig (XF86ConfigPtr p)

+{

+	if (p == NULL)

+		return;

+

+	xf86freeFiles (p->conf_files);

+	xf86freeModules (p->conf_modules);

+	xf86freeFlags (p->conf_flags);

+	xf86freeMonitorList (p->conf_monitor_lst);

+	xf86freeModesList (p->conf_modes_lst);

+	xf86freeVideoAdaptorList (p->conf_videoadaptor_lst);

+	xf86freeDeviceList (p->conf_device_lst);

+	xf86freeScreenList (p->conf_screen_lst);

+	xf86freeLayoutList (p->conf_layout_lst);

+	xf86freeInputList (p->conf_input_lst);

+	xf86freeVendorList (p->conf_vendor_lst);

+	xf86freeDRI (p->conf_dri);

+	xf86freeExtensions (p->conf_extensions);

+	TestFree(p->conf_comment);

+

+	free (p);

+}

diff --git a/xorg-server/hw/xfree86/parser/scan.c b/xorg-server/hw/xfree86/parser/scan.c
index 06710d55a..99e1288a5 100644
--- a/xorg-server/hw/xfree86/parser/scan.c
+++ b/xorg-server/hw/xfree86/parser/scan.c
@@ -1,1247 +1,1232 @@
-/* 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* View/edit this file with tab stops set to 4 */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <unistd.h>
-#include <stdarg.h>
-#include <X11/Xdefs.h>
-#include <X11/Xfuncproto.h>
-
-#if defined(_POSIX_SOURCE)
-#include <limits.h>
-#else
-#define _POSIX_SOURCE
-#include <limits.h>
-#undef _POSIX_SOURCE
-#endif /* _POSIX_SOURCE */
-
-#if !defined(PATH_MAX)
-#if defined(MAXPATHLEN)
-#define PATH_MAX MAXPATHLEN
-#else
-#define PATH_MAX 1024
-#endif /* MAXPATHLEN */
-#endif /* !PATH_MAX */
-
-#if !defined(MAXHOSTNAMELEN)
-#define MAXHOSTNAMELEN 32
-#endif /* !MAXHOSTNAMELEN */
-
-#include "Configint.h"
-#include "xf86tokens.h"
-
-#define CONFIG_BUF_LEN     1024
-#define CONFIG_MAX_FILES   64
-
-static int StringToToken (char *, xf86ConfigSymTabRec *);
-
-static struct {
-	FILE *file;
-	char *path;
-} configFiles[CONFIG_MAX_FILES];
-static const char **builtinConfig = NULL;
-static int builtinIndex = 0;
-static int configPos = 0;		/* current readers position */
-static int configLineNo = 0;	/* linenumber */
-static char *configBuf, *configRBuf;	/* buffer for lines */
-static char *configPath;		/* path to config file */
-static char *configDirPath;		/* path to config dir */
-static char *configSection = NULL;	/* name of current section being parsed */
-static int numFiles = 0;		/* number of config files */
-static int curFileIndex = 0;		/* index of current config file */
-static int pushToken = LOCK_TOKEN;
-static int eol_seen = 0;		/* private state to handle comments */
-LexRec val;
-
-/* 
- * xf86strToUL --
- *
- *  A portable, but restricted, version of strtoul().  It only understands
- *  hex, octal, and decimal.  But it's good enough for our needs.
- */
-static unsigned int
-xf86strToUL (char *str)
-{
-	int base = 10;
-	char *p = str;
-	unsigned int tot = 0;
-
-	if (*p == '0')
-	{
-		p++;
-		if ((*p == 'x') || (*p == 'X'))
-		{
-			p++;
-			base = 16;
-		}
-		else
-			base = 8;
-	}
-	while (*p)
-	{
-		if ((*p >= '0') && (*p <= ((base == 8) ? '7' : '9')))
-		{
-			tot = tot * base + (*p - '0');
-		}
-		else if ((base == 16) && (*p >= 'a') && (*p <= 'f'))
-		{
-			tot = tot * base + 10 + (*p - 'a');
-		}
-		else if ((base == 16) && (*p >= 'A') && (*p <= 'F'))
-		{
-			tot = tot * base + 10 + (*p - 'A');
-		}
-		else
-		{
-			return (tot);
-		}
-		p++;
-	}
-	return (tot);
-}
-
-/*
- * xf86getNextLine --
- *
- *  read from the configFiles FILE stream until we encounter a new
- *  line; this is effectively just a big wrapper for fgets(3).
- *
- *  xf86getToken() assumes that we will read up to the next
- *  newline; we need to grow configBuf and configRBuf as needed to
- *  support that.
- */
-
-static char*
-xf86getNextLine(void)
-{
-	static int configBufLen = CONFIG_BUF_LEN;
-	char *tmpConfigBuf, *tmpConfigRBuf;
-	int c, i, pos = 0, eolFound = 0;
-	char *ret = NULL;
-
-	/*
-	 * reallocate the string if it was grown last time (i.e., is no
-	 * longer CONFIG_BUF_LEN); we malloc the new strings first, so
-	 * that if either of the mallocs fail, we can fall back on the
-	 * existing buffer allocations
-	 */
-
-	if (configBufLen != CONFIG_BUF_LEN) {
-
-		tmpConfigBuf = malloc(CONFIG_BUF_LEN);
-		tmpConfigRBuf = malloc(CONFIG_BUF_LEN);
-
-		if (!tmpConfigBuf || !tmpConfigRBuf) {
-
-			/*
-			 * at least one of the mallocs failed; keep the old buffers
-			 * and free any partial allocations
-			 */
-
-			free(tmpConfigBuf);
-			free(tmpConfigRBuf);
-
-		} else {
-
-			/*
-			 * malloc succeeded; free the old buffers and use the new
-			 * buffers
-			 */
-
-			configBufLen = CONFIG_BUF_LEN;
-
-			free(configBuf);
-			free(configRBuf);
-
-			configBuf = tmpConfigBuf;
-			configRBuf = tmpConfigRBuf;
-		}
-	}
-
-	/* read in another block of chars */
-
-	do {
-		ret = fgets(configBuf + pos, configBufLen - pos - 1,
-			    configFiles[curFileIndex].file);
-
-		if (!ret) {
-			/*
-			 * if the file doesn't end in a newline, add one
-			 * and trigger another read
-			 */
-			if (pos != 0) {
-				strcpy(&configBuf[pos], "\n");
-				ret = configBuf;
-			} else
-				break;
-		}
-
-		/* search for EOL in the new block of chars */
-
-		for (i = pos; i < (configBufLen - 1); i++) {
-			c = configBuf[i];
-
-			if (c == '\0') break;
-
-			if ((c == '\n') || (c == '\r')) {
-				eolFound = 1;
-				break;
-			}
-		}
-
-		/*
-		 * if we didn't find EOL, then grow the string and
-		 * read in more
-		 */
-
-		if (!eolFound) {
-
-			tmpConfigBuf = realloc(configBuf, configBufLen + CONFIG_BUF_LEN);
-			tmpConfigRBuf = realloc(configRBuf, configBufLen + CONFIG_BUF_LEN);
-
-			if (!tmpConfigBuf || !tmpConfigRBuf) {
-
-				/*
-				 * at least one of the reallocations failed; use the
-				 * new allocation that succeeded, but we have to
-				 * fallback to the previous configBufLen size and use
-				 * the string we have, even though we don't have an
-				 * EOL
-				 */
-
-				if (tmpConfigBuf) configBuf = tmpConfigBuf;
-				if (tmpConfigRBuf) configRBuf = tmpConfigRBuf;
-
-				break;
-
-			} else {
-
-				/* reallocation succeeded */
-
-				configBuf = tmpConfigBuf;
-				configRBuf = tmpConfigRBuf;
-				pos = i;
-				configBufLen += CONFIG_BUF_LEN;
-			}
-		}
-
-	} while (!eolFound);
-
-	return (ret);
-}
-
-/* 
- * xf86getToken --
- *      Read next Token from the config file. Handle the global variable
- *      pushToken.
- */
-int
-xf86getToken (xf86ConfigSymTabRec * tab)
-{
-	int c, i;
-
-	/* 
-	 * First check whether pushToken has a different value than LOCK_TOKEN.
-	 * In this case rBuf[] contains a valid STRING/TOKEN/NUMBER. But in the
-	 * oth * case the next token must be read from the input.
-	 */
-	if (pushToken == EOF_TOKEN)
-		return (EOF_TOKEN);
-	else if (pushToken == LOCK_TOKEN)
-	{
-		/*
-		 * eol_seen is only set for the first token after a newline.
-		 */
-		eol_seen = 0;
-
-		c = configBuf[configPos];
-
-		/* 
-		 * Get start of next Token. EOF is handled,
-		 * whitespaces are skipped. 
-		 */
-
-again:
-		if (!c)
-		{
-			char *ret;
-			if (numFiles > 0)
-				ret = xf86getNextLine();
-			else {
-				if (builtinConfig[builtinIndex] == NULL)
-					ret = NULL;
-				else {
-					ret = strncpy(configBuf, builtinConfig[builtinIndex],
-							CONFIG_BUF_LEN);
-					builtinIndex++;
-				}
-			}
-			if (ret == NULL)
-			{
-				/*
-				 * if necessary, move to the next file and
-				 * read the first line
-				 */
-				if (curFileIndex + 1 < numFiles) {
-					curFileIndex++;
-					configLineNo = 0;
-					goto again;
-				}
-				else
-					return (pushToken = EOF_TOKEN);
-			}
-			configLineNo++;
-			configPos = 0;
-			eol_seen = 1;
-		}
-
-		i = 0;
-		for (;;) {
-			c = configBuf[configPos++];
-			configRBuf[i++] = c;
-			switch (c) {
-				case ' ':
-				case '\t':
-				case '\r':
-					continue;
-				case '\n':
-					i = 0;
-					continue;
-			}
-			break;
-		}
-		if (c == '\0')
-			goto again;
-
-		if (c == '#')
-		{
-			do
-			{
-				configRBuf[i++] = (c = configBuf[configPos++]);
-			}
-			while ((c != '\n') && (c != '\r') && (c != '\0'));
-			configRBuf[i] = '\0';
-			/* XXX no private copy.
-			 * Use xf86addComment when setting a comment.
-			 */
-			val.str = configRBuf;
-			return (COMMENT);
-		}
-
-		/* GJA -- handle '-' and ','  * Be careful: "-hsync" is a keyword. */
-		else if ((c == ',') && !isalpha (configBuf[configPos]))
-		{
-			return COMMA;
-		}
-		else if ((c == '-') && !isalpha (configBuf[configPos]))
-		{
-			return DASH;
-		}
-
-		/* 
-		 * Numbers are returned immediately ...
-		 */
-		if (isdigit (c))
-		{
-			int base;
-
-			if (c == '0')
-				if ((configBuf[configPos] == 'x') ||
-					(configBuf[configPos] == 'X'))
-                                {
-					base = 16;
-                                        val.numType = PARSE_HEX;
-                                }
-				else
-                                {
-					base = 8;
-                                        val.numType = PARSE_OCTAL;
-                                }
-			else
-                        {
-				base = 10;
-                                val.numType = PARSE_DECIMAL;
-                        }
-
-			configRBuf[0] = c;
-			i = 1;
-			while (isdigit (c = configBuf[configPos++]) ||
-				   (c == '.') || (c == 'x') || (c == 'X') ||
-				   ((base == 16) && (((c >= 'a') && (c <= 'f')) ||
-									 ((c >= 'A') && (c <= 'F')))))
-				configRBuf[i++] = c;
-			configPos--;		/* GJA -- one too far */
-			configRBuf[i] = '\0';
-			val.num = xf86strToUL (configRBuf);
-			val.realnum = atof (configRBuf);
-			return (NUMBER);
-		}
-
-		/* 
-		 * All Strings START with a \" ...
-		 */
-		else if (c == '\"')
-		{
-			i = -1;
-			do
-			{
-				configRBuf[++i] = (c = configBuf[configPos++]);
-			}
-			while ((c != '\"') && (c != '\n') && (c != '\r') && (c != '\0'));
-			configRBuf[i] = '\0';
-			val.str = malloc (strlen (configRBuf) + 1);
-			strcpy (val.str, configRBuf);	/* private copy ! */
-			return (STRING);
-		}
-
-		/* 
-		 * ... and now we MUST have a valid token.  The search is
-		 * handled later along with the pushed tokens.
-		 */
-		else
-		{
-			configRBuf[0] = c;
-			i = 0;
-			do
-			{
-				configRBuf[++i] = (c = configBuf[configPos++]);
-			}
-			while ((c != ' ') && (c != '\t') && (c != '\n') && (c != '\r') && (c != '\0') && (c != '#'));
-			--configPos;
-			configRBuf[i] = '\0';
-			i = 0;
-		}
-
-	}
-	else
-	{
-
-		/* 
-		 * Here we deal with pushed tokens. Reinitialize pushToken again. If
-		 * the pushed token was NUMBER || STRING return them again ...
-		 */
-		int temp = pushToken;
-		pushToken = LOCK_TOKEN;
-
-		if (temp == COMMA || temp == DASH)
-			return (temp);
-		if (temp == NUMBER || temp == STRING)
-			return (temp);
-	}
-
-	/* 
-	 * Joop, at last we have to lookup the token ...
-	 */
-	if (tab)
-	{
-		i = 0;
-		while (tab[i].token != -1)
-			if (xf86nameCompare (configRBuf, tab[i].name) == 0)
-				return (tab[i].token);
-			else
-				i++;
-	}
-
-	return (ERROR_TOKEN);		/* Error catcher */
-}
-
-int
-xf86getSubToken (char **comment)
-{
-	int token;
-
-	for (;;) {
-		token = xf86getToken(NULL);
-		if (token == COMMENT) {
-			if (comment)
-				*comment = xf86addComment(*comment, val.str);
-		}
-		else
-			return (token);
-	}
-	/*NOTREACHED*/
-}
-
-int
-xf86getSubTokenWithTab (char **comment, xf86ConfigSymTabRec *tab)
-{
-	int token;
-
-	for (;;) {
-		token = xf86getToken(tab);
-		if (token == COMMENT) {
-			if (comment)
-				*comment = xf86addComment(*comment, val.str);
-		}
-		else
-			return (token);
-	}
-	/*NOTREACHED*/
-}
-
-void
-xf86unGetToken (int token)
-{
-	pushToken = token;
-}
-
-char *
-xf86tokenString (void)
-{
-	return configRBuf;
-}
-
-int
-xf86pathIsAbsolute(const char *path)
-{
-	if (path && path[0] == '/')
-		return 1;
-	return 0;
-}
-
-/* A path is "safe" if it is relative and if it contains no ".." elements. */
-int
-xf86pathIsSafe(const char *path)
-{
-	if (xf86pathIsAbsolute(path))
-		return 0;
-
-	/* Compare with ".." */
-	if (!strcmp(path, ".."))
-		return 0;
-
-	/* Look for leading "../" */
-	if (!strncmp(path, "../", 3))
-		return 0;
-
-	/* Look for trailing "/.." */
-	if ((strlen(path) > 3) && !strcmp(path + strlen(path) - 3, "/.."))
-		return 0;
-
-	/* Look for "/../" */
-	if (strstr(path, "/../"))
-		return 0;
-
-	return 1;
-}
-
-/*
- * This function substitutes the following escape sequences:
- *
- *    %A    cmdline argument as an absolute path (must be absolute to match)
- *    %R    cmdline argument as a relative path
- *    %S    cmdline argument as a "safe" path (relative, and no ".." elements)
- *    %X    default config file name ("xorg.conf")
- *    %H    hostname
- *    %E    config file environment ($XORGCONFIG) as an absolute path
- *    %F    config file environment ($XORGCONFIG) as a relative path
- *    %G    config file environment ($XORGCONFIG) as a safe path
- *    %P    projroot
- *    %C    sysconfdir
- *    %D    datadir
- *    %M    major version number
- *    %%    %
- */
-
-#ifndef XCONFIGFILE
-#define XCONFIGFILE	"xorg.conf"
-#endif
-#ifndef XCONFIGDIR
-#define XCONFIGDIR	"xorg.conf.d"
-#endif
-#ifndef XCONFIGSUFFIX
-#define XCONFIGSUFFIX	".conf"
-#endif
-#ifndef PROJECTROOT
-#define PROJECTROOT	"/usr/X11R6"
-#endif
-#ifndef SYSCONFDIR
-#define SYSCONFDIR	PROJECTROOT "/etc"
-#endif
-#ifndef DATADIR
-#define DATADIR		PROJECTROOT "/share"
-#endif
-#ifndef XCONFENV
-#define XCONFENV	"XORGCONFIG"
-#endif
-#define XFREE86CFGFILE "XF86Config"
-#ifndef XF86_VERSION_MAJOR
-#ifdef XVERSION
-#if XVERSION > 40000000
-#define XF86_VERSION_MAJOR	(XVERSION / 10000000)
-#else
-#define XF86_VERSION_MAJOR	(XVERSION / 1000)
-#endif
-#else
-#define XF86_VERSION_MAJOR	4
-#endif
-#endif
-
-#define BAIL_OUT		do {									\
-							free(result);				\
-							return NULL;						\
-						} while (0)
-
-#define CHECK_LENGTH	do {									\
-							if (l > PATH_MAX) {					\
-								BAIL_OUT;						\
-							}									\
-						} while (0)
-
-#define APPEND_STR(s)	do {									\
-							if (strlen(s) + l > PATH_MAX) {		\
-								BAIL_OUT;						\
-							} else {							\
-								strcpy(result + l, s);			\
-								l += strlen(s);					\
-							}									\
-						} while (0)
-
-static char *
-DoSubstitution(const char *template, const char *cmdline, const char *projroot,
-				int *cmdlineUsed, int *envUsed,
-				const char *XConfigFile)
-{
-	char *result;
-	int i, l;
-	static const char *env = NULL;
-	static char *hostname = NULL;
-	static char majorvers[3] = "";
-
-	if (!template)
-		return NULL;
-
-	if (cmdlineUsed)
-		*cmdlineUsed = 0;
-	if (envUsed)
-		*envUsed = 0;
-
-	result = malloc(PATH_MAX + 1);
-	l = 0;
-	for (i = 0; template[i]; i++) {
-		if (template[i] != '%') {
-			result[l++] = template[i];
-			CHECK_LENGTH;
-		} else {
-			switch (template[++i]) {
-			case 'A':
-				if (cmdline && xf86pathIsAbsolute(cmdline)) {
-					APPEND_STR(cmdline);
-					if (cmdlineUsed)
-						*cmdlineUsed = 1;
-				} else
-					BAIL_OUT;
-				break;
-			case 'R':
-				if (cmdline && !xf86pathIsAbsolute(cmdline)) {
-					APPEND_STR(cmdline);
-					if (cmdlineUsed)
-						*cmdlineUsed = 1;
-				} else 
-					BAIL_OUT;
-				break;
-			case 'S':
-				if (cmdline && xf86pathIsSafe(cmdline)) {
-					APPEND_STR(cmdline);
-					if (cmdlineUsed)
-						*cmdlineUsed = 1;
-				} else 
-					BAIL_OUT;
-				break;
-			case 'X':
-				APPEND_STR(XConfigFile);
-				break;
-			case 'H':
-				if (!hostname) {
-					if ((hostname = malloc(MAXHOSTNAMELEN + 1))) {
-						if (gethostname(hostname, MAXHOSTNAMELEN) == 0) {
-							hostname[MAXHOSTNAMELEN] = '\0';
-						} else {
-							free(hostname);
-							hostname = NULL;
-						}
-					}
-				}
-				if (hostname)
-					APPEND_STR(hostname);
-				break;
-			case 'E':
-				if (!env)
-					env = getenv(XCONFENV);
-				if (env && xf86pathIsAbsolute(env)) {
-					APPEND_STR(env);
-					if (envUsed)
-						*envUsed = 1;
-				} else
-					BAIL_OUT;
-				break;
-			case 'F':
-				if (!env)
-					env = getenv(XCONFENV);
-				if (env && !xf86pathIsAbsolute(env)) {
-					APPEND_STR(env);
-					if (envUsed)
-						*envUsed = 1;
-				} else
-					BAIL_OUT;
-				break;
-			case 'G':
-				if (!env)
-					env = getenv(XCONFENV);
-				if (env && xf86pathIsSafe(env)) {
-					APPEND_STR(env);
-					if (envUsed)
-						*envUsed = 1;
-				} else
-					BAIL_OUT;
-				break;
-			case 'P':
-				if (projroot && xf86pathIsAbsolute(projroot))
-					APPEND_STR(projroot);
-				else
-					BAIL_OUT;
-				break;
-			case 'C':
-				APPEND_STR(SYSCONFDIR);
-				break;
-			case 'D':
-				APPEND_STR(DATADIR);
-				break;
-			case 'M':
-				if (!majorvers[0]) {
-					if (XF86_VERSION_MAJOR < 0 || XF86_VERSION_MAJOR > 99) {
-						fprintf(stderr, "XF86_VERSION_MAJOR is out of range\n");
-						BAIL_OUT;
-					} else
-						sprintf(majorvers, "%d", XF86_VERSION_MAJOR);
-				}
-				APPEND_STR(majorvers);
-				break;
-			case '%':
-				result[l++] = '%';
-				CHECK_LENGTH;
-				break;
-			default:
-				fprintf(stderr, "invalid escape %%%c found in path template\n",
-						template[i]);
-				BAIL_OUT;
-				break;
-			}
-		}
-	}
-#ifdef DEBUG
-	fprintf(stderr, "Converted `%s' to `%s'\n", template, result);
-#endif
-	return result;
-}
-
-/*
- * Given some searching parameters, locate and open the xorg config file.
- */
-static char *
-OpenConfigFile(const char *path, const char *cmdline, const char *projroot,
-	       const char *confname)
-{
-	char *filepath = NULL;
-	char *pathcopy;
-	const char *template;
-	int cmdlineUsed = 0;
-	FILE *file = NULL;
-
-	pathcopy = strdup(path);
-	for (template = strtok(pathcopy, ","); template && !file;
-	     template = strtok(NULL, ",")) {
-		filepath = DoSubstitution(template, cmdline, projroot,
-					  &cmdlineUsed, NULL, confname);
-		if (!filepath)
-			continue;
-		if (cmdline && !cmdlineUsed) {
-			free(filepath);
-			filepath = NULL;
-			continue;
-		}
-		file = fopen(filepath, "r");
-		if (!file) {
-			free(filepath);
-			filepath = NULL;
-		}
-	}
-
-	if (file) {
-		configFiles[numFiles].file = file;
-		configFiles[numFiles].path = strdup(filepath);
-		numFiles++;
-	}
-	return filepath;
-}
-
-/*
- * Match non-hidden files in the xorg config directory with a .conf
- * suffix. This filter is passed to scandir(3).
- */
-static int
-ConfigFilter(const struct dirent *de)
-{
-	const char *name = de->d_name;
-	size_t len;
-	size_t suflen = strlen(XCONFIGSUFFIX);
-
-	if (!name || name[0] == '.')
-		return 0;
-	len = strlen(name);
-	if(len <= suflen)
-		return 0;
-	if (strcmp(&name[len-suflen], XCONFIGSUFFIX) != 0)
-		return 0;
-	return 1;
-}
-
-static Bool
-AddConfigDirFiles(const char *dirpath, struct dirent **list, int num)
-{
-	int i;
-	Bool openedFile = FALSE;
-	Bool warnOnce = FALSE;
-
-	for (i = 0; i < num; i++) {
-		char *path;
-		FILE *file;
-
-		if (numFiles >= CONFIG_MAX_FILES) {
-			if (!warnOnce) {
-				ErrorF("Maximum number of configuration "
-				       "files opened\n");
-				warnOnce = TRUE;
-			}
-			free(list[i]);
-			continue;
-		}
-
-		path = malloc(PATH_MAX + 1);
-		snprintf(path, PATH_MAX + 1, "%s/%s", dirpath,
-			 list[i]->d_name);
-		free(list[i]);
-		file = fopen(path, "r");
-		if (!file) {
-			free(path);
-			continue;
-		}
-		openedFile = TRUE;
-
-		configFiles[numFiles].file = file;
-		configFiles[numFiles].path = path;
-		numFiles++;
-	}
-
-	return openedFile;
-}
-
-/*
- * Given some searching parameters, locate and open the xorg config
- * directory. The directory does not need to contain config files.
- */
-static char *
-OpenConfigDir(const char *path, const char *cmdline, const char *projroot,
-	      const char *confname)
-{
-	char *dirpath, *pathcopy;
-	const char *template;
-	Bool found = FALSE;
-	int cmdlineUsed = 0;
-
-	pathcopy = strdup(path);
-	for (template = strtok(pathcopy, ","); template && !found;
-	     template = strtok(NULL, ",")) {
-		struct dirent **list = NULL;
-		int num;
-
-		dirpath = DoSubstitution(template, cmdline, projroot,
-					 &cmdlineUsed, NULL, confname);
-		if (!dirpath)
-			continue;
-		if (cmdline && !cmdlineUsed) {
-			free(dirpath);
-			dirpath = NULL;
-			continue;
-		}
-
-		/* match files named *.conf */
-		num = scandir(dirpath, &list, ConfigFilter, alphasort);
-		found = AddConfigDirFiles(dirpath, list, num);
-		if (!found) {
-			free(dirpath);
-			dirpath = NULL;
-			if (list)
-				free(list);
-		}
-	}
-
-	return dirpath;
-}
-
-/*
- * xf86initConfigFiles -- Setup global variables and buffers.
- */
-void
-xf86initConfigFiles(void)
-{
-	curFileIndex = 0;
-	configPos = 0;
-	configLineNo = 0;
-	pushToken = LOCK_TOKEN;
-
-	configBuf = malloc(CONFIG_BUF_LEN);
-	configRBuf = malloc(CONFIG_BUF_LEN);
-	configBuf[0] = '\0';	/* sanity ... */
-}
-
-/*
- * xf86openConfigFile --
- *
- * This function take a config file search path (optional), a command-line
- * specified file name (optional) and the ProjectRoot path (optional) and
- * locates and opens a config file based on that information.  If a
- * command-line file name is specified, then this function fails if none
- * of the located files.
- *
- * The return value is a pointer to the actual name of the file that was
- * opened.  When no file is found, the return value is NULL.
- *
- * The escape sequences allowed in the search path are defined above.
- *
- */
-
-#ifndef DEFAULT_CONF_PATH
-#define DEFAULT_CONF_PATH	"/etc/X11/%S," \
-							"%P/etc/X11/%S," \
-							"/etc/X11/%G," \
-							"%P/etc/X11/%G," \
-							"/etc/X11/%X-%M," \
-							"/etc/X11/%X," \
-							"/etc/%X," \
-							"%P/etc/X11/%X.%H," \
-							"%P/etc/X11/%X-%M," \
-							"%P/etc/X11/%X," \
-							"%P/lib/X11/%X.%H," \
-							"%P/lib/X11/%X-%M," \
-							"%P/lib/X11/%X"
-#endif
-
-const char *
-xf86openConfigFile(const char *path, const char *cmdline, const char *projroot)
-{
-	if (!path || !path[0])
-		path = DEFAULT_CONF_PATH;
-	if (!projroot || !projroot[0])
-		projroot = PROJECTROOT;
-
-	/* Search for a config file or a fallback */
-	configPath = OpenConfigFile(path, cmdline, projroot, XCONFIGFILE);
-	if (!configPath)
-		configPath = OpenConfigFile(path, cmdline, projroot,
-					    XFREE86CFGFILE);
-	return configPath;
-}
-
-/*
- * xf86openConfigDirFiles --
- *
- * This function take a config directory search path (optional), a
- * command-line specified directory name (optional) and the ProjectRoot path
- * (optional) and locates and opens a config directory based on that
- * information.  If a command-line name is specified, then this function
- * fails if it is not found.
- *
- * The return value is a pointer to the actual name of the direcoty that was
- * opened.  When no directory is found, the return value is NULL.
- *
- * The escape sequences allowed in the search path are defined above.
- *
- */
-const char *
-xf86openConfigDirFiles(const char *path, const char *cmdline,
-		       const char *projroot)
-{
-	if (!path || !path[0])
-		path = DEFAULT_CONF_PATH;
-	if (!projroot || !projroot[0])
-		projroot = PROJECTROOT;
-
-	/* Search for the multiconf directory */
-	configDirPath = OpenConfigDir(path, cmdline, projroot, XCONFIGDIR);
-	return configDirPath;
-}
-
-void
-xf86closeConfigFile (void)
-{
-	int i;
-
-	free (configPath);
-	configPath = NULL;
-	free (configDirPath);
-	configDirPath = NULL;
-	free (configRBuf);
-	configRBuf = NULL;
-	free (configBuf);
-	configBuf = NULL;
-
-	if (numFiles == 0) {
-		builtinConfig = NULL;
-		builtinIndex = 0;
-	}
-	for (i = 0; i < numFiles; i++) {
-		fclose(configFiles[i].file);
-		configFiles[i].file = NULL;
-		free(configFiles[i].path);
-		configFiles[i].path = NULL;
-	}
-	numFiles = 0;
-}
-
-void
-xf86setBuiltinConfig(const char *config[])
-{
-	builtinConfig = config;
-}
-
-void
-xf86parseError (char *format,...)
-{
-	va_list ap;
-	char *filename = numFiles ? configFiles[curFileIndex].path :
-			 "<builtin configuration>";
-
-	ErrorF ("Parse error on line %d of section %s in file %s\n\t",
-		 configLineNo, configSection, filename);
-	va_start (ap, format);
-	VErrorF (format, ap);
-	va_end (ap);
-
-	ErrorF ("\n");
-}
-
-void
-xf86validationError (char *format,...)
-{
-	va_list ap;
-	char *filename = numFiles ? configFiles[curFileIndex].path :
-			 "<builtin configuration>";
-
-	ErrorF ("Data incomplete in file %s\n\t", filename);
-	va_start (ap, format);
-	VErrorF (format, ap);
-	va_end (ap);
-
-	ErrorF ("\n");
-}
-
-void
-xf86setSection (char *section)
-{
-	if (configSection)
-		free(configSection);
-	configSection = malloc(strlen (section) + 1);
-	strcpy (configSection, section);
-}
-
-/* 
- * xf86getToken --
- *  Lookup a string if it is actually a token in disguise.
- */
-int
-xf86getStringToken (xf86ConfigSymTabRec * tab)
-{
-	return StringToToken (val.str, tab);
-}
-
-static int
-StringToToken (char *str, xf86ConfigSymTabRec * tab)
-{
-	int i;
-
-	for (i = 0; tab[i].token != -1; i++)
-	{
-		if (!xf86nameCompare (tab[i].name, str))
-			return tab[i].token;
-	}
-	return (ERROR_TOKEN);
-}
-
-
-/* 
- * Compare two names.  The characters '_', ' ', and '\t' are ignored
- * in the comparison.
- */
-int
-xf86nameCompare (const char *s1, const char *s2)
-{
-	char c1, c2;
-
-	if (!s1 || *s1 == 0) {
-		if (!s2 || *s2 == 0)
-			return (0);
-		else
-			return (1);
-		}
-
-	while (*s1 == '_' || *s1 == ' ' || *s1 == '\t')
-		s1++;
-	while (*s2 == '_' || *s2 == ' ' || *s2 == '\t')
-		s2++;
-	c1 = (isupper (*s1) ? tolower (*s1) : *s1);
-	c2 = (isupper (*s2) ? tolower (*s2) : *s2);
-	while (c1 == c2)
-	{
-		if (c1 == '\0')
-			return (0);
-		s1++;
-		s2++;
-		while (*s1 == '_' || *s1 == ' ' || *s1 == '\t')
-			s1++;
-		while (*s2 == '_' || *s2 == ' ' || *s2 == '\t')
-			s2++;
-		c1 = (isupper (*s1) ? tolower (*s1) : *s1);
-		c2 = (isupper (*s2) ? tolower (*s2) : *s2);
-	}
-	return (c1 - c2);
-}
-
-char *
-xf86addComment(char *cur, char *add)
-{
-	char *str;
-	int len, curlen, iscomment, hasnewline = 0, endnewline;
-
-	if (add == NULL || add[0] == '\0')
-		return (cur);
-
-	if (cur) {
-		curlen = strlen(cur);
-		if (curlen)
-		    hasnewline = cur[curlen - 1] == '\n';
-		eol_seen = 0;
-	}
-	else
-		curlen = 0;
-
-	str = add;
-	iscomment = 0;
-	while (*str) {
-	    if (*str != ' ' && *str != '\t')
-		break;
-	    ++str;
-	}
-	iscomment = (*str == '#');
-
-	len = strlen(add);
-	endnewline = add[len - 1] == '\n';
-	len +=  1 + iscomment + (!hasnewline) + (!endnewline) + eol_seen;
-
-	if ((str = realloc(cur, len + curlen)) == NULL)
-		return (cur);
-
-	cur = str;
-
-	if (eol_seen || (curlen && !hasnewline))
-		cur[curlen++] = '\n';
-	if (!iscomment)
-		cur[curlen++] = '#';
-	strcpy(cur + curlen, add);
-	if (!endnewline)
-		strcat(cur, "\n");
-
-	return (cur);
-}
-
-Bool
-xf86getBoolValue(Bool *val, const char *str)
-{
-	if (!val || !str)
-		return FALSE;
-	if (*str == '\0') {
-		*val = TRUE;
-	} else {
-		if (xf86nameCompare(str, "1") == 0)
-			*val = TRUE;
-		else if (xf86nameCompare(str, "on") == 0)
-			*val = TRUE;
-		else if (xf86nameCompare(str, "true") == 0)
-			*val = TRUE;
-		else if (xf86nameCompare(str, "yes") == 0)
-			*val = TRUE;
-		else if (xf86nameCompare(str, "0") == 0)
-			*val = FALSE;
-		else if (xf86nameCompare(str, "off") == 0)
-			*val = FALSE;
-		else if (xf86nameCompare(str, "false") == 0)
-			*val = FALSE;
-		else if (xf86nameCompare(str, "no") == 0)
-			*val = FALSE;
-		else
-			return FALSE;
-	}
-	return TRUE;
-}
+/* 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* View/edit this file with tab stops set to 4 */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <ctype.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <sys/types.h>

+#include <dirent.h>

+#include <unistd.h>

+#include <stdarg.h>

+#include <X11/Xdefs.h>

+#include <X11/Xfuncproto.h>

+

+#if defined(_POSIX_SOURCE)

+#include <limits.h>

+#else

+#define _POSIX_SOURCE

+#include <limits.h>

+#undef _POSIX_SOURCE

+#endif /* _POSIX_SOURCE */

+

+#if !defined(PATH_MAX)

+#if defined(MAXPATHLEN)

+#define PATH_MAX MAXPATHLEN

+#else

+#define PATH_MAX 1024

+#endif /* MAXPATHLEN */

+#endif /* !PATH_MAX */

+

+#if !defined(MAXHOSTNAMELEN)

+#define MAXHOSTNAMELEN 32

+#endif /* !MAXHOSTNAMELEN */

+

+#include "Configint.h"

+#include "xf86tokens.h"

+

+#define CONFIG_BUF_LEN     1024

+#define CONFIG_MAX_FILES   64

+

+static int StringToToken (char *, xf86ConfigSymTabRec *);

+

+static struct {

+	FILE *file;

+	char *path;

+} configFiles[CONFIG_MAX_FILES];

+static const char **builtinConfig = NULL;

+static int builtinIndex = 0;

+static int configPos = 0;		/* current readers position */

+static int configLineNo = 0;	/* linenumber */

+static char *configBuf, *configRBuf;	/* buffer for lines */

+static char *configPath;		/* path to config file */

+static char *configDirPath;		/* path to config dir */

+static char *configSection = NULL;	/* name of current section being parsed */

+static int numFiles = 0;		/* number of config files */

+static int curFileIndex = 0;		/* index of current config file */

+static int pushToken = LOCK_TOKEN;

+static int eol_seen = 0;		/* private state to handle comments */

+LexRec val;

+

+/* 

+ * xf86strToUL --

+ *

+ *  A portable, but restricted, version of strtoul().  It only understands

+ *  hex, octal, and decimal.  But it's good enough for our needs.

+ */

+static unsigned int

+xf86strToUL (char *str)

+{

+	int base = 10;

+	char *p = str;

+	unsigned int tot = 0;

+

+	if (*p == '0')

+	{

+		p++;

+		if ((*p == 'x') || (*p == 'X'))

+		{

+			p++;

+			base = 16;

+		}

+		else

+			base = 8;

+	}

+	while (*p)

+	{

+		if ((*p >= '0') && (*p <= ((base == 8) ? '7' : '9')))

+		{

+			tot = tot * base + (*p - '0');

+		}

+		else if ((base == 16) && (*p >= 'a') && (*p <= 'f'))

+		{

+			tot = tot * base + 10 + (*p - 'a');

+		}

+		else if ((base == 16) && (*p >= 'A') && (*p <= 'F'))

+		{

+			tot = tot * base + 10 + (*p - 'A');

+		}

+		else

+		{

+			return tot;

+		}

+		p++;

+	}

+	return tot;

+}

+

+/*

+ * xf86getNextLine --

+ *

+ *  read from the configFiles FILE stream until we encounter a new

+ *  line; this is effectively just a big wrapper for fgets(3).

+ *

+ *  xf86getToken() assumes that we will read up to the next

+ *  newline; we need to grow configBuf and configRBuf as needed to

+ *  support that.

+ */

+

+static char*

+xf86getNextLine(void)

+{

+	static int configBufLen = CONFIG_BUF_LEN;

+	char *tmpConfigBuf, *tmpConfigRBuf;

+	int c, i, pos = 0, eolFound = 0;

+	char *ret = NULL;

+

+	/*

+	 * reallocate the string if it was grown last time (i.e., is no

+	 * longer CONFIG_BUF_LEN); we malloc the new strings first, so

+	 * that if either of the mallocs fail, we can fall back on the

+	 * existing buffer allocations

+	 */

+

+	if (configBufLen != CONFIG_BUF_LEN) {

+

+		tmpConfigBuf = malloc(CONFIG_BUF_LEN);

+		tmpConfigRBuf = malloc(CONFIG_BUF_LEN);

+

+		if (!tmpConfigBuf || !tmpConfigRBuf) {

+

+			/*

+			 * at least one of the mallocs failed; keep the old buffers

+			 * and free any partial allocations

+			 */

+

+			free(tmpConfigBuf);

+			free(tmpConfigRBuf);

+

+		} else {

+

+			/*

+			 * malloc succeeded; free the old buffers and use the new

+			 * buffers

+			 */

+

+			configBufLen = CONFIG_BUF_LEN;

+

+			free(configBuf);

+			free(configRBuf);

+

+			configBuf = tmpConfigBuf;

+			configRBuf = tmpConfigRBuf;

+		}

+	}

+

+	/* read in another block of chars */

+

+	do {

+		ret = fgets(configBuf + pos, configBufLen - pos - 1,

+			    configFiles[curFileIndex].file);

+

+		if (!ret) {

+			/*

+			 * if the file doesn't end in a newline, add one

+			 * and trigger another read

+			 */

+			if (pos != 0) {

+				strcpy(&configBuf[pos], "\n");

+				ret = configBuf;

+			} else

+				break;

+		}

+

+		/* search for EOL in the new block of chars */

+

+		for (i = pos; i < (configBufLen - 1); i++) {

+			c = configBuf[i];

+

+			if (c == '\0') break;

+

+			if ((c == '\n') || (c == '\r')) {

+				eolFound = 1;

+				break;

+			}

+		}

+

+		/*

+		 * if we didn't find EOL, then grow the string and

+		 * read in more

+		 */

+

+		if (!eolFound) {

+

+			tmpConfigBuf = realloc(configBuf, configBufLen + CONFIG_BUF_LEN);

+			tmpConfigRBuf = realloc(configRBuf, configBufLen + CONFIG_BUF_LEN);

+

+			if (!tmpConfigBuf || !tmpConfigRBuf) {

+

+				/*

+				 * at least one of the reallocations failed; use the

+				 * new allocation that succeeded, but we have to

+				 * fallback to the previous configBufLen size and use

+				 * the string we have, even though we don't have an

+				 * EOL

+				 */

+

+				if (tmpConfigBuf) configBuf = tmpConfigBuf;

+				if (tmpConfigRBuf) configRBuf = tmpConfigRBuf;

+

+				break;

+

+			} else {

+

+				/* reallocation succeeded */

+

+				configBuf = tmpConfigBuf;

+				configRBuf = tmpConfigRBuf;

+				pos = i;

+				configBufLen += CONFIG_BUF_LEN;

+			}

+		}

+

+	} while (!eolFound);

+

+	return ret;

+}

+

+/* 

+ * xf86getToken --

+ *      Read next Token from the config file. Handle the global variable

+ *      pushToken.

+ */

+int

+xf86getToken (xf86ConfigSymTabRec * tab)

+{

+	int c, i;

+

+	/* 

+	 * First check whether pushToken has a different value than LOCK_TOKEN.

+	 * In this case rBuf[] contains a valid STRING/TOKEN/NUMBER. But in the

+	 * oth * case the next token must be read from the input.

+	 */

+	if (pushToken == EOF_TOKEN)

+		return EOF_TOKEN;

+	else if (pushToken == LOCK_TOKEN)

+	{

+		/*

+		 * eol_seen is only set for the first token after a newline.

+		 */

+		eol_seen = 0;

+

+		c = configBuf[configPos];

+

+		/* 

+		 * Get start of next Token. EOF is handled,

+		 * whitespaces are skipped. 

+		 */

+

+again:

+		if (!c)

+		{

+			char *ret;

+			if (numFiles > 0)

+				ret = xf86getNextLine();

+			else {

+				if (builtinConfig[builtinIndex] == NULL)

+					ret = NULL;

+				else {

+					ret = strncpy(configBuf, builtinConfig[builtinIndex],

+							CONFIG_BUF_LEN);

+					builtinIndex++;

+				}

+			}

+			if (ret == NULL)

+			{

+				/*

+				 * if necessary, move to the next file and

+				 * read the first line

+				 */

+				if (curFileIndex + 1 < numFiles) {

+					curFileIndex++;

+					configLineNo = 0;

+					goto again;

+				}

+				else

+					return pushToken = EOF_TOKEN;

+			}

+			configLineNo++;

+			configPos = 0;

+			eol_seen = 1;

+		}

+

+		i = 0;

+		for (;;) {

+			c = configBuf[configPos++];

+			configRBuf[i++] = c;

+			switch (c) {

+				case ' ':

+				case '\t':

+				case '\r':

+					continue;

+				case '\n':

+					i = 0;

+					continue;

+			}

+			break;

+		}

+		if (c == '\0')

+			goto again;

+

+		if (c == '#')

+		{

+			do

+			{

+				configRBuf[i++] = (c = configBuf[configPos++]);

+			}

+			while ((c != '\n') && (c != '\r') && (c != '\0'));

+			configRBuf[i] = '\0';

+			/* XXX no private copy.

+			 * Use xf86addComment when setting a comment.

+			 */

+			val.str = configRBuf;

+			return COMMENT;

+		}

+

+		/* GJA -- handle '-' and ','  * Be careful: "-hsync" is a keyword. */

+		else if ((c == ',') && !isalpha (configBuf[configPos]))

+		{

+			return COMMA;

+		}

+		else if ((c == '-') && !isalpha (configBuf[configPos]))

+		{

+			return DASH;

+		}

+

+		/* 

+		 * Numbers are returned immediately ...

+		 */

+		if (isdigit (c))

+		{

+			int base;

+

+			if (c == '0')

+				if ((configBuf[configPos] == 'x') ||

+					(configBuf[configPos] == 'X'))

+                                {

+					base = 16;

+                                        val.numType = PARSE_HEX;

+                                }

+				else

+                                {

+					base = 8;

+                                        val.numType = PARSE_OCTAL;

+                                }

+			else

+                        {

+				base = 10;

+                                val.numType = PARSE_DECIMAL;

+                        }

+

+			configRBuf[0] = c;

+			i = 1;

+			while (isdigit (c = configBuf[configPos++]) ||

+				   (c == '.') || (c == 'x') || (c == 'X') ||

+				   ((base == 16) && (((c >= 'a') && (c <= 'f')) ||

+									 ((c >= 'A') && (c <= 'F')))))

+				configRBuf[i++] = c;

+			configPos--;		/* GJA -- one too far */

+			configRBuf[i] = '\0';

+			val.num = xf86strToUL (configRBuf);

+			val.realnum = atof (configRBuf);

+			return NUMBER;

+		}

+

+		/* 

+		 * All Strings START with a \" ...

+		 */

+		else if (c == '\"')

+		{

+			i = -1;

+			do

+			{

+				configRBuf[++i] = (c = configBuf[configPos++]);

+			}

+			while ((c != '\"') && (c != '\n') && (c != '\r') && (c != '\0'));

+			configRBuf[i] = '\0';

+			val.str = malloc (strlen (configRBuf) + 1);

+			strcpy (val.str, configRBuf);	/* private copy ! */

+			return STRING;

+		}

+

+		/* 

+		 * ... and now we MUST have a valid token.  The search is

+		 * handled later along with the pushed tokens.

+		 */

+		else

+		{

+			configRBuf[0] = c;

+			i = 0;

+			do

+			{

+				configRBuf[++i] = (c = configBuf[configPos++]);

+			}

+			while ((c != ' ') && (c != '\t') && (c != '\n') && (c != '\r') && (c != '\0') && (c != '#'));

+			--configPos;

+			configRBuf[i] = '\0';

+			i = 0;

+		}

+

+	}

+	else

+	{

+

+		/* 

+		 * Here we deal with pushed tokens. Reinitialize pushToken again. If

+		 * the pushed token was NUMBER || STRING return them again ...

+		 */

+		int temp = pushToken;

+		pushToken = LOCK_TOKEN;

+

+		if (temp == COMMA || temp == DASH)

+			return temp;

+		if (temp == NUMBER || temp == STRING)

+			return temp;

+	}

+

+	/* 

+	 * Joop, at last we have to lookup the token ...

+	 */

+	if (tab)

+	{

+		i = 0;

+		while (tab[i].token != -1)

+			if (xf86nameCompare (configRBuf, tab[i].name) == 0)

+				return tab[i].token;

+			else

+				i++;

+	}

+

+	return ERROR_TOKEN;		/* Error catcher */

+}

+

+int

+xf86getSubToken (char **comment)

+{

+	int token;

+

+	for (;;) {

+		token = xf86getToken(NULL);

+		if (token == COMMENT) {

+			if (comment)

+				*comment = xf86addComment(*comment, val.str);

+		}

+		else

+			return token;

+	}

+	/*NOTREACHED*/

+}

+

+int

+xf86getSubTokenWithTab (char **comment, xf86ConfigSymTabRec *tab)

+{

+	int token;

+

+	for (;;) {

+		token = xf86getToken(tab);

+		if (token == COMMENT) {

+			if (comment)

+				*comment = xf86addComment(*comment, val.str);

+		}

+		else

+			return token;

+	}

+	/*NOTREACHED*/

+}

+

+void

+xf86unGetToken (int token)

+{

+	pushToken = token;

+}

+

+char *

+xf86tokenString (void)

+{

+	return configRBuf;

+}

+

+int

+xf86pathIsAbsolute(const char *path)

+{

+	if (path && path[0] == '/')

+		return 1;

+	return 0;

+}

+

+/* A path is "safe" if it is relative and if it contains no ".." elements. */

+int

+xf86pathIsSafe(const char *path)

+{

+	if (xf86pathIsAbsolute(path))

+		return 0;

+

+	/* Compare with ".." */

+	if (!strcmp(path, ".."))

+		return 0;

+

+	/* Look for leading "../" */

+	if (!strncmp(path, "../", 3))

+		return 0;

+

+	/* Look for trailing "/.." */

+	if ((strlen(path) > 3) && !strcmp(path + strlen(path) - 3, "/.."))

+		return 0;

+

+	/* Look for "/../" */

+	if (strstr(path, "/../"))

+		return 0;

+

+	return 1;

+}

+

+/*

+ * This function substitutes the following escape sequences:

+ *

+ *    %A    cmdline argument as an absolute path (must be absolute to match)

+ *    %R    cmdline argument as a relative path

+ *    %S    cmdline argument as a "safe" path (relative, and no ".." elements)

+ *    %X    default config file name ("xorg.conf")

+ *    %H    hostname

+ *    %E    config file environment ($XORGCONFIG) as an absolute path

+ *    %F    config file environment ($XORGCONFIG) as a relative path

+ *    %G    config file environment ($XORGCONFIG) as a safe path

+ *    %P    projroot

+ *    %C    sysconfdir

+ *    %D    datadir

+ *    %M    config file format version number

+ *    %%    %

+ */

+

+#ifndef XCONFIGFILE

+#define XCONFIGFILE	"xorg.conf"

+#endif

+#ifndef XCONFIGDIR

+#define XCONFIGDIR	"xorg.conf.d"

+#endif

+#ifndef XCONFIGSUFFIX

+#define XCONFIGSUFFIX	".conf"

+#endif

+#ifndef PROJECTROOT

+#define PROJECTROOT	"/usr/X11R6"

+#endif

+#ifndef SYSCONFDIR

+#define SYSCONFDIR	PROJECTROOT "/etc"

+#endif

+#ifndef DATADIR

+#define DATADIR		PROJECTROOT "/share"

+#endif

+#ifndef XCONFENV

+#define XCONFENV	"XORGCONFIG"

+#endif

+/* xorg.conf is based on XF86Config version 4.   If we ever break

+   compatibility of the xorg.conf syntax, we'll bump this version number. */

+#ifndef CONFIG_FILE_VERSION

+#define CONFIG_FILE_VERSION	4

+#endif

+

+#define BAIL_OUT		do {									\

+							free(result);				\

+							return NULL;						\

+						} while (0)

+

+#define CHECK_LENGTH	do {									\

+							if (l > PATH_MAX) {					\

+								BAIL_OUT;						\

+							}									\

+						} while (0)

+

+#define APPEND_STR(s)	do {									\

+							if (strlen(s) + l > PATH_MAX) {		\

+								BAIL_OUT;						\

+							} else {							\

+								strcpy(result + l, s);			\

+								l += strlen(s);					\

+							}									\

+						} while (0)

+

+static char *

+DoSubstitution(const char *template, const char *cmdline, const char *projroot,

+				int *cmdlineUsed, int *envUsed,

+				const char *XConfigFile)

+{

+	char *result;

+	int i, l;

+	static const char *env = NULL;

+	static char *hostname = NULL;

+	static char majorvers[3] = "";

+

+	if (!template)

+		return NULL;

+

+	if (cmdlineUsed)

+		*cmdlineUsed = 0;

+	if (envUsed)

+		*envUsed = 0;

+

+	result = malloc(PATH_MAX + 1);

+	l = 0;

+	for (i = 0; template[i]; i++) {

+		if (template[i] != '%') {

+			result[l++] = template[i];

+			CHECK_LENGTH;

+		} else {

+			switch (template[++i]) {

+			case 'A':

+				if (cmdline && xf86pathIsAbsolute(cmdline)) {

+					APPEND_STR(cmdline);

+					if (cmdlineUsed)

+						*cmdlineUsed = 1;

+				} else

+					BAIL_OUT;

+				break;

+			case 'R':

+				if (cmdline && !xf86pathIsAbsolute(cmdline)) {

+					APPEND_STR(cmdline);

+					if (cmdlineUsed)

+						*cmdlineUsed = 1;

+				} else 

+					BAIL_OUT;

+				break;

+			case 'S':

+				if (cmdline && xf86pathIsSafe(cmdline)) {

+					APPEND_STR(cmdline);

+					if (cmdlineUsed)

+						*cmdlineUsed = 1;

+				} else 

+					BAIL_OUT;

+				break;

+			case 'X':

+				APPEND_STR(XConfigFile);

+				break;

+			case 'H':

+				if (!hostname) {

+					if ((hostname = malloc(MAXHOSTNAMELEN + 1))) {

+						if (gethostname(hostname, MAXHOSTNAMELEN) == 0) {

+							hostname[MAXHOSTNAMELEN] = '\0';

+						} else {

+							free(hostname);

+							hostname = NULL;

+						}

+					}

+				}

+				if (hostname)

+					APPEND_STR(hostname);

+				break;

+			case 'E':

+				if (!env)

+					env = getenv(XCONFENV);

+				if (env && xf86pathIsAbsolute(env)) {

+					APPEND_STR(env);

+					if (envUsed)

+						*envUsed = 1;

+				} else

+					BAIL_OUT;

+				break;

+			case 'F':

+				if (!env)

+					env = getenv(XCONFENV);

+				if (env && !xf86pathIsAbsolute(env)) {

+					APPEND_STR(env);

+					if (envUsed)

+						*envUsed = 1;

+				} else

+					BAIL_OUT;

+				break;

+			case 'G':

+				if (!env)

+					env = getenv(XCONFENV);

+				if (env && xf86pathIsSafe(env)) {

+					APPEND_STR(env);

+					if (envUsed)

+						*envUsed = 1;

+				} else

+					BAIL_OUT;

+				break;

+			case 'P':

+				if (projroot && xf86pathIsAbsolute(projroot))

+					APPEND_STR(projroot);

+				else

+					BAIL_OUT;

+				break;

+			case 'C':

+				APPEND_STR(SYSCONFDIR);

+				break;

+			case 'D':

+				APPEND_STR(DATADIR);

+				break;

+			case 'M':

+				if (!majorvers[0]) {

+					snprintf(majorvers, sizeof(majorvers),

+						 "%d", CONFIG_FILE_VERSION);

+				}

+				APPEND_STR(majorvers);

+				break;

+			case '%':

+				result[l++] = '%';

+				CHECK_LENGTH;

+				break;

+			default:

+				fprintf(stderr, "invalid escape %%%c found in path template\n",

+						template[i]);

+				BAIL_OUT;

+				break;

+			}

+		}

+	}

+#ifdef DEBUG

+	fprintf(stderr, "Converted `%s' to `%s'\n", template, result);

+#endif

+	return result;

+}

+

+/*

+ * Given some searching parameters, locate and open the xorg config file.

+ */

+static char *

+OpenConfigFile(const char *path, const char *cmdline, const char *projroot,

+	       const char *confname)

+{

+	char *filepath = NULL;

+	char *pathcopy;

+	const char *template;

+	int cmdlineUsed = 0;

+	FILE *file = NULL;

+

+	pathcopy = strdup(path);

+	for (template = strtok(pathcopy, ","); template && !file;

+	     template = strtok(NULL, ",")) {

+		filepath = DoSubstitution(template, cmdline, projroot,

+					  &cmdlineUsed, NULL, confname);

+		if (!filepath)

+			continue;

+		if (cmdline && !cmdlineUsed) {

+			free(filepath);

+			filepath = NULL;

+			continue;

+		}

+		file = fopen(filepath, "r");

+		if (!file) {

+			free(filepath);

+			filepath = NULL;

+		}

+	}

+

+	if (file) {

+		configFiles[numFiles].file = file;

+		configFiles[numFiles].path = strdup(filepath);

+		numFiles++;

+	}

+	return filepath;

+}

+

+/*

+ * Match non-hidden files in the xorg config directory with a .conf

+ * suffix. This filter is passed to scandir(3).

+ */

+static int

+ConfigFilter(const struct dirent *de)

+{

+	const char *name = de->d_name;

+	size_t len;

+	size_t suflen = strlen(XCONFIGSUFFIX);

+

+	if (!name || name[0] == '.')

+		return 0;

+	len = strlen(name);

+	if(len <= suflen)

+		return 0;

+	if (strcmp(&name[len-suflen], XCONFIGSUFFIX) != 0)

+		return 0;

+	return 1;

+}

+

+static Bool

+AddConfigDirFiles(const char *dirpath, struct dirent **list, int num)

+{

+	int i;

+	Bool openedFile = FALSE;

+	Bool warnOnce = FALSE;

+

+	for (i = 0; i < num; i++) {

+		char *path;

+		FILE *file;

+

+		if (numFiles >= CONFIG_MAX_FILES) {

+			if (!warnOnce) {

+				ErrorF("Maximum number of configuration "

+				       "files opened\n");

+				warnOnce = TRUE;

+			}

+			free(list[i]);

+			continue;

+		}

+

+		path = malloc(PATH_MAX + 1);

+		snprintf(path, PATH_MAX + 1, "%s/%s", dirpath,

+			 list[i]->d_name);

+		free(list[i]);

+		file = fopen(path, "r");

+		if (!file) {

+			free(path);

+			continue;

+		}

+		openedFile = TRUE;

+

+		configFiles[numFiles].file = file;

+		configFiles[numFiles].path = path;

+		numFiles++;

+	}

+

+	return openedFile;

+}

+

+/*

+ * Given some searching parameters, locate and open the xorg config

+ * directory. The directory does not need to contain config files.

+ */

+static char *

+OpenConfigDir(const char *path, const char *cmdline, const char *projroot,

+	      const char *confname)

+{

+	char *dirpath, *pathcopy;

+	const char *template;

+	Bool found = FALSE;

+	int cmdlineUsed = 0;

+

+	pathcopy = strdup(path);

+	for (template = strtok(pathcopy, ","); template && !found;

+	     template = strtok(NULL, ",")) {

+		struct dirent **list = NULL;

+		int num;

+

+		dirpath = DoSubstitution(template, cmdline, projroot,

+					 &cmdlineUsed, NULL, confname);

+		if (!dirpath)

+			continue;

+		if (cmdline && !cmdlineUsed) {

+			free(dirpath);

+			dirpath = NULL;

+			continue;

+		}

+

+		/* match files named *.conf */

+		num = scandir(dirpath, &list, ConfigFilter, alphasort);

+		found = AddConfigDirFiles(dirpath, list, num);

+		if (!found) {

+			free(dirpath);

+			dirpath = NULL;

+			free(list);

+		}

+	}

+

+	return dirpath;

+}

+

+/*

+ * xf86initConfigFiles -- Setup global variables and buffers.

+ */

+void

+xf86initConfigFiles(void)

+{

+	curFileIndex = 0;

+	configPos = 0;

+	configLineNo = 0;

+	pushToken = LOCK_TOKEN;

+

+	configBuf = malloc(CONFIG_BUF_LEN);

+	configRBuf = malloc(CONFIG_BUF_LEN);

+	configBuf[0] = '\0';	/* sanity ... */

+}

+

+/*

+ * xf86openConfigFile --

+ *

+ * This function take a config file search path (optional), a command-line

+ * specified file name (optional) and the ProjectRoot path (optional) and

+ * locates and opens a config file based on that information.  If a

+ * command-line file name is specified, then this function fails if none

+ * of the located files.

+ *

+ * The return value is a pointer to the actual name of the file that was

+ * opened.  When no file is found, the return value is NULL.

+ *

+ * The escape sequences allowed in the search path are defined above.

+ *

+ */

+

+#ifndef DEFAULT_CONF_PATH

+#define DEFAULT_CONF_PATH	"/etc/X11/%S," \

+							"%P/etc/X11/%S," \

+							"/etc/X11/%G," \

+							"%P/etc/X11/%G," \

+							"/etc/X11/%X-%M," \

+							"/etc/X11/%X," \

+							"/etc/%X," \

+							"%P/etc/X11/%X.%H," \

+							"%P/etc/X11/%X-%M," \

+							"%P/etc/X11/%X," \

+							"%P/lib/X11/%X.%H," \

+							"%P/lib/X11/%X-%M," \

+							"%P/lib/X11/%X"

+#endif

+

+const char *

+xf86openConfigFile(const char *path, const char *cmdline, const char *projroot)

+{

+	if (!path || !path[0])

+		path = DEFAULT_CONF_PATH;

+	if (!projroot || !projroot[0])

+		projroot = PROJECTROOT;

+

+	/* Search for a config file */

+	configPath = OpenConfigFile(path, cmdline, projroot, XCONFIGFILE);

+	return configPath;

+}

+

+/*

+ * xf86openConfigDirFiles --

+ *

+ * This function take a config directory search path (optional), a

+ * command-line specified directory name (optional) and the ProjectRoot path

+ * (optional) and locates and opens a config directory based on that

+ * information.  If a command-line name is specified, then this function

+ * fails if it is not found.

+ *

+ * The return value is a pointer to the actual name of the direcoty that was

+ * opened.  When no directory is found, the return value is NULL.

+ *

+ * The escape sequences allowed in the search path are defined above.

+ *

+ */

+const char *

+xf86openConfigDirFiles(const char *path, const char *cmdline,

+		       const char *projroot)

+{

+	if (!path || !path[0])

+		path = DEFAULT_CONF_PATH;

+	if (!projroot || !projroot[0])

+		projroot = PROJECTROOT;

+

+	/* Search for the multiconf directory */

+	configDirPath = OpenConfigDir(path, cmdline, projroot, XCONFIGDIR);

+	return configDirPath;

+}

+

+void

+xf86closeConfigFile (void)

+{

+	int i;

+

+	free (configPath);

+	configPath = NULL;

+	free (configDirPath);

+	configDirPath = NULL;

+	free (configRBuf);

+	configRBuf = NULL;

+	free (configBuf);

+	configBuf = NULL;

+

+	if (numFiles == 0) {

+		builtinConfig = NULL;

+		builtinIndex = 0;

+	}

+	for (i = 0; i < numFiles; i++) {

+		fclose(configFiles[i].file);

+		configFiles[i].file = NULL;

+		free(configFiles[i].path);

+		configFiles[i].path = NULL;

+	}

+	numFiles = 0;

+}

+

+void

+xf86setBuiltinConfig(const char *config[])

+{

+	builtinConfig = config;

+}

+

+void

+xf86parseError (char *format,...)

+{

+	va_list ap;

+	char *filename = numFiles ? configFiles[curFileIndex].path :

+			 "<builtin configuration>";

+

+	ErrorF ("Parse error on line %d of section %s in file %s\n\t",

+		 configLineNo, configSection, filename);

+	va_start (ap, format);

+	VErrorF (format, ap);

+	va_end (ap);

+

+	ErrorF ("\n");

+}

+

+void

+xf86validationError (char *format,...)

+{

+	va_list ap;

+	char *filename = numFiles ? configFiles[curFileIndex].path :

+			 "<builtin configuration>";

+

+	ErrorF ("Data incomplete in file %s\n\t", filename);

+	va_start (ap, format);

+	VErrorF (format, ap);

+	va_end (ap);

+

+	ErrorF ("\n");

+}

+

+void

+xf86setSection (char *section)

+{

+	free(configSection);

+	configSection = malloc(strlen (section) + 1);

+	strcpy (configSection, section);

+}

+

+/* 

+ * xf86getToken --

+ *  Lookup a string if it is actually a token in disguise.

+ */

+int

+xf86getStringToken (xf86ConfigSymTabRec * tab)

+{

+	return StringToToken (val.str, tab);

+}

+

+static int

+StringToToken (char *str, xf86ConfigSymTabRec * tab)

+{

+	int i;

+

+	for (i = 0; tab[i].token != -1; i++)

+	{

+		if (!xf86nameCompare (tab[i].name, str))

+			return tab[i].token;

+	}

+	return ERROR_TOKEN;

+}

+

+

+/* 

+ * Compare two names.  The characters '_', ' ', and '\t' are ignored

+ * in the comparison.

+ */

+int

+xf86nameCompare (const char *s1, const char *s2)

+{

+	char c1, c2;

+

+	if (!s1 || *s1 == 0) {

+		if (!s2 || *s2 == 0)

+			return 0;

+		else

+			return 1;

+		}

+

+	while (*s1 == '_' || *s1 == ' ' || *s1 == '\t')

+		s1++;

+	while (*s2 == '_' || *s2 == ' ' || *s2 == '\t')

+		s2++;

+	c1 = (isupper (*s1) ? tolower (*s1) : *s1);

+	c2 = (isupper (*s2) ? tolower (*s2) : *s2);

+	while (c1 == c2)

+	{

+		if (c1 == '\0')

+			return 0;

+		s1++;

+		s2++;

+		while (*s1 == '_' || *s1 == ' ' || *s1 == '\t')

+			s1++;

+		while (*s2 == '_' || *s2 == ' ' || *s2 == '\t')

+			s2++;

+		c1 = (isupper (*s1) ? tolower (*s1) : *s1);

+		c2 = (isupper (*s2) ? tolower (*s2) : *s2);

+	}

+	return c1 - c2;

+}

+

+char *

+xf86addComment(char *cur, char *add)

+{

+	char *str;

+	int len, curlen, iscomment, hasnewline = 0, endnewline;

+

+	if (add == NULL || add[0] == '\0')

+		return cur;

+

+	if (cur) {

+		curlen = strlen(cur);

+		if (curlen)

+		    hasnewline = cur[curlen - 1] == '\n';

+		eol_seen = 0;

+	}

+	else

+		curlen = 0;

+

+	str = add;

+	iscomment = 0;

+	while (*str) {

+	    if (*str != ' ' && *str != '\t')

+		break;

+	    ++str;

+	}

+	iscomment = (*str == '#');

+

+	len = strlen(add);

+	endnewline = add[len - 1] == '\n';

+	len +=  1 + iscomment + (!hasnewline) + (!endnewline) + eol_seen;

+

+	if ((str = realloc(cur, len + curlen)) == NULL)

+		return cur;

+

+	cur = str;

+

+	if (eol_seen || (curlen && !hasnewline))

+		cur[curlen++] = '\n';

+	if (!iscomment)

+		cur[curlen++] = '#';

+	strcpy(cur + curlen, add);

+	if (!endnewline)

+		strcat(cur, "\n");

+

+	return cur;

+}

+

+Bool

+xf86getBoolValue(Bool *val, const char *str)

+{

+	if (!val || !str)

+		return FALSE;

+	if (*str == '\0') {

+		*val = TRUE;

+	} else {

+		if (xf86nameCompare(str, "1") == 0)

+			*val = TRUE;

+		else if (xf86nameCompare(str, "on") == 0)

+			*val = TRUE;

+		else if (xf86nameCompare(str, "true") == 0)

+			*val = TRUE;

+		else if (xf86nameCompare(str, "yes") == 0)

+			*val = TRUE;

+		else if (xf86nameCompare(str, "0") == 0)

+			*val = FALSE;

+		else if (xf86nameCompare(str, "off") == 0)

+			*val = FALSE;

+		else if (xf86nameCompare(str, "false") == 0)

+			*val = FALSE;

+		else if (xf86nameCompare(str, "no") == 0)

+			*val = FALSE;

+		else

+			return FALSE;

+	}

+	return TRUE;

+}

diff --git a/xorg-server/hw/xfree86/parser/xf86Parser.h b/xorg-server/hw/xfree86/parser/xf86Parser.h
index d79544a20..d35bbab27 100644
--- a/xorg-server/hw/xfree86/parser/xf86Parser.h
+++ b/xorg-server/hw/xfree86/parser/xf86Parser.h
@@ -1,518 +1,530 @@
-/* 
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-/* 
- * This file contains the external interfaces for the XFree86 configuration
- * file parser.
- */
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#ifndef _xf86Parser_h_
-#define _xf86Parser_h_
-
-#include <X11/Xdefs.h>
-#include "xf86Optrec.h"
-
-#define HAVE_PARSER_DECLS
-
-typedef struct
-{
-	char *file_logfile;
-	char *file_modulepath;
-	char *file_fontpath;
-	char *file_comment;
-	char *file_xkbdir;
-}
-XF86ConfFilesRec, *XF86ConfFilesPtr;
-
-/* Values for load_type */
-#define XF86_LOAD_MODULE	0
-#define XF86_LOAD_DRIVER	1
-#define XF86_DISABLE_MODULE	2
-
-typedef struct
-{
-	GenericListRec list;
-	int load_type;
-	char *load_name;
-	XF86OptionPtr load_opt;
-	char *load_comment;
-        int ignore;
-}
-XF86LoadRec, *XF86LoadPtr;
-
-typedef struct
-{
-	XF86LoadPtr mod_load_lst;
-    XF86LoadPtr mod_disable_lst;
-	char *mod_comment;
-}
-XF86ConfModuleRec, *XF86ConfModulePtr;
-
-#define CONF_IMPLICIT_KEYBOARD	"Implicit Core Keyboard"
-
-#define CONF_IMPLICIT_POINTER	"Implicit Core Pointer"
-
-#define XF86CONF_PHSYNC    0x0001
-#define XF86CONF_NHSYNC    0x0002
-#define XF86CONF_PVSYNC    0x0004
-#define XF86CONF_NVSYNC    0x0008
-#define XF86CONF_INTERLACE 0x0010
-#define XF86CONF_DBLSCAN   0x0020
-#define XF86CONF_CSYNC     0x0040
-#define XF86CONF_PCSYNC    0x0080
-#define XF86CONF_NCSYNC    0x0100
-#define XF86CONF_HSKEW     0x0200	/* hskew provided */
-#define XF86CONF_BCAST     0x0400
-#define XF86CONF_CUSTOM    0x0800	/* timing numbers customized by editor */
-#define XF86CONF_VSCAN     0x1000
-
-typedef struct
-{
-	GenericListRec list;
-	char *ml_identifier;
-	int ml_clock;
-	int ml_hdisplay;
-	int ml_hsyncstart;
-	int ml_hsyncend;
-	int ml_htotal;
-	int ml_vdisplay;
-	int ml_vsyncstart;
-	int ml_vsyncend;
-	int ml_vtotal;
-	int ml_vscan;
-	int ml_flags;
-	int ml_hskew;
-	char *ml_comment;
-}
-XF86ConfModeLineRec, *XF86ConfModeLinePtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *vp_identifier;
-	XF86OptionPtr vp_option_lst;
-	char *vp_comment;
-}
-XF86ConfVideoPortRec, *XF86ConfVideoPortPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *va_identifier;
-	char *va_vendor;
-	char *va_board;
-	char *va_busid;
-	char *va_driver;
-	XF86OptionPtr va_option_lst;
-	XF86ConfVideoPortPtr va_port_lst;
-	char *va_fwdref;
-	char *va_comment;
-}
-XF86ConfVideoAdaptorRec, *XF86ConfVideoAdaptorPtr;
-
-#define CONF_MAX_HSYNC 8
-#define CONF_MAX_VREFRESH 8
-
-typedef struct
-{
-	float hi, lo;
-}
-parser_range;
-
-typedef struct
-{
-	int red, green, blue;
-}
-parser_rgb;
-
-typedef struct
-{
-	GenericListRec list;
-	char *modes_identifier;
-	XF86ConfModeLinePtr mon_modeline_lst;
-	char *modes_comment;
-}
-XF86ConfModesRec, *XF86ConfModesPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *ml_modes_str;
-	XF86ConfModesPtr ml_modes;
-}
-XF86ConfModesLinkRec, *XF86ConfModesLinkPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *mon_identifier;
-	char *mon_vendor;
-	char *mon_modelname;
-	int mon_width;				/* in mm */
-	int mon_height;				/* in mm */
-	XF86ConfModeLinePtr mon_modeline_lst;
-	int mon_n_hsync;
-	parser_range mon_hsync[CONF_MAX_HSYNC];
-	int mon_n_vrefresh;
-	parser_range mon_vrefresh[CONF_MAX_VREFRESH];
-	float mon_gamma_red;
-	float mon_gamma_green;
-	float mon_gamma_blue;
-	XF86OptionPtr mon_option_lst;
-	XF86ConfModesLinkPtr mon_modes_sect_lst;
-	char *mon_comment;
-}
-XF86ConfMonitorRec, *XF86ConfMonitorPtr;
-
-#define CONF_MAXDACSPEEDS 4
-#define CONF_MAXCLOCKS    128
-
-typedef struct
-{
-	GenericListRec list;
-	char *dev_identifier;
-	char *dev_vendor;
-	char *dev_board;
-	char *dev_chipset;
-	char *dev_busid;
-	char *dev_card;
-	char *dev_driver;
-	char *dev_ramdac;
-	int dev_dacSpeeds[CONF_MAXDACSPEEDS];
-	int dev_videoram;
-	int dev_textclockfreq;
-	unsigned long dev_bios_base;
-	unsigned long dev_mem_base;
-	unsigned long dev_io_base;
-	char *dev_clockchip;
-	int dev_clocks;
-	int dev_clock[CONF_MAXCLOCKS];
-	int dev_chipid;
-	int dev_chiprev;
-	int dev_irq;
-	int dev_screen;
-	XF86OptionPtr dev_option_lst;
-	char *dev_comment;
-}
-XF86ConfDeviceRec, *XF86ConfDevicePtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *mode_name;
-}
-XF86ModeRec, *XF86ModePtr;
-
-typedef struct
-{
-	GenericListRec list;
-	int disp_frameX0;
-	int disp_frameY0;
-	int disp_virtualX;
-	int disp_virtualY;
-	int disp_depth;
-	int disp_bpp;
-	char *disp_visual;
-	parser_rgb disp_weight;
-	parser_rgb disp_black;
-	parser_rgb disp_white;
-	XF86ModePtr disp_mode_lst;
-	XF86OptionPtr disp_option_lst;
-	char *disp_comment;
-}
-XF86ConfDisplayRec, *XF86ConfDisplayPtr;
-
-typedef struct
-{
-	XF86OptionPtr flg_option_lst;
-	char *flg_comment;
-}
-XF86ConfFlagsRec, *XF86ConfFlagsPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *al_adaptor_str;
-	XF86ConfVideoAdaptorPtr al_adaptor;
-}
-XF86ConfAdaptorLinkRec, *XF86ConfAdaptorLinkPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *scrn_identifier;
-	char *scrn_obso_driver;
-	int scrn_defaultdepth;
-	int scrn_defaultbpp;
-	int scrn_defaultfbbpp;
-	char *scrn_monitor_str;
-	XF86ConfMonitorPtr scrn_monitor;
-	char *scrn_device_str;
-	XF86ConfDevicePtr scrn_device;
-	XF86ConfAdaptorLinkPtr scrn_adaptor_lst;
-	XF86ConfDisplayPtr scrn_display_lst;
-	XF86OptionPtr scrn_option_lst;
-	char *scrn_comment;
-	int scrn_virtualX, scrn_virtualY;
-}
-XF86ConfScreenRec, *XF86ConfScreenPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *inp_identifier;
-	char *inp_driver;
-	XF86OptionPtr inp_option_lst;
-	char *inp_comment;
-}
-XF86ConfInputRec, *XF86ConfInputPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	XF86ConfInputPtr iref_inputdev;
-	char *iref_inputdev_str;
-	XF86OptionPtr iref_option_lst;
-}
-XF86ConfInputrefRec, *XF86ConfInputrefPtr;
-
-typedef struct
-{
-	Bool set;
-	Bool val;
-}
-xf86TriState;
-
-typedef struct
-{
-	GenericListRec list;
-	char *identifier;
-	char *driver;
-	char **match_product;
-	char **match_vendor;
-	char **match_device;
-	char **match_tag;
-	xf86TriState is_keyboard;
-	xf86TriState is_pointer;
-	xf86TriState is_joystick;
-	xf86TriState is_tablet;
-	xf86TriState is_touchpad;
-	xf86TriState is_touchscreen;
-	XF86OptionPtr option_lst;
-	char *comment;
-}
-XF86ConfInputClassRec, *XF86ConfInputClassPtr;
-
-/* Values for adj_where */
-#define CONF_ADJ_OBSOLETE	-1
-#define CONF_ADJ_ABSOLUTE	0
-#define CONF_ADJ_RIGHTOF	1
-#define CONF_ADJ_LEFTOF		2
-#define CONF_ADJ_ABOVE		3
-#define CONF_ADJ_BELOW		4
-#define CONF_ADJ_RELATIVE	5
-
-typedef struct
-{
-	GenericListRec list;
-	int adj_scrnum;
-	XF86ConfScreenPtr adj_screen;
-	char *adj_screen_str;
-	XF86ConfScreenPtr adj_top;
-	char *adj_top_str;
-	XF86ConfScreenPtr adj_bottom;
-	char *adj_bottom_str;
-	XF86ConfScreenPtr adj_left;
-	char *adj_left_str;
-	XF86ConfScreenPtr adj_right;
-	char *adj_right_str;
-	int adj_where;
-	int adj_x;
-	int adj_y;
-	char *adj_refscreen;
-}
-XF86ConfAdjacencyRec, *XF86ConfAdjacencyPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *inactive_device_str;
-	XF86ConfDevicePtr inactive_device;
-}
-XF86ConfInactiveRec, *XF86ConfInactivePtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *lay_identifier;
-	XF86ConfAdjacencyPtr lay_adjacency_lst;
-	XF86ConfInactivePtr lay_inactive_lst;
-	XF86ConfInputrefPtr lay_input_lst;
-	XF86OptionPtr lay_option_lst;
-	char *lay_comment;
-}
-XF86ConfLayoutRec, *XF86ConfLayoutPtr;
-
-typedef struct 
-{ 
-	GenericListRec list; 
-	char *vs_name;
-	char *vs_identifier;
-	XF86OptionPtr vs_option_lst;
-	char *vs_comment;
-}
-XF86ConfVendSubRec, *XF86ConfVendSubPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	char *vnd_identifier;
-	XF86OptionPtr vnd_option_lst;
-	XF86ConfVendSubPtr vnd_sub_lst;
-	char *vnd_comment;
-}
-XF86ConfVendorRec, *XF86ConfVendorPtr;
-
-typedef struct
-{
-	GenericListRec list;
-	int buf_count;
-	int buf_size;
-	char *buf_flags;
-	char *buf_comment;
-}
-XF86ConfBuffersRec, *XF86ConfBuffersPtr;
-
-typedef struct
-{
-	char *dri_group_name;
-	int dri_group;
-	int dri_mode;
-	XF86ConfBuffersPtr dri_buffers_lst;
-	char *dri_comment;
-}
-XF86ConfDRIRec, *XF86ConfDRIPtr;
-
-typedef struct
-{
-	XF86OptionPtr ext_option_lst;
-	char *extensions_comment;
-}
-XF86ConfExtensionsRec, *XF86ConfExtensionsPtr;
-
-typedef struct
-{
-	XF86ConfFilesPtr conf_files;
-	XF86ConfModulePtr conf_modules;
-	XF86ConfFlagsPtr conf_flags;
-	XF86ConfVideoAdaptorPtr conf_videoadaptor_lst;
-	XF86ConfModesPtr conf_modes_lst;
-	XF86ConfMonitorPtr conf_monitor_lst;
-	XF86ConfDevicePtr conf_device_lst;
-	XF86ConfScreenPtr conf_screen_lst;
-	XF86ConfInputPtr conf_input_lst;
-	XF86ConfInputClassPtr conf_inputclass_lst;
-	XF86ConfLayoutPtr conf_layout_lst;
-	XF86ConfVendorPtr conf_vendor_lst;
-	XF86ConfDRIPtr conf_dri;
-	XF86ConfExtensionsPtr conf_extensions;
-	char *conf_comment;
-}
-XF86ConfigRec, *XF86ConfigPtr;
-
-typedef struct
-{
-	int token;			/* id of the token */
-	char *name;			/* pointer to the LOWERCASED name */
-}
-xf86ConfigSymTabRec, *xf86ConfigSymTabPtr;
-
-/*
- * prototypes for public functions
- */
-extern void xf86initConfigFiles(void);
-extern const char *xf86openConfigFile(const char *path, const char *cmdline,
-				      const char *projroot);
-extern const char *xf86openConfigDirFiles(const char *path, const char *cmdline,
-					  const char *projroot);
-extern void xf86setBuiltinConfig(const char *config[]);
-extern XF86ConfigPtr xf86readConfigFile(void);
-extern void xf86closeConfigFile(void);
-extern void xf86freeConfig(XF86ConfigPtr p);
-extern int xf86writeConfigFile(const char *, XF86ConfigPtr);
-extern _X_EXPORT XF86ConfDevicePtr xf86findDevice(const char *ident, XF86ConfDevicePtr p);
-extern _X_EXPORT XF86ConfLayoutPtr xf86findLayout(const char *name, XF86ConfLayoutPtr list);
-extern _X_EXPORT XF86ConfMonitorPtr xf86findMonitor(const char *ident, XF86ConfMonitorPtr p);
-extern _X_EXPORT XF86ConfModesPtr xf86findModes(const char *ident, XF86ConfModesPtr p);
-extern _X_EXPORT XF86ConfModeLinePtr xf86findModeLine(const char *ident, XF86ConfModeLinePtr p);
-extern _X_EXPORT XF86ConfScreenPtr xf86findScreen(const char *ident, XF86ConfScreenPtr p);
-extern _X_EXPORT XF86ConfInputPtr xf86findInput(const char *ident, XF86ConfInputPtr p);
-extern _X_EXPORT XF86ConfInputPtr xf86findInputByDriver(const char *driver, XF86ConfInputPtr p);
-extern _X_EXPORT XF86ConfVideoAdaptorPtr xf86findVideoAdaptor(const char *ident,
-						XF86ConfVideoAdaptorPtr p);
-extern int xf86layoutAddInputDevices(XF86ConfigPtr config, XF86ConfLayoutPtr layout);
-
-extern _X_EXPORT GenericListPtr xf86addListItem(GenericListPtr head, GenericListPtr c_new);
-extern _X_EXPORT int xf86itemNotSublist(GenericListPtr list_1, GenericListPtr list_2);
-
-extern _X_EXPORT int xf86pathIsAbsolute(const char *path);
-extern _X_EXPORT int xf86pathIsSafe(const char *path);
-extern _X_EXPORT char *xf86addComment(char *cur, char *add);
-extern _X_EXPORT Bool xf86getBoolValue(Bool *val, const char *str);
-
-#endif /* _xf86Parser_h_ */
+/* 

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+/* 

+ * This file contains the external interfaces for the XFree86 configuration

+ * file parser.

+ */

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#ifndef _xf86Parser_h_

+#define _xf86Parser_h_

+

+#include <X11/Xdefs.h>

+#include "xf86Optrec.h"

+#include "list.h"

+

+#define HAVE_PARSER_DECLS

+

+typedef struct

+{

+	char *file_logfile;

+	char *file_modulepath;

+	char *file_fontpath;

+	char *file_comment;

+	char *file_xkbdir;

+}

+XF86ConfFilesRec, *XF86ConfFilesPtr;

+

+/* Values for load_type */

+#define XF86_LOAD_MODULE	0

+#define XF86_LOAD_DRIVER	1

+#define XF86_DISABLE_MODULE	2

+

+typedef struct

+{

+	GenericListRec list;

+	int load_type;

+	char *load_name;

+	XF86OptionPtr load_opt;

+	char *load_comment;

+        int ignore;

+}

+XF86LoadRec, *XF86LoadPtr;

+

+typedef struct

+{

+	XF86LoadPtr mod_load_lst;

+    XF86LoadPtr mod_disable_lst;

+	char *mod_comment;

+}

+XF86ConfModuleRec, *XF86ConfModulePtr;

+

+#define CONF_IMPLICIT_KEYBOARD	"Implicit Core Keyboard"

+

+#define CONF_IMPLICIT_POINTER	"Implicit Core Pointer"

+

+#define XF86CONF_PHSYNC    0x0001

+#define XF86CONF_NHSYNC    0x0002

+#define XF86CONF_PVSYNC    0x0004

+#define XF86CONF_NVSYNC    0x0008

+#define XF86CONF_INTERLACE 0x0010

+#define XF86CONF_DBLSCAN   0x0020

+#define XF86CONF_CSYNC     0x0040

+#define XF86CONF_PCSYNC    0x0080

+#define XF86CONF_NCSYNC    0x0100

+#define XF86CONF_HSKEW     0x0200	/* hskew provided */

+#define XF86CONF_BCAST     0x0400

+#define XF86CONF_CUSTOM    0x0800	/* timing numbers customized by editor */

+#define XF86CONF_VSCAN     0x1000

+

+typedef struct

+{

+	GenericListRec list;

+	char *ml_identifier;

+	int ml_clock;

+	int ml_hdisplay;

+	int ml_hsyncstart;

+	int ml_hsyncend;

+	int ml_htotal;

+	int ml_vdisplay;

+	int ml_vsyncstart;

+	int ml_vsyncend;

+	int ml_vtotal;

+	int ml_vscan;

+	int ml_flags;

+	int ml_hskew;

+	char *ml_comment;

+}

+XF86ConfModeLineRec, *XF86ConfModeLinePtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *vp_identifier;

+	XF86OptionPtr vp_option_lst;

+	char *vp_comment;

+}

+XF86ConfVideoPortRec, *XF86ConfVideoPortPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *va_identifier;

+	char *va_vendor;

+	char *va_board;

+	char *va_busid;

+	char *va_driver;

+	XF86OptionPtr va_option_lst;

+	XF86ConfVideoPortPtr va_port_lst;

+	char *va_fwdref;

+	char *va_comment;

+}

+XF86ConfVideoAdaptorRec, *XF86ConfVideoAdaptorPtr;

+

+#define CONF_MAX_HSYNC 8

+#define CONF_MAX_VREFRESH 8

+

+typedef struct

+{

+	float hi, lo;

+}

+parser_range;

+

+typedef struct

+{

+	int red, green, blue;

+}

+parser_rgb;

+

+typedef struct

+{

+	GenericListRec list;

+	char *modes_identifier;

+	XF86ConfModeLinePtr mon_modeline_lst;

+	char *modes_comment;

+}

+XF86ConfModesRec, *XF86ConfModesPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *ml_modes_str;

+	XF86ConfModesPtr ml_modes;

+}

+XF86ConfModesLinkRec, *XF86ConfModesLinkPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *mon_identifier;

+	char *mon_vendor;

+	char *mon_modelname;

+	int mon_width;				/* in mm */

+	int mon_height;				/* in mm */

+	XF86ConfModeLinePtr mon_modeline_lst;

+	int mon_n_hsync;

+	parser_range mon_hsync[CONF_MAX_HSYNC];

+	int mon_n_vrefresh;

+	parser_range mon_vrefresh[CONF_MAX_VREFRESH];

+	float mon_gamma_red;

+	float mon_gamma_green;

+	float mon_gamma_blue;

+	XF86OptionPtr mon_option_lst;

+	XF86ConfModesLinkPtr mon_modes_sect_lst;

+	char *mon_comment;

+}

+XF86ConfMonitorRec, *XF86ConfMonitorPtr;

+

+#define CONF_MAXDACSPEEDS 4

+#define CONF_MAXCLOCKS    128

+

+typedef struct

+{

+	GenericListRec list;

+	char *dev_identifier;

+	char *dev_vendor;

+	char *dev_board;

+	char *dev_chipset;

+	char *dev_busid;

+	char *dev_card;

+	char *dev_driver;

+	char *dev_ramdac;

+	int dev_dacSpeeds[CONF_MAXDACSPEEDS];

+	int dev_videoram;

+	int dev_textclockfreq;

+	unsigned long dev_bios_base;

+	unsigned long dev_mem_base;

+	unsigned long dev_io_base;

+	char *dev_clockchip;

+	int dev_clocks;

+	int dev_clock[CONF_MAXCLOCKS];

+	int dev_chipid;

+	int dev_chiprev;

+	int dev_irq;

+	int dev_screen;

+	XF86OptionPtr dev_option_lst;

+	char *dev_comment;

+}

+XF86ConfDeviceRec, *XF86ConfDevicePtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *mode_name;

+}

+XF86ModeRec, *XF86ModePtr;

+

+typedef struct

+{

+	GenericListRec list;

+	int disp_frameX0;

+	int disp_frameY0;

+	int disp_virtualX;

+	int disp_virtualY;

+	int disp_depth;

+	int disp_bpp;

+	char *disp_visual;

+	parser_rgb disp_weight;

+	parser_rgb disp_black;

+	parser_rgb disp_white;

+	XF86ModePtr disp_mode_lst;

+	XF86OptionPtr disp_option_lst;

+	char *disp_comment;

+}

+XF86ConfDisplayRec, *XF86ConfDisplayPtr;

+

+typedef struct

+{

+	XF86OptionPtr flg_option_lst;

+	char *flg_comment;

+}

+XF86ConfFlagsRec, *XF86ConfFlagsPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *al_adaptor_str;

+	XF86ConfVideoAdaptorPtr al_adaptor;

+}

+XF86ConfAdaptorLinkRec, *XF86ConfAdaptorLinkPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *scrn_identifier;

+	char *scrn_obso_driver;

+	int scrn_defaultdepth;

+	int scrn_defaultbpp;

+	int scrn_defaultfbbpp;

+	char *scrn_monitor_str;

+	XF86ConfMonitorPtr scrn_monitor;

+	char *scrn_device_str;

+	XF86ConfDevicePtr scrn_device;

+	XF86ConfAdaptorLinkPtr scrn_adaptor_lst;

+	XF86ConfDisplayPtr scrn_display_lst;

+	XF86OptionPtr scrn_option_lst;

+	char *scrn_comment;

+	int scrn_virtualX, scrn_virtualY;

+}

+XF86ConfScreenRec, *XF86ConfScreenPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *inp_identifier;

+	char *inp_driver;

+	XF86OptionPtr inp_option_lst;

+	char *inp_comment;

+}

+XF86ConfInputRec, *XF86ConfInputPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	XF86ConfInputPtr iref_inputdev;

+	char *iref_inputdev_str;

+	XF86OptionPtr iref_option_lst;

+}

+XF86ConfInputrefRec, *XF86ConfInputrefPtr;

+

+typedef struct

+{

+	Bool set;

+	Bool val;

+}

+xf86TriState;

+

+typedef struct

+{

+	struct list entry;

+	char **values;

+}

+xf86MatchGroup;

+

+typedef struct

+{

+	GenericListRec list;

+	char *identifier;

+	char *driver;

+	struct list match_product;

+	struct list match_vendor;

+	struct list match_device;

+	struct list match_os;

+	struct list match_pnpid;

+	struct list match_usbid;

+	struct list match_driver;

+	struct list match_tag;

+	xf86TriState is_keyboard;

+	xf86TriState is_pointer;

+	xf86TriState is_joystick;

+	xf86TriState is_tablet;

+	xf86TriState is_touchpad;

+	xf86TriState is_touchscreen;

+	XF86OptionPtr option_lst;

+	char *comment;

+}

+XF86ConfInputClassRec, *XF86ConfInputClassPtr;

+

+/* Values for adj_where */

+#define CONF_ADJ_OBSOLETE	-1

+#define CONF_ADJ_ABSOLUTE	0

+#define CONF_ADJ_RIGHTOF	1

+#define CONF_ADJ_LEFTOF		2

+#define CONF_ADJ_ABOVE		3

+#define CONF_ADJ_BELOW		4

+#define CONF_ADJ_RELATIVE	5

+

+typedef struct

+{

+	GenericListRec list;

+	int adj_scrnum;

+	XF86ConfScreenPtr adj_screen;

+	char *adj_screen_str;

+	XF86ConfScreenPtr adj_top;

+	char *adj_top_str;

+	XF86ConfScreenPtr adj_bottom;

+	char *adj_bottom_str;

+	XF86ConfScreenPtr adj_left;

+	char *adj_left_str;

+	XF86ConfScreenPtr adj_right;

+	char *adj_right_str;

+	int adj_where;

+	int adj_x;

+	int adj_y;

+	char *adj_refscreen;

+}

+XF86ConfAdjacencyRec, *XF86ConfAdjacencyPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *inactive_device_str;

+	XF86ConfDevicePtr inactive_device;

+}

+XF86ConfInactiveRec, *XF86ConfInactivePtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *lay_identifier;

+	XF86ConfAdjacencyPtr lay_adjacency_lst;

+	XF86ConfInactivePtr lay_inactive_lst;

+	XF86ConfInputrefPtr lay_input_lst;

+	XF86OptionPtr lay_option_lst;

+	char *lay_comment;

+}

+XF86ConfLayoutRec, *XF86ConfLayoutPtr;

+

+typedef struct 

+{ 

+	GenericListRec list; 

+	char *vs_name;

+	char *vs_identifier;

+	XF86OptionPtr vs_option_lst;

+	char *vs_comment;

+}

+XF86ConfVendSubRec, *XF86ConfVendSubPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	char *vnd_identifier;

+	XF86OptionPtr vnd_option_lst;

+	XF86ConfVendSubPtr vnd_sub_lst;

+	char *vnd_comment;

+}

+XF86ConfVendorRec, *XF86ConfVendorPtr;

+

+typedef struct

+{

+	GenericListRec list;

+	int buf_count;

+	int buf_size;

+	char *buf_flags;

+	char *buf_comment;

+}

+XF86ConfBuffersRec, *XF86ConfBuffersPtr;

+

+typedef struct

+{

+	char *dri_group_name;

+	int dri_group;

+	int dri_mode;

+	XF86ConfBuffersPtr dri_buffers_lst;

+	char *dri_comment;

+}

+XF86ConfDRIRec, *XF86ConfDRIPtr;

+

+typedef struct

+{

+	XF86OptionPtr ext_option_lst;

+	char *extensions_comment;

+}

+XF86ConfExtensionsRec, *XF86ConfExtensionsPtr;

+

+typedef struct

+{

+	XF86ConfFilesPtr conf_files;

+	XF86ConfModulePtr conf_modules;

+	XF86ConfFlagsPtr conf_flags;

+	XF86ConfVideoAdaptorPtr conf_videoadaptor_lst;

+	XF86ConfModesPtr conf_modes_lst;

+	XF86ConfMonitorPtr conf_monitor_lst;

+	XF86ConfDevicePtr conf_device_lst;

+	XF86ConfScreenPtr conf_screen_lst;

+	XF86ConfInputPtr conf_input_lst;

+	XF86ConfInputClassPtr conf_inputclass_lst;

+	XF86ConfLayoutPtr conf_layout_lst;

+	XF86ConfVendorPtr conf_vendor_lst;

+	XF86ConfDRIPtr conf_dri;

+	XF86ConfExtensionsPtr conf_extensions;

+	char *conf_comment;

+}

+XF86ConfigRec, *XF86ConfigPtr;

+

+typedef struct

+{

+	int token;			/* id of the token */

+	char *name;			/* pointer to the LOWERCASED name */

+}

+xf86ConfigSymTabRec, *xf86ConfigSymTabPtr;

+

+/*

+ * prototypes for public functions

+ */

+extern void xf86initConfigFiles(void);

+extern const char *xf86openConfigFile(const char *path, const char *cmdline,

+				      const char *projroot);

+extern const char *xf86openConfigDirFiles(const char *path, const char *cmdline,

+					  const char *projroot);

+extern void xf86setBuiltinConfig(const char *config[]);

+extern XF86ConfigPtr xf86readConfigFile(void);

+extern void xf86closeConfigFile(void);

+extern void xf86freeConfig(XF86ConfigPtr p);

+extern int xf86writeConfigFile(const char *, XF86ConfigPtr);

+extern _X_EXPORT XF86ConfDevicePtr xf86findDevice(const char *ident, XF86ConfDevicePtr p);

+extern _X_EXPORT XF86ConfLayoutPtr xf86findLayout(const char *name, XF86ConfLayoutPtr list);

+extern _X_EXPORT XF86ConfMonitorPtr xf86findMonitor(const char *ident, XF86ConfMonitorPtr p);

+extern _X_EXPORT XF86ConfModesPtr xf86findModes(const char *ident, XF86ConfModesPtr p);

+extern _X_EXPORT XF86ConfModeLinePtr xf86findModeLine(const char *ident, XF86ConfModeLinePtr p);

+extern _X_EXPORT XF86ConfScreenPtr xf86findScreen(const char *ident, XF86ConfScreenPtr p);

+extern _X_EXPORT XF86ConfInputPtr xf86findInput(const char *ident, XF86ConfInputPtr p);

+extern _X_EXPORT XF86ConfInputPtr xf86findInputByDriver(const char *driver, XF86ConfInputPtr p);

+extern _X_EXPORT XF86ConfVideoAdaptorPtr xf86findVideoAdaptor(const char *ident,

+						XF86ConfVideoAdaptorPtr p);

+extern int xf86layoutAddInputDevices(XF86ConfigPtr config, XF86ConfLayoutPtr layout);

+

+extern _X_EXPORT GenericListPtr xf86addListItem(GenericListPtr head, GenericListPtr c_new);

+extern _X_EXPORT int xf86itemNotSublist(GenericListPtr list_1, GenericListPtr list_2);

+

+extern _X_EXPORT int xf86pathIsAbsolute(const char *path);

+extern _X_EXPORT int xf86pathIsSafe(const char *path);

+extern _X_EXPORT char *xf86addComment(char *cur, char *add);

+extern _X_EXPORT Bool xf86getBoolValue(Bool *val, const char *str);

+

+#endif /* _xf86Parser_h_ */

diff --git a/xorg-server/hw/xfree86/parser/xf86tokens.h b/xorg-server/hw/xfree86/parser/xf86tokens.h
index cb600704b..3bea43d15 100644
--- a/xorg-server/hw/xfree86/parser/xf86tokens.h
+++ b/xorg-server/hw/xfree86/parser/xf86tokens.h
@@ -1,291 +1,295 @@
-/* 
- * 
- * Copyright (c) 1997  Metro Link Incorporated
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- * Except as contained in this notice, the name of the Metro Link shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from Metro Link.
- * 
- */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#ifndef _xf86_tokens_h
-#define _xf86_tokens_h
-
-/* Undefine symbols that some OSs might define */
-#undef IOBASE
-
-/* 
- * Each token should have a unique value regardless of the section
- * it is used in.
- */
-
-typedef enum {
-    /* errno-style tokens */
-    OBSOLETE_TOKEN	= -5,
-    EOF_TOKEN		= -4,
-    LOCK_TOKEN		= -3,
-    ERROR_TOKEN		= -2,
-
-    /* value type tokens */
-    NUMBER		= 1,
-    STRING,
-
-    /* Tokens that can appear in many sections */
-    SECTION,
-    SUBSECTION,
-    ENDSECTION,
-    ENDSUBSECTION,
-    IDENTIFIER,
-    VENDOR,
-    DASH,
-    COMMA,
-    OPTION,
-    COMMENT,
-
-    /* Frequency units */
-    HRZ,
-    KHZ,
-    MHZ,
-
-    /* File tokens */
-    FONTPATH,
-    MODULEPATH,
-    LOGFILEPATH,
-    XKBDIR,
-
-    /* Server Flag tokens.  These are deprecated in favour of generic Options */
-    NOTRAPSIGNALS,
-    DONTZAP,
-    DONTZOOM,
-    DISABLEVIDMODE,
-    ALLOWNONLOCAL,
-    DISABLEMODINDEV,
-    MODINDEVALLOWNONLOCAL,
-    ALLOWMOUSEOPENFAIL,
-    BLANKTIME,
-    STANDBYTIME,
-    SUSPENDTIME,
-    OFFTIME,
-    DEFAULTLAYOUT,
-
-    /* Monitor tokens */
-    MODEL,
-    MODELINE,
-    DISPLAYSIZE,
-    HORIZSYNC,
-    VERTREFRESH,
-    MODE,
-    GAMMA,
-    USEMODES,
-
-    /* Modes tokens */
-    /* no new ones */
-
-    /* Mode tokens */
-    DOTCLOCK,
-    HTIMINGS,
-    VTIMINGS,
-    FLAGS,
-    HSKEW,
-    BCAST,
-    VSCAN,
-    ENDMODE,
-
-    /* Screen tokens */
-    OBSDRIVER,
-    MDEVICE,
-    MONITOR,
-    SCREENNO,
-    DEFAULTDEPTH,
-    DEFAULTBPP,
-    DEFAULTFBBPP,
-    
-    /* VideoAdaptor tokens */
-    VIDEOADAPTOR,
-
-    /* Mode timing tokens */
-    TT_INTERLACE,
-    TT_PHSYNC,
-    TT_NHSYNC,
-    TT_PVSYNC,
-    TT_NVSYNC,
-    TT_CSYNC,
-    TT_PCSYNC,
-    TT_NCSYNC,
-    TT_DBLSCAN,
-    TT_HSKEW,
-    TT_BCAST,
-    TT_VSCAN,
-    TT_CUSTOM,
-
-    /* Module tokens */
-    LOAD,
-    LOAD_DRIVER,
-    DISABLE,
-    
-    /* Device tokens */
-    DRIVER,
-    CHIPSET,
-    CLOCKS,
-    VIDEORAM,
-    BOARD,
-    IOBASE,
-    RAMDAC,
-    DACSPEED,
-    BIOSBASE,
-    MEMBASE,
-    CLOCKCHIP,
-    CHIPID,
-    CHIPREV,
-    CARD,
-    BUSID,
-    TEXTCLOCKFRQ,
-    IRQ,
-
-    /* Keyboard tokens */
-    AUTOREPEAT,
-    XLEDS,
-    KPROTOCOL,
-    XKBKEYMAP,
-    XKBCOMPAT,
-    XKBTYPES,
-    XKBKEYCODES,
-    XKBGEOMETRY,
-    XKBSYMBOLS,
-    XKBDISABLE,
-    PANIX106,
-    XKBRULES,
-    XKBMODEL,
-    XKBLAYOUT,
-    XKBVARIANT,
-    XKBOPTIONS,
-    /* The next two have become ServerFlags options */
-    VTSYSREQ,
-    /* Obsolete keyboard tokens */
-    SERVERNUM,
-    LEFTALT,
-    RIGHTALT,
-    SCROLLLOCK_TOK,
-    RIGHTCTL,
-    /* arguments for the above obsolete tokens */
-    CONF_KM_META,
-    CONF_KM_COMPOSE,
-    CONF_KM_MODESHIFT,
-    CONF_KM_MODELOCK,
-    CONF_KM_SCROLLLOCK,
-    CONF_KM_CONTROL,
-
-    /* Pointer tokens */
-    EMULATE3,
-    BAUDRATE,
-    SAMPLERATE,
-    PRESOLUTION,
-    CLEARDTR,
-    CLEARRTS,
-    CHORDMIDDLE,
-    PROTOCOL,
-    PDEVICE,
-    EM3TIMEOUT,
-    DEVICE_NAME,
-    ALWAYSCORE,
-    PBUTTONS,
-    ZAXISMAPPING,
-
-    /* Pointer Z axis mapping tokens */
-    XAXIS,
-    YAXIS,
-
-    /* Display tokens */
-    MODES,
-    VIEWPORT,
-    VIRTUAL,
-    VISUAL,
-    BLACK_TOK,
-    WHITE_TOK,
-    DEPTH,
-    BPP,
-    WEIGHT,
-    
-    /* Layout Tokens */
-    SCREEN,
-    INACTIVE,
-    INPUTDEVICE,
-
-    /* Adjaceny Tokens */
-    RIGHTOF,
-    LEFTOF,
-    ABOVE,
-    BELOW,
-    RELATIVE,
-    ABSOLUTE,
-
-    /* Vendor Tokens */
-    VENDORNAME,
-
-    /* DRI Tokens */
-    GROUP,
-    BUFFERS,
-
-    /* InputClass Tokens */
-    MATCH_PRODUCT,
-    MATCH_VENDOR,
-    MATCH_DEVICE_PATH,
-    MATCH_TAG,
-    MATCH_IS_KEYBOARD,
-    MATCH_IS_POINTER,
-    MATCH_IS_JOYSTICK,
-    MATCH_IS_TABLET,
-    MATCH_IS_TOUCHPAD,
-    MATCH_IS_TOUCHSCREEN
-} ParserTokens;
-
-#endif /* _xf86_tokens_h */
+/* 

+ * 

+ * Copyright (c) 1997  Metro Link Incorporated

+ * 

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ * 

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * 

+ * Except as contained in this notice, the name of the Metro Link shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from Metro Link.

+ * 

+ */

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

+ * OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the copyright holder(s)

+ * and author(s) shall not be used in advertising or otherwise to promote

+ * the sale, use or other dealings in this Software without prior written

+ * authorization from the copyright holder(s) and author(s).

+ */

+

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#ifndef _xf86_tokens_h

+#define _xf86_tokens_h

+

+/* Undefine symbols that some OSs might define */

+#undef IOBASE

+

+/* 

+ * Each token should have a unique value regardless of the section

+ * it is used in.

+ */

+

+typedef enum {

+    /* errno-style tokens */

+    OBSOLETE_TOKEN	= -5,

+    EOF_TOKEN		= -4,

+    LOCK_TOKEN		= -3,

+    ERROR_TOKEN		= -2,

+

+    /* value type tokens */

+    NUMBER		= 1,

+    STRING,

+

+    /* Tokens that can appear in many sections */

+    SECTION,

+    SUBSECTION,

+    ENDSECTION,

+    ENDSUBSECTION,

+    IDENTIFIER,

+    VENDOR,

+    DASH,

+    COMMA,

+    OPTION,

+    COMMENT,

+

+    /* Frequency units */

+    HRZ,

+    KHZ,

+    MHZ,

+

+    /* File tokens */

+    FONTPATH,

+    MODULEPATH,

+    LOGFILEPATH,

+    XKBDIR,

+

+    /* Server Flag tokens.  These are deprecated in favour of generic Options */

+    NOTRAPSIGNALS,

+    DONTZAP,

+    DONTZOOM,

+    DISABLEVIDMODE,

+    ALLOWNONLOCAL,

+    DISABLEMODINDEV,

+    MODINDEVALLOWNONLOCAL,

+    ALLOWMOUSEOPENFAIL,

+    BLANKTIME,

+    STANDBYTIME,

+    SUSPENDTIME,

+    OFFTIME,

+    DEFAULTLAYOUT,

+

+    /* Monitor tokens */

+    MODEL,

+    MODELINE,

+    DISPLAYSIZE,

+    HORIZSYNC,

+    VERTREFRESH,

+    MODE,

+    GAMMA,

+    USEMODES,

+

+    /* Modes tokens */

+    /* no new ones */

+

+    /* Mode tokens */

+    DOTCLOCK,

+    HTIMINGS,

+    VTIMINGS,

+    FLAGS,

+    HSKEW,

+    BCAST,

+    VSCAN,

+    ENDMODE,

+

+    /* Screen tokens */

+    OBSDRIVER,

+    MDEVICE,

+    MONITOR,

+    SCREENNO,

+    DEFAULTDEPTH,

+    DEFAULTBPP,

+    DEFAULTFBBPP,

+    

+    /* VideoAdaptor tokens */

+    VIDEOADAPTOR,

+

+    /* Mode timing tokens */

+    TT_INTERLACE,

+    TT_PHSYNC,

+    TT_NHSYNC,

+    TT_PVSYNC,

+    TT_NVSYNC,

+    TT_CSYNC,

+    TT_PCSYNC,

+    TT_NCSYNC,

+    TT_DBLSCAN,

+    TT_HSKEW,

+    TT_BCAST,

+    TT_VSCAN,

+    TT_CUSTOM,

+

+    /* Module tokens */

+    LOAD,

+    LOAD_DRIVER,

+    DISABLE,

+    

+    /* Device tokens */

+    DRIVER,

+    CHIPSET,

+    CLOCKS,

+    VIDEORAM,

+    BOARD,

+    IOBASE,

+    RAMDAC,

+    DACSPEED,

+    BIOSBASE,

+    MEMBASE,

+    CLOCKCHIP,

+    CHIPID,

+    CHIPREV,

+    CARD,

+    BUSID,

+    TEXTCLOCKFRQ,

+    IRQ,

+

+    /* Keyboard tokens */

+    AUTOREPEAT,

+    XLEDS,

+    KPROTOCOL,

+    XKBKEYMAP,

+    XKBCOMPAT,

+    XKBTYPES,

+    XKBKEYCODES,

+    XKBGEOMETRY,

+    XKBSYMBOLS,

+    XKBDISABLE,

+    PANIX106,

+    XKBRULES,

+    XKBMODEL,

+    XKBLAYOUT,

+    XKBVARIANT,

+    XKBOPTIONS,

+    /* The next two have become ServerFlags options */

+    VTSYSREQ,

+    /* Obsolete keyboard tokens */

+    SERVERNUM,

+    LEFTALT,

+    RIGHTALT,

+    SCROLLLOCK_TOK,

+    RIGHTCTL,

+    /* arguments for the above obsolete tokens */

+    CONF_KM_META,

+    CONF_KM_COMPOSE,

+    CONF_KM_MODESHIFT,

+    CONF_KM_MODELOCK,

+    CONF_KM_SCROLLLOCK,

+    CONF_KM_CONTROL,

+

+    /* Pointer tokens */

+    EMULATE3,

+    BAUDRATE,

+    SAMPLERATE,

+    PRESOLUTION,

+    CLEARDTR,

+    CLEARRTS,

+    CHORDMIDDLE,

+    PROTOCOL,

+    PDEVICE,

+    EM3TIMEOUT,

+    DEVICE_NAME,

+    ALWAYSCORE,

+    PBUTTONS,

+    ZAXISMAPPING,

+

+    /* Pointer Z axis mapping tokens */

+    XAXIS,

+    YAXIS,

+

+    /* Display tokens */

+    MODES,

+    VIEWPORT,

+    VIRTUAL,

+    VISUAL,

+    BLACK_TOK,

+    WHITE_TOK,

+    DEPTH,

+    BPP,

+    WEIGHT,

+    

+    /* Layout Tokens */

+    SCREEN,

+    INACTIVE,

+    INPUTDEVICE,

+

+    /* Adjaceny Tokens */

+    RIGHTOF,

+    LEFTOF,

+    ABOVE,

+    BELOW,

+    RELATIVE,

+    ABSOLUTE,

+

+    /* Vendor Tokens */

+    VENDORNAME,

+

+    /* DRI Tokens */

+    GROUP,

+    BUFFERS,

+

+    /* InputClass Tokens */

+    MATCH_PRODUCT,

+    MATCH_VENDOR,

+    MATCH_DEVICE_PATH,

+    MATCH_OS,

+    MATCH_PNPID,

+    MATCH_USBID,

+    MATCH_DRIVER,

+    MATCH_TAG,

+    MATCH_IS_KEYBOARD,

+    MATCH_IS_POINTER,

+    MATCH_IS_JOYSTICK,

+    MATCH_IS_TABLET,

+    MATCH_IS_TOUCHPAD,

+    MATCH_IS_TOUCHSCREEN

+} ParserTokens;

+

+#endif /* _xf86_tokens_h */

diff --git a/xorg-server/hw/xfree86/ramdac/IBM.c b/xorg-server/hw/xfree86/ramdac/IBM.c
index 2d9fe4d8f..3a477d7be 100644
--- a/xorg-server/hw/xfree86/ramdac/IBM.c
+++ b/xorg-server/hw/xfree86/ramdac/IBM.c
@@ -1,639 +1,639 @@
-/*
- * Copyright 1998 by Alan Hourihane, Wigan, England.
- *
- * 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 Alan Hourihane not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Alan Hourihane makes no representations
- * about the suitability of this software for any purpose.  It is provided
- * "as is" without express or implied warranty.
- *
- * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL ALAN HOURIHANE 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.
- *
- * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>
- *
- * IBM RAMDAC routines.
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include "xf86Cursor.h"
-
-#define INIT_IBM_RAMDAC_INFO
-#include "IBMPriv.h"
-#include "xf86RamDacPriv.h"
-
-#define INITIALFREQERR 100000
-
-unsigned long
-IBMramdac640CalculateMNPCForClock(
-    unsigned long RefClock,	/* In 100Hz units */
-    unsigned long ReqClock,	/* In 100Hz units */
-    char IsPixClock,	/* boolean, is this the pixel or the sys clock */
-    unsigned long MinClock,	/* Min VCO rating */
-    unsigned long MaxClock,	/* Max VCO rating */
-    unsigned long *rM,	/* M Out */
-    unsigned long *rN,	/* N Out */
-    unsigned long *rP,	/* Min P In, P Out */
-    unsigned long *rC	/* C Out */
-)
-{
-  unsigned long   M, N, P, iP = *rP;
-  unsigned long   IntRef, VCO, Clock;
-  long            freqErr, lowestFreqErr = INITIALFREQERR;
-  unsigned long   ActualClock = 0;
-
-  for (N = 0; N <= 63; N++)
-    {
-      IntRef = RefClock / (N + 1);
-      if (IntRef < 10000)
-	break;			/* IntRef needs to be >= 1MHz */
-      for (M = 2; M <= 127; M++)
-	{
-	  VCO = IntRef * (M + 1);
-	  if ((VCO < MinClock) || (VCO > MaxClock))
-	    continue;
-	  for (P = iP; P <= 4; P++)
-	    {
-	      if (P != 0)
-		Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);
-	      else
-		Clock = (RefClock * (M + 1)) / (N + 1);
-
-	      freqErr = (Clock - ReqClock);
-
-	      if (freqErr < 0)
-		{
-		  /* PixelClock gets rounded up always so monitor reports
-		     correct frequency. */
-		  if (IsPixClock)
-		    continue;
-		  freqErr = -freqErr;
-		}
-
-	      if (freqErr < lowestFreqErr)
-		{
-		  *rM = M;
-		  *rN = N;
-		  *rP = P;
-		  *rC = (VCO <= 1280000 ? 1 : 2);
-		  ActualClock = Clock;
-
-		  lowestFreqErr = freqErr;
-		  /* Return if we found an exact match */
-		  if (freqErr == 0)
-		    return (ActualClock);
-		}
-	    }
-	}
-    }
-
-  return (ActualClock);
-}
-
-unsigned long
-IBMramdac526CalculateMNPCForClock(
-    unsigned long RefClock,	/* In 100Hz units */
-    unsigned long ReqClock,	/* In 100Hz units */
-    char IsPixClock,	/* boolean, is this the pixel or the sys clock */
-    unsigned long MinClock,	/* Min VCO rating */
-    unsigned long MaxClock,	/* Max VCO rating */
-    unsigned long *rM,	/* M Out */
-    unsigned long *rN,	/* N Out */
-    unsigned long *rP,	/* Min P In, P Out */
-    unsigned long *rC	/* C Out */
-)
-{
-  unsigned long   M, N, P, iP = *rP;
-  unsigned long   IntRef, VCO, Clock;
-  long            freqErr, lowestFreqErr = INITIALFREQERR;
-  unsigned long   ActualClock = 0;
-
-  for (N = 0; N <= 63; N++)
-    {
-      IntRef = RefClock / (N + 1);
-      if (IntRef < 10000)
-	break;			/* IntRef needs to be >= 1MHz */
-      for (M = 0; M <= 63; M++)
-	{
-	  VCO = IntRef * (M + 1);
-	  if ((VCO < MinClock) || (VCO > MaxClock))
-	    continue;
-	  for (P = iP; P <= 4; P++)
-	    {
-	      if (P)
-		Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);
-	      else
-		Clock = VCO;
-
-	      freqErr = (Clock - ReqClock);
-
-	      if (freqErr < 0)
-		{
-		  /* PixelClock gets rounded up always so monitor reports
-		     correct frequency. */
-		  if (IsPixClock)
-		    continue;
-		  freqErr = -freqErr;
-		}
-
-	      if (freqErr < lowestFreqErr)
-		{
-		  *rM = M;
-		  *rN = N;
-		  *rP = P;
-		  *rC = (VCO <= 1280000 ? 1 : 2);
-		  ActualClock = Clock;
-
-		  lowestFreqErr = freqErr;
-		  /* Return if we found an exact match */
-		  if (freqErr == 0)
-		    return (ActualClock);
-		}
-	    }
-	}
-    }
-
-  return (ActualClock);
-}
-
-void
-IBMramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
-				    RamDacRegRecPtr ramdacReg)
-{
-	int i, maxreg, dacreg;
-
-	switch (ramdacPtr->RamDacType) {
-	    case IBM640_RAMDAC:
-		maxreg = 0x300;
-		dacreg = 1024;
-		break;
-	    default:
-		maxreg = 0x100;
-		dacreg = 768;
-		break;
-	}
-
-	/* Here we pass a short, so that we can evaluate a mask too */
-	/* So that the mask is the high byte and the data the low byte */
-	for (i=0;i<maxreg;i++) 
-	    (*ramdacPtr->WriteDAC)
-	        (pScrn, i, (ramdacReg->DacRegs[i] & 0xFF00) >> 8, 
-						ramdacReg->DacRegs[i]);
-
-	(*ramdacPtr->WriteAddress)(pScrn, 0);
-	for (i=0;i<dacreg;i++)
-	    	(*ramdacPtr->WriteData)(pScrn, ramdacReg->DAC[i]);
-}
-
-void
-IBMramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr, 
-				 RamDacRegRecPtr ramdacReg)
-{
-	int i, maxreg, dacreg;
-
-	switch (ramdacPtr->RamDacType) {
-	    case IBM640_RAMDAC:
-		maxreg = 0x300;
-		dacreg = 1024;
-		break;
-	    default:
-		maxreg = 0x100;
-		dacreg = 768;
-		break;
-	}
-	
-	(*ramdacPtr->ReadAddress)(pScrn, 0);
-	for (i=0;i<dacreg;i++)
-	    ramdacReg->DAC[i] = (*ramdacPtr->ReadData)(pScrn);
-
-	for (i=0;i<maxreg;i++) 
-	    ramdacReg->DacRegs[i] = (*ramdacPtr->ReadDAC)(pScrn, i);
-}
-
-RamDacHelperRecPtr
-IBMramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs/* , RamDacRecPtr ramdacPtr*/)
-{
-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-    RamDacHelperRecPtr ramdacHelperPtr = NULL;
-    Bool RamDacIsSupported = FALSE;
-    int IBMramdac_ID = -1;
-    int i;
-    unsigned char id, rev, id2, rev2;
-
-    /* read ID and revision */
-    rev = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_rev);
-    id = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_id);
-
-    /* check if ID and revision are read only */
-    (*ramdacPtr->WriteDAC)(pScrn, ~rev, 0, IBMRGB_rev);
-    (*ramdacPtr->WriteDAC)(pScrn, ~id, 0, IBMRGB_id);
-    rev2 = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_rev);
-    id2 = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_id);
-
-    switch (id) {
-	case 0x30:
-		if (rev == 0xc0) IBMramdac_ID = IBM624_RAMDAC;
-		if (rev == 0x80) IBMramdac_ID = IBM624DB_RAMDAC;
-		break;
-	case 0x12:
-		if (rev == 0x1c) IBMramdac_ID = IBM640_RAMDAC;
-		break;
-	case 0x01:
-		IBMramdac_ID = IBM525_RAMDAC;
-		break;
-	case 0x02:
-		if (rev == 0xf0) IBMramdac_ID = IBM524_RAMDAC;
-		if (rev == 0xe0) IBMramdac_ID = IBM524A_RAMDAC;
-		if (rev == 0xc0) IBMramdac_ID = IBM526_RAMDAC;
-		if (rev == 0x80) IBMramdac_ID = IBM526DB_RAMDAC;
-		break;
-    }
-
-    if (id == 1 || id == 2) {
-        if (id == id2 && rev == rev2) {		/* IBM RGB52x found */
-	    /* check for 128bit VRAM -> RGB528 */
-	    if (((*ramdacPtr->ReadDAC)(pScrn, IBMRGB_misc1) & 0x03) == 0x03) {
-	        IBMramdac_ID = IBM528_RAMDAC;	/* 128bit DAC found */
-	        if (rev == 0xe0)
-		    IBMramdac_ID = IBM528A_RAMDAC;
-	    }
-        }
-    }
-
-    (*ramdacPtr->WriteDAC)(pScrn, rev, 0, IBMRGB_rev);
-    (*ramdacPtr->WriteDAC)(pScrn, id, 0, IBMRGB_id);
-
-    if (IBMramdac_ID == -1) {
-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-		"Cannot determine IBM RAMDAC type, aborting\n");
-	return NULL;
-    } else {
-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-		"Attached RAMDAC is %s\n", IBMramdacDeviceInfo[IBMramdac_ID&0xFFFF].DeviceName);
-    }
-
-    for (i=0;ramdacs[i].token != -1;i++) {
-	if (ramdacs[i].token == IBMramdac_ID)
-	    RamDacIsSupported = TRUE;
-    }
-
-    if (!RamDacIsSupported) {
-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-		"This IBM RAMDAC is NOT supported by this driver, aborting\n");
-	return NULL;
-    }
-
-    ramdacHelperPtr = RamDacHelperCreateInfoRec();
-    switch (IBMramdac_ID) {
-	case IBM526_RAMDAC:
-	case IBM526DB_RAMDAC:
- 	    ramdacHelperPtr->SetBpp = IBMramdac526SetBpp;
-    	    ramdacHelperPtr->HWCursorInit = IBMramdac526HWCursorInit;
-	    break;
-	case IBM640_RAMDAC:
- 	    ramdacHelperPtr->SetBpp = IBMramdac640SetBpp;
-    	    ramdacHelperPtr->HWCursorInit = IBMramdac640HWCursorInit;
-	    break;
-    }
-    ramdacPtr->RamDacType = IBMramdac_ID;
-    ramdacHelperPtr->RamDacType = IBMramdac_ID;
-    ramdacHelperPtr->Save = IBMramdacSave;
-    ramdacHelperPtr->Restore = IBMramdacRestore;
-
-    return ramdacHelperPtr;
-}
-
-void
-IBMramdac526SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
-{
-    ramdacReg->DacRegs[IBMRGB_key_control] = 0x00; /* Disable Chroma Key */
-
-    switch (pScrn->bitsPerPixel) {
-	case 32:
-	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_32BPP;
-	    ramdacReg->DacRegs[IBMRGB_32bpp] = B32_DCOL_DIRECT;
-	    ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
-	    if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
-		ramdacReg->DacRegs[IBMRGB_key_control] = 0x01; /* Enable Key */
-		ramdacReg->DacRegs[IBMRGB_key] = 0xFF; 
-		ramdacReg->DacRegs[IBMRGB_key_mask] = 0xFF;
-	    }
-	    break;
-	case 24:
-	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_24BPP;
-	    ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_24bpp] = B24_DCOL_DIRECT;
-	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
-	    break;
-	case 16:
-	    if (pScrn->depth == 16) {
-	        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;
-	        ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
-	        ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
-	        ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT|B16_LINEAR |
-					           B16_CONTIGUOUS | B16_565;
-	        ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
-	    } else {
-	        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;
-	        ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
-	        ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
-	        ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT|B16_LINEAR |
-					           B16_CONTIGUOUS | B16_555;
-	        ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
-	    }
-	    break;
-	case 8:
-	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_8BPP;
-	    ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_8bpp] = B8_DCOL_INDIRECT;
-	    break;
-	case 4:
-	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_4BPP;
-	    ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
-	    ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
-    }
-}
-
-IBMramdac526SetBppProc *IBMramdac526SetBppWeak(void) {
-    return IBMramdac526SetBpp;
-}
-
-void
-IBMramdac640SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
-{
-    unsigned char bpp = 0x00;
-    unsigned char overlaybpp = 0x00;
-    unsigned char offset = 0x00;
-    unsigned char dispcont = 0x44;
-
-    ramdacReg->DacRegs[RGB640_SER_WID_03_00] = 0x00;
-    ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x00;
-    ramdacReg->DacRegs[RGB640_DIAGS] = 0x07;
-
-    switch (pScrn->depth) {
-	case 8:
-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x00; 
-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x00;
-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;
-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;
-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_16_1; /*16:1 Mux*/
-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */
-	    bpp = 0x03;
-	    break;
-	case 15:
-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;
-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;
-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;
-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;
-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1; /* 8:1 Mux*/
-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */
-	    bpp = 0x0E;
-	    break;
-	case 16:
-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;
-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;
-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;
-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;
-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1; /* 8:1 Mux*/
-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */
-	    bpp = 0x05;
-	    break;
-	case 24:
-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30; 
-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;
-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;
-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;
-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1; /* 4:1 Mux*/
-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */
-	    bpp = 0x09;
-	    if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
-		ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x04;
-		ramdacReg->DacRegs[RGB640_CHROMA_KEY0] = 0xFF;
-		ramdacReg->DacRegs[RGB640_CHROMA_MASK0] = 0xFF;
-		offset = 0x04;
-		overlaybpp = 0x04;
-		dispcont = 0x48;
-	    }
-	    break;
-	case 30: /* 10 bit dac */
-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30; 
-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;
-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;
-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;
-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1; /* 4:1 Mux*/
-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PSIZE10 | 
-						   IBM640_PCLK_8; /* pll / 8 */
-	    bpp = 0x0D;
-	    break;
-    }
-	
-    { 
-	int i;
-    	for (i=0x100;i<0x140;i+=4) {
-	    /* Initialize FrameBuffer Window Attribute Table */
-	    ramdacReg->DacRegs[i+0] = bpp;
-	    ramdacReg->DacRegs[i+1] = offset;
-	    ramdacReg->DacRegs[i+2] = 0x00;
-	    ramdacReg->DacRegs[i+3] = 0x00;
-	    /* Initialize Overlay Window Attribute Table */
-	    ramdacReg->DacRegs[i+0x100] = overlaybpp;
-	    ramdacReg->DacRegs[i+0x101] = 0x00;
-	    ramdacReg->DacRegs[i+0x102] = 0x00;
-	    ramdacReg->DacRegs[i+0x103] = dispcont;
-        }
-    }
-}
-
-static void 
-IBMramdac526ShowCursor(ScrnInfoPtr pScrn)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-   /* Enable cursor - X11 mode */
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs, 0x00, 0x07);
-}
-
-static void 
-IBMramdac640ShowCursor(ScrnInfoPtr pScrn)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-   /* Enable cursor - mode2 (x11 mode) */
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x0B);
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CROSSHAIR_CONTROL, 0x00, 0x00);
-}
-
-static void
-IBMramdac526HideCursor(ScrnInfoPtr pScrn)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-   /* Disable cursor - X11 mode */
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs, 0x00, 0x24);
-}
-
-static void
-IBMramdac640HideCursor(ScrnInfoPtr pScrn)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-   /* Disable cursor - mode2 (x11 mode) */
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x08);
-}
-
-static void
-IBMramdac526SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-   x += 64;
-   y += 64;
-
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_hot_x, 0x00, 0x3f);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_hot_y, 0x00, 0x3f);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_xl, 0x00, x & 0xff);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_xh, 0x00, (x>>8) & 0xf);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_yl, 0x00, y & 0xff);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_yh, 0x00, (y>>8) & 0xf);
-}
-
-static void
-IBMramdac640SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-   x += 64;
-   y += 64;
-
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_OFFSETX, 0x00, 0x3f);
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_OFFSETY, 0x00, 0x3f);
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_X_LOW, 0x00, x & 0xff);
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_X_HIGH, 0x00, (x>>8) & 0xf);
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_Y_LOW, 0x00, y & 0xff);
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_Y_HIGH, 0x00, (y>>8) & 0xf);
-}
-
-static void
-IBMramdac526SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col1_r, 0x00, bg >> 16);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col1_g, 0x00, bg >> 8);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col1_b, 0x00, bg);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col2_r, 0x00, fg >> 16);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col2_g, 0x00, fg >> 8);
-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col2_b, 0x00, fg);
-}
-
-static void
-IBMramdac640SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-  
-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_COL0, 0x00, 0);
-   (*ramdacPtr->WriteData)(pScrn, fg>>16);
-   (*ramdacPtr->WriteData)(pScrn, fg>>8);
-   (*ramdacPtr->WriteData)(pScrn, fg);
-   (*ramdacPtr->WriteData)(pScrn, bg>>16);
-   (*ramdacPtr->WriteData)(pScrn, bg>>8);
-   (*ramdacPtr->WriteData)(pScrn, bg);
-   (*ramdacPtr->WriteData)(pScrn, fg>>16);
-   (*ramdacPtr->WriteData)(pScrn, fg>>8);
-   (*ramdacPtr->WriteData)(pScrn, fg);
-   (*ramdacPtr->WriteData)(pScrn, bg>>16);
-   (*ramdacPtr->WriteData)(pScrn, bg>>8);
-   (*ramdacPtr->WriteData)(pScrn, bg);
-}
-
-static void 
-IBMramdac526LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-   int i;
-   /* 
-    * Output the cursor data.  The realize function has put the planes into
-    * their correct order, so we can just blast this out.
-    */
-   for (i = 0; i < 1024; i++)
-      (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_array + i, 0x00, (*src++));
-}
-
-static void 
-IBMramdac640LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
-{
-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-   int i;
-   /* 
-    * Output the cursor data.  The realize function has put the planes into
-    * their correct order, so we can just blast this out.
-    */
-   for (i = 0; i < 1024; i++)
-      (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_WRITE + i, 0x00, (*src++));
-}
-
-static Bool 
-IBMramdac526UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)
-{
-    return TRUE;
-}
-
-static Bool 
-IBMramdac640UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)
-{
-    return TRUE;
-}
-
-void
-IBMramdac526HWCursorInit(xf86CursorInfoPtr infoPtr)
-{
-    infoPtr->MaxWidth = 64;
-    infoPtr->MaxHeight = 64;
-    infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
-		     HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |
-		     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;
-    infoPtr->SetCursorColors = IBMramdac526SetCursorColors;
-    infoPtr->SetCursorPosition = IBMramdac526SetCursorPosition;
-    infoPtr->LoadCursorImage = IBMramdac526LoadCursorImage;
-    infoPtr->HideCursor = IBMramdac526HideCursor;
-    infoPtr->ShowCursor = IBMramdac526ShowCursor;
-    infoPtr->UseHWCursor = IBMramdac526UseHWCursor;
-}
-
-void
-IBMramdac640HWCursorInit(xf86CursorInfoPtr infoPtr)
-{
-    infoPtr->MaxWidth = 64;
-    infoPtr->MaxHeight = 64;
-    infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
-		     HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |
-		     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;
-    infoPtr->SetCursorColors = IBMramdac640SetCursorColors;
-    infoPtr->SetCursorPosition = IBMramdac640SetCursorPosition;
-    infoPtr->LoadCursorImage = IBMramdac640LoadCursorImage;
-    infoPtr->HideCursor = IBMramdac640HideCursor;
-    infoPtr->ShowCursor = IBMramdac640ShowCursor;
-    infoPtr->UseHWCursor = IBMramdac640UseHWCursor;
-}
+/*

+ * Copyright 1998 by Alan Hourihane, Wigan, England.

+ *

+ * 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 Alan Hourihane not be used in

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

+ * specific, written prior permission.  Alan Hourihane makes no representations

+ * about the suitability of this software for any purpose.  It is provided

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

+ *

+ * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

+ * EVENT SHALL ALAN HOURIHANE 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.

+ *

+ * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>

+ *

+ * IBM RAMDAC routines.

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include "xf86Cursor.h"

+

+#define INIT_IBM_RAMDAC_INFO

+#include "IBMPriv.h"

+#include "xf86RamDacPriv.h"

+

+#define INITIALFREQERR 100000

+

+unsigned long

+IBMramdac640CalculateMNPCForClock(

+    unsigned long RefClock,	/* In 100Hz units */

+    unsigned long ReqClock,	/* In 100Hz units */

+    char IsPixClock,	/* boolean, is this the pixel or the sys clock */

+    unsigned long MinClock,	/* Min VCO rating */

+    unsigned long MaxClock,	/* Max VCO rating */

+    unsigned long *rM,	/* M Out */

+    unsigned long *rN,	/* N Out */

+    unsigned long *rP,	/* Min P In, P Out */

+    unsigned long *rC	/* C Out */

+)

+{

+  unsigned long   M, N, P, iP = *rP;

+  unsigned long   IntRef, VCO, Clock;

+  long            freqErr, lowestFreqErr = INITIALFREQERR;

+  unsigned long   ActualClock = 0;

+

+  for (N = 0; N <= 63; N++)

+    {

+      IntRef = RefClock / (N + 1);

+      if (IntRef < 10000)

+	break;			/* IntRef needs to be >= 1MHz */

+      for (M = 2; M <= 127; M++)

+	{

+	  VCO = IntRef * (M + 1);

+	  if ((VCO < MinClock) || (VCO > MaxClock))

+	    continue;

+	  for (P = iP; P <= 4; P++)

+	    {

+	      if (P != 0)

+		Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);

+	      else

+		Clock = (RefClock * (M + 1)) / (N + 1);

+

+	      freqErr = (Clock - ReqClock);

+

+	      if (freqErr < 0)

+		{

+		  /* PixelClock gets rounded up always so monitor reports

+		     correct frequency. */

+		  if (IsPixClock)

+		    continue;

+		  freqErr = -freqErr;

+		}

+

+	      if (freqErr < lowestFreqErr)

+		{

+		  *rM = M;

+		  *rN = N;

+		  *rP = P;

+		  *rC = (VCO <= 1280000 ? 1 : 2);

+		  ActualClock = Clock;

+

+		  lowestFreqErr = freqErr;

+		  /* Return if we found an exact match */

+		  if (freqErr == 0)

+		    return ActualClock;

+		}

+	    }

+	}

+    }

+

+  return ActualClock;

+}

+

+unsigned long

+IBMramdac526CalculateMNPCForClock(

+    unsigned long RefClock,	/* In 100Hz units */

+    unsigned long ReqClock,	/* In 100Hz units */

+    char IsPixClock,	/* boolean, is this the pixel or the sys clock */

+    unsigned long MinClock,	/* Min VCO rating */

+    unsigned long MaxClock,	/* Max VCO rating */

+    unsigned long *rM,	/* M Out */

+    unsigned long *rN,	/* N Out */

+    unsigned long *rP,	/* Min P In, P Out */

+    unsigned long *rC	/* C Out */

+)

+{

+  unsigned long   M, N, P, iP = *rP;

+  unsigned long   IntRef, VCO, Clock;

+  long            freqErr, lowestFreqErr = INITIALFREQERR;

+  unsigned long   ActualClock = 0;

+

+  for (N = 0; N <= 63; N++)

+    {

+      IntRef = RefClock / (N + 1);

+      if (IntRef < 10000)

+	break;			/* IntRef needs to be >= 1MHz */

+      for (M = 0; M <= 63; M++)

+	{

+	  VCO = IntRef * (M + 1);

+	  if ((VCO < MinClock) || (VCO > MaxClock))

+	    continue;

+	  for (P = iP; P <= 4; P++)

+	    {

+	      if (P)

+		Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);

+	      else

+		Clock = VCO;

+

+	      freqErr = (Clock - ReqClock);

+

+	      if (freqErr < 0)

+		{

+		  /* PixelClock gets rounded up always so monitor reports

+		     correct frequency. */

+		  if (IsPixClock)

+		    continue;

+		  freqErr = -freqErr;

+		}

+

+	      if (freqErr < lowestFreqErr)

+		{

+		  *rM = M;

+		  *rN = N;

+		  *rP = P;

+		  *rC = (VCO <= 1280000 ? 1 : 2);

+		  ActualClock = Clock;

+

+		  lowestFreqErr = freqErr;

+		  /* Return if we found an exact match */

+		  if (freqErr == 0)

+		    return ActualClock;

+		}

+	    }

+	}

+    }

+

+  return ActualClock;

+}

+

+void

+IBMramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,

+				    RamDacRegRecPtr ramdacReg)

+{

+	int i, maxreg, dacreg;

+

+	switch (ramdacPtr->RamDacType) {

+	    case IBM640_RAMDAC:

+		maxreg = 0x300;

+		dacreg = 1024;

+		break;

+	    default:

+		maxreg = 0x100;

+		dacreg = 768;

+		break;

+	}

+

+	/* Here we pass a short, so that we can evaluate a mask too */

+	/* So that the mask is the high byte and the data the low byte */

+	for (i=0;i<maxreg;i++) 

+	    (*ramdacPtr->WriteDAC)

+	        (pScrn, i, (ramdacReg->DacRegs[i] & 0xFF00) >> 8, 

+						ramdacReg->DacRegs[i]);

+

+	(*ramdacPtr->WriteAddress)(pScrn, 0);

+	for (i=0;i<dacreg;i++)

+	    	(*ramdacPtr->WriteData)(pScrn, ramdacReg->DAC[i]);

+}

+

+void

+IBMramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr, 

+				 RamDacRegRecPtr ramdacReg)

+{

+	int i, maxreg, dacreg;

+

+	switch (ramdacPtr->RamDacType) {

+	    case IBM640_RAMDAC:

+		maxreg = 0x300;

+		dacreg = 1024;

+		break;

+	    default:

+		maxreg = 0x100;

+		dacreg = 768;

+		break;

+	}

+	

+	(*ramdacPtr->ReadAddress)(pScrn, 0);

+	for (i=0;i<dacreg;i++)

+	    ramdacReg->DAC[i] = (*ramdacPtr->ReadData)(pScrn);

+

+	for (i=0;i<maxreg;i++) 

+	    ramdacReg->DacRegs[i] = (*ramdacPtr->ReadDAC)(pScrn, i);

+}

+

+RamDacHelperRecPtr

+IBMramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs/* , RamDacRecPtr ramdacPtr*/)

+{

+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+    RamDacHelperRecPtr ramdacHelperPtr = NULL;

+    Bool RamDacIsSupported = FALSE;

+    int IBMramdac_ID = -1;

+    int i;

+    unsigned char id, rev, id2, rev2;

+

+    /* read ID and revision */

+    rev = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_rev);

+    id = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_id);

+

+    /* check if ID and revision are read only */

+    (*ramdacPtr->WriteDAC)(pScrn, ~rev, 0, IBMRGB_rev);

+    (*ramdacPtr->WriteDAC)(pScrn, ~id, 0, IBMRGB_id);

+    rev2 = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_rev);

+    id2 = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_id);

+

+    switch (id) {

+	case 0x30:

+		if (rev == 0xc0) IBMramdac_ID = IBM624_RAMDAC;

+		if (rev == 0x80) IBMramdac_ID = IBM624DB_RAMDAC;

+		break;

+	case 0x12:

+		if (rev == 0x1c) IBMramdac_ID = IBM640_RAMDAC;

+		break;

+	case 0x01:

+		IBMramdac_ID = IBM525_RAMDAC;

+		break;

+	case 0x02:

+		if (rev == 0xf0) IBMramdac_ID = IBM524_RAMDAC;

+		if (rev == 0xe0) IBMramdac_ID = IBM524A_RAMDAC;

+		if (rev == 0xc0) IBMramdac_ID = IBM526_RAMDAC;

+		if (rev == 0x80) IBMramdac_ID = IBM526DB_RAMDAC;

+		break;

+    }

+

+    if (id == 1 || id == 2) {

+        if (id == id2 && rev == rev2) {		/* IBM RGB52x found */

+	    /* check for 128bit VRAM -> RGB528 */

+	    if (((*ramdacPtr->ReadDAC)(pScrn, IBMRGB_misc1) & 0x03) == 0x03) {

+	        IBMramdac_ID = IBM528_RAMDAC;	/* 128bit DAC found */

+	        if (rev == 0xe0)

+		    IBMramdac_ID = IBM528A_RAMDAC;

+	    }

+        }

+    }

+

+    (*ramdacPtr->WriteDAC)(pScrn, rev, 0, IBMRGB_rev);

+    (*ramdacPtr->WriteDAC)(pScrn, id, 0, IBMRGB_id);

+

+    if (IBMramdac_ID == -1) {

+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

+		"Cannot determine IBM RAMDAC type, aborting\n");

+	return NULL;

+    } else {

+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

+		"Attached RAMDAC is %s\n", IBMramdacDeviceInfo[IBMramdac_ID&0xFFFF].DeviceName);

+    }

+

+    for (i=0;ramdacs[i].token != -1;i++) {

+	if (ramdacs[i].token == IBMramdac_ID)

+	    RamDacIsSupported = TRUE;

+    }

+

+    if (!RamDacIsSupported) {

+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

+		"This IBM RAMDAC is NOT supported by this driver, aborting\n");

+	return NULL;

+    }

+

+    ramdacHelperPtr = RamDacHelperCreateInfoRec();

+    switch (IBMramdac_ID) {

+	case IBM526_RAMDAC:

+	case IBM526DB_RAMDAC:

+ 	    ramdacHelperPtr->SetBpp = IBMramdac526SetBpp;

+    	    ramdacHelperPtr->HWCursorInit = IBMramdac526HWCursorInit;

+	    break;

+	case IBM640_RAMDAC:

+ 	    ramdacHelperPtr->SetBpp = IBMramdac640SetBpp;

+    	    ramdacHelperPtr->HWCursorInit = IBMramdac640HWCursorInit;

+	    break;

+    }

+    ramdacPtr->RamDacType = IBMramdac_ID;

+    ramdacHelperPtr->RamDacType = IBMramdac_ID;

+    ramdacHelperPtr->Save = IBMramdacSave;

+    ramdacHelperPtr->Restore = IBMramdacRestore;

+

+    return ramdacHelperPtr;

+}

+

+void

+IBMramdac526SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)

+{

+    ramdacReg->DacRegs[IBMRGB_key_control] = 0x00; /* Disable Chroma Key */

+

+    switch (pScrn->bitsPerPixel) {

+	case 32:

+	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_32BPP;

+	    ramdacReg->DacRegs[IBMRGB_32bpp] = B32_DCOL_DIRECT;

+	    ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

+	    if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {

+		ramdacReg->DacRegs[IBMRGB_key_control] = 0x01; /* Enable Key */

+		ramdacReg->DacRegs[IBMRGB_key] = 0xFF; 

+		ramdacReg->DacRegs[IBMRGB_key_mask] = 0xFF;

+	    }

+	    break;

+	case 24:

+	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_24BPP;

+	    ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_24bpp] = B24_DCOL_DIRECT;

+	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

+	    break;

+	case 16:

+	    if (pScrn->depth == 16) {

+	        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;

+	        ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

+	        ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

+	        ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT|B16_LINEAR |

+					           B16_CONTIGUOUS | B16_565;

+	        ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

+	    } else {

+	        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;

+	        ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

+	        ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

+	        ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT|B16_LINEAR |

+					           B16_CONTIGUOUS | B16_555;

+	        ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

+	    }

+	    break;

+	case 8:

+	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_8BPP;

+	    ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_8bpp] = B8_DCOL_INDIRECT;

+	    break;

+	case 4:

+	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_4BPP;

+	    ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;

+	    ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

+    }

+}

+

+IBMramdac526SetBppProc *IBMramdac526SetBppWeak(void) {

+    return IBMramdac526SetBpp;

+}

+

+void

+IBMramdac640SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)

+{

+    unsigned char bpp = 0x00;

+    unsigned char overlaybpp = 0x00;

+    unsigned char offset = 0x00;

+    unsigned char dispcont = 0x44;

+

+    ramdacReg->DacRegs[RGB640_SER_WID_03_00] = 0x00;

+    ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x00;

+    ramdacReg->DacRegs[RGB640_DIAGS] = 0x07;

+

+    switch (pScrn->depth) {

+	case 8:

+	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x00; 

+	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x00;

+	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;

+	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;

+    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_16_1; /*16:1 Mux*/

+    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */

+	    bpp = 0x03;

+	    break;

+	case 15:

+	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;

+	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;

+	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;

+	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;

+    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1; /* 8:1 Mux*/

+    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */

+	    bpp = 0x0E;

+	    break;

+	case 16:

+	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;

+	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;

+	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;

+	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;

+    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1; /* 8:1 Mux*/

+    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */

+	    bpp = 0x05;

+	    break;

+	case 24:

+	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30; 

+	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;

+	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;

+	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;

+    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1; /* 4:1 Mux*/

+    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */

+	    bpp = 0x09;

+	    if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {

+		ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x04;

+		ramdacReg->DacRegs[RGB640_CHROMA_KEY0] = 0xFF;

+		ramdacReg->DacRegs[RGB640_CHROMA_MASK0] = 0xFF;

+		offset = 0x04;

+		overlaybpp = 0x04;

+		dispcont = 0x48;

+	    }

+	    break;

+	case 30: /* 10 bit dac */

+	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30; 

+	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;

+	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;

+	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;

+    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1; /* 4:1 Mux*/

+    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PSIZE10 | 

+						   IBM640_PCLK_8; /* pll / 8 */

+	    bpp = 0x0D;

+	    break;

+    }

+	

+    { 

+	int i;

+    	for (i=0x100;i<0x140;i+=4) {

+	    /* Initialize FrameBuffer Window Attribute Table */

+	    ramdacReg->DacRegs[i+0] = bpp;

+	    ramdacReg->DacRegs[i+1] = offset;

+	    ramdacReg->DacRegs[i+2] = 0x00;

+	    ramdacReg->DacRegs[i+3] = 0x00;

+	    /* Initialize Overlay Window Attribute Table */

+	    ramdacReg->DacRegs[i+0x100] = overlaybpp;

+	    ramdacReg->DacRegs[i+0x101] = 0x00;

+	    ramdacReg->DacRegs[i+0x102] = 0x00;

+	    ramdacReg->DacRegs[i+0x103] = dispcont;

+        }

+    }

+}

+

+static void 

+IBMramdac526ShowCursor(ScrnInfoPtr pScrn)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+   /* Enable cursor - X11 mode */

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs, 0x00, 0x07);

+}

+

+static void 

+IBMramdac640ShowCursor(ScrnInfoPtr pScrn)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+   /* Enable cursor - mode2 (x11 mode) */

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x0B);

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CROSSHAIR_CONTROL, 0x00, 0x00);

+}

+

+static void

+IBMramdac526HideCursor(ScrnInfoPtr pScrn)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+   /* Disable cursor - X11 mode */

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs, 0x00, 0x24);

+}

+

+static void

+IBMramdac640HideCursor(ScrnInfoPtr pScrn)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+   /* Disable cursor - mode2 (x11 mode) */

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x08);

+}

+

+static void

+IBMramdac526SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+   x += 64;

+   y += 64;

+

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_hot_x, 0x00, 0x3f);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_hot_y, 0x00, 0x3f);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_xl, 0x00, x & 0xff);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_xh, 0x00, (x>>8) & 0xf);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_yl, 0x00, y & 0xff);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_yh, 0x00, (y>>8) & 0xf);

+}

+

+static void

+IBMramdac640SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+   x += 64;

+   y += 64;

+

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_OFFSETX, 0x00, 0x3f);

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_OFFSETY, 0x00, 0x3f);

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_X_LOW, 0x00, x & 0xff);

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_X_HIGH, 0x00, (x>>8) & 0xf);

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_Y_LOW, 0x00, y & 0xff);

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_Y_HIGH, 0x00, (y>>8) & 0xf);

+}

+

+static void

+IBMramdac526SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col1_r, 0x00, bg >> 16);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col1_g, 0x00, bg >> 8);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col1_b, 0x00, bg);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col2_r, 0x00, fg >> 16);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col2_g, 0x00, fg >> 8);

+   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col2_b, 0x00, fg);

+}

+

+static void

+IBMramdac640SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+  

+   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_COL0, 0x00, 0);

+   (*ramdacPtr->WriteData)(pScrn, fg>>16);

+   (*ramdacPtr->WriteData)(pScrn, fg>>8);

+   (*ramdacPtr->WriteData)(pScrn, fg);

+   (*ramdacPtr->WriteData)(pScrn, bg>>16);

+   (*ramdacPtr->WriteData)(pScrn, bg>>8);

+   (*ramdacPtr->WriteData)(pScrn, bg);

+   (*ramdacPtr->WriteData)(pScrn, fg>>16);

+   (*ramdacPtr->WriteData)(pScrn, fg>>8);

+   (*ramdacPtr->WriteData)(pScrn, fg);

+   (*ramdacPtr->WriteData)(pScrn, bg>>16);

+   (*ramdacPtr->WriteData)(pScrn, bg>>8);

+   (*ramdacPtr->WriteData)(pScrn, bg);

+}

+

+static void 

+IBMramdac526LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+   int i;

+   /* 

+    * Output the cursor data.  The realize function has put the planes into

+    * their correct order, so we can just blast this out.

+    */

+   for (i = 0; i < 1024; i++)

+      (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_array + i, 0x00, (*src++));

+}

+

+static void 

+IBMramdac640LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)

+{

+   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+   int i;

+   /* 

+    * Output the cursor data.  The realize function has put the planes into

+    * their correct order, so we can just blast this out.

+    */

+   for (i = 0; i < 1024; i++)

+      (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_WRITE + i, 0x00, (*src++));

+}

+

+static Bool 

+IBMramdac526UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)

+{

+    return TRUE;

+}

+

+static Bool 

+IBMramdac640UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)

+{

+    return TRUE;

+}

+

+void

+IBMramdac526HWCursorInit(xf86CursorInfoPtr infoPtr)

+{

+    infoPtr->MaxWidth = 64;

+    infoPtr->MaxHeight = 64;

+    infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |

+		     HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |

+		     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;

+    infoPtr->SetCursorColors = IBMramdac526SetCursorColors;

+    infoPtr->SetCursorPosition = IBMramdac526SetCursorPosition;

+    infoPtr->LoadCursorImage = IBMramdac526LoadCursorImage;

+    infoPtr->HideCursor = IBMramdac526HideCursor;

+    infoPtr->ShowCursor = IBMramdac526ShowCursor;

+    infoPtr->UseHWCursor = IBMramdac526UseHWCursor;

+}

+

+void

+IBMramdac640HWCursorInit(xf86CursorInfoPtr infoPtr)

+{

+    infoPtr->MaxWidth = 64;

+    infoPtr->MaxHeight = 64;

+    infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |

+		     HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |

+		     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;

+    infoPtr->SetCursorColors = IBMramdac640SetCursorColors;

+    infoPtr->SetCursorPosition = IBMramdac640SetCursorPosition;

+    infoPtr->LoadCursorImage = IBMramdac640LoadCursorImage;

+    infoPtr->HideCursor = IBMramdac640HideCursor;

+    infoPtr->ShowCursor = IBMramdac640ShowCursor;

+    infoPtr->UseHWCursor = IBMramdac640UseHWCursor;

+}

diff --git a/xorg-server/hw/xfree86/ramdac/TI.c b/xorg-server/hw/xfree86/ramdac/TI.c
index 1c541d76b..f189fed25 100644
--- a/xorg-server/hw/xfree86/ramdac/TI.c
+++ b/xorg-server/hw/xfree86/ramdac/TI.c
@@ -1,717 +1,717 @@
-/*
- * Copyright 1998 by Alan Hourihane, Wigan, England.
- *
- * 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 Alan Hourihane not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Alan Hourihane makes no representations
- * about the suitability of this software for any purpose.  It is provided
- * "as is" without express or implied warranty.
- *
- * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL ALAN HOURIHANE 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.
- *
- * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>
- *
- * Modified from IBM.c to support TI RAMDAC routines 
- *   by Jens Owen, <jens@tungstengraphics.com>.
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include "xf86Cursor.h"
-
-#define INIT_TI_RAMDAC_INFO
-#include "TIPriv.h"
-#include "xf86RamDacPriv.h"
-
-/* The following values are in kHz */
-#define TI_MIN_VCO_FREQ  110000
-#define TI_MAX_VCO_FREQ  220000
-
-unsigned long
-TIramdacCalculateMNPForClock(
-    unsigned long RefClock,	/* In 100Hz units */
-    unsigned long ReqClock,	/* In 100Hz units */
-    char IsPixClock,	/* boolean, is this the pixel or the sys clock */
-    unsigned long MinClock,	/* Min VCO rating */
-    unsigned long MaxClock,	/* Max VCO rating */
-    unsigned long *rM,	/* M Out */
-    unsigned long *rN,	/* N Out */
-    unsigned long *rP 	/* Min P In, P Out */
-)
-{
-    unsigned long   n, p;
-    unsigned long   best_m = 0, best_n = 0;
-    double          VCO, IntRef = (double)RefClock;
-    double          m_err, inc_m, calc_m;
-    unsigned long   ActualClock;
-
-    /* Make sure that MinClock <= ReqClock <= MaxClock */
-    if ( ReqClock < MinClock)
-	ReqClock = MinClock;
-    if ( ReqClock > MaxClock )
-	ReqClock = MaxClock;
-
-    /*
-     * ActualClock = VCO / 2 ^ p
-     * Choose p so that TI_MIN_VCO_FREQ <= VCO <= TI_MAX_VCO_FREQ
-     * Note that since TI_MAX_VCO_FREQ = 2 * TI_MIN_VCO_FREQ
-     * we don't have to bother checking for this maximum limit.
-     */
-    VCO = (double)ReqClock;
-    for ( p = 0; p < 3 && VCO < TI_MIN_VCO_FREQ; ( p )++ )
-	 VCO *= 2.0;
-
-    /*
-     * We avoid doing multiplications by ( 65 - n ),
-     * and add an increment instead - this keeps any error small.
-     */
-    inc_m = VCO / ( IntRef * 8.0 );
-
-    /* Initial value of calc_m for the loop */
-    calc_m = inc_m + inc_m + inc_m;
-
-    /* Initial amount of error for an integer - impossibly large */
-    m_err = 2.0;
-
-    /* Search for the closest INTEGER value of ( 65 - m ) */
-    for ( n = 3; n <= 25; ( n )++, calc_m += inc_m ) {
-
-	/* Ignore values of ( 65 - m ) which we can't use */
-	if ( calc_m < 3.0 || calc_m > 64.0 )
-	    continue;
-
-	/*
-	 * Pick the closest INTEGER (has smallest fractional part).
-	 * The optimizer should clean this up for us.
-	 */
-	if (( calc_m - ( int ) calc_m ) < m_err ) {
-	    m_err = calc_m - ( int ) calc_m;
-	    best_m = ( int ) calc_m;
-	    best_n = n;
-	}
-    }
-
-    /* 65 - ( 65 - x ) = x */
-    *rM = 65 - best_m;
-    *rN = 65 - best_n;
-    *rP = p;
-
-    /* Now all the calculations can be completed */
-    VCO = 8.0 * IntRef * best_m / best_n;
-    ActualClock = VCO / ( 1 << p );
-
-    DebugF( "f_out=%ld f_vco=%.1f n=%d m=%d p=%d\n",
-	    ActualClock, VCO, *rN, *rM, *rP);
-
-    return (ActualClock);
-}
-
-void
-TIramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
-				   RamDacRegRecPtr ramdacReg)
-{
-    int i;
-    unsigned long status;
-
-    /* Here we pass a short, so that we can evaluate a mask too
-     * So that the mask is the high byte and the data the low byte
-     * Order is important
-     */
-    TIRESTORE(TIDAC_latch_ctrl);
-    TIRESTORE(TIDAC_true_color_ctrl);
-    TIRESTORE(TIDAC_multiplex_ctrl);
-    TIRESTORE(TIDAC_clock_select);
-    TIRESTORE(TIDAC_palette_page);
-    TIRESTORE(TIDAC_general_ctrl);
-    TIRESTORE(TIDAC_misc_ctrl);
-	    /* 0x2A & 0x2B are reserved */
-    TIRESTORE(TIDAC_key_over_low);
-    TIRESTORE(TIDAC_key_over_high);
-    TIRESTORE(TIDAC_key_red_low);
-    TIRESTORE(TIDAC_key_red_high);
-    TIRESTORE(TIDAC_key_green_low);
-    TIRESTORE(TIDAC_key_green_high);
-    TIRESTORE(TIDAC_key_blue_low);
-    TIRESTORE(TIDAC_key_blue_high);
-    TIRESTORE(TIDAC_key_ctrl);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_clock_ctrl, 0, 0x30);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_clock_ctrl, 0, 0x38);
-    TIRESTORE(TIDAC_clock_ctrl);
-    TIRESTORE(TIDAC_sense_test);
-    TIRESTORE(TIDAC_ind_curs_ctrl);
-
-    /* only restore clocks if they were valid to begin with */
-
-    if (ramdacReg->DacRegs[TIDAC_PIXEL_VALID]) {
-    /* Reset pixel clock */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0, 0x3c);
-
-    /* Restore N, M & P values for pixel clocks */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0,
-					ramdacReg->DacRegs[TIDAC_PIXEL_N]);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0,
-					ramdacReg->DacRegs[TIDAC_PIXEL_M]);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0,
-					ramdacReg->DacRegs[TIDAC_PIXEL_P]);
-
-    /* wait for pixel clock to lock */
-    i = 1000000;
-    do {
-	status = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);
-    } while ((!(status & 0x40)) && (--i));
-    if (!(status & 0x40)) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 
-			"Pixel clock setup timed out\n");
-	return;
-    }
-    }
-
-    if (ramdacReg->DacRegs[TIDAC_LOOP_VALID]) {
-    /* Reset loop clock */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0, 0x70);
-
-    /* Restore N, M & P values for pixel clocks */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0,
-					ramdacReg->DacRegs[TIDAC_LOOP_N]);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0,
-					ramdacReg->DacRegs[TIDAC_LOOP_M]);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0,
-					ramdacReg->DacRegs[TIDAC_LOOP_P]);
-
-    /* wait for loop clock to lock */
-    i = 1000000;
-    do {
-        status = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);
-    } while ((!(status & 0x40)) && (--i));
-    if (!(status & 0x40)) {
-	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 
-			"Loop clock setup timed out\n");
-	    return;
-    }
-    }
-
-    /* restore palette */
-    (*ramdacPtr->WriteAddress)(pScrn, 0);
-#ifndef NOT_DONE
-    for (i=0;i<768;i++)
-	(*ramdacPtr->WriteData)(pScrn, ramdacReg->DAC[i]);
-#else
-	(*ramdacPtr->WriteData)(pScrn, 0);
-	(*ramdacPtr->WriteData)(pScrn, 0);
-	(*ramdacPtr->WriteData)(pScrn, 0);
-    for (i=0;i<765;i++)
-	(*ramdacPtr->WriteData)(pScrn, 0xff);
-#endif
-}
-
-void
-TIramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr, 
-				RamDacRegRecPtr ramdacReg)
-{
-    int i;
-
-    (*ramdacPtr->ReadAddress)(pScrn, 0);
-    for (i=0;i<768;i++)
-	ramdacReg->DAC[i] = (*ramdacPtr->ReadData)(pScrn);
-
-    /* Read back N,M and P values for pixel clock */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);
-    ramdacReg->DacRegs[TIDAC_PIXEL_N] = 
-			(*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x11);
-    ramdacReg->DacRegs[TIDAC_PIXEL_M] = 
-		    	(*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);
-    ramdacReg->DacRegs[TIDAC_PIXEL_P] = 
-		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);
-
-    /* Read back N,M and P values for loop clock */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);
-    ramdacReg->DacRegs[TIDAC_LOOP_N] = 
-		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x11);
-    ramdacReg->DacRegs[TIDAC_LOOP_M] = 
-		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);
-    ramdacReg->DacRegs[TIDAC_LOOP_P] = 
-		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);
-
-    /* Order is important */
-    TISAVE(TIDAC_latch_ctrl);
-    TISAVE(TIDAC_true_color_ctrl);
-    TISAVE(TIDAC_multiplex_ctrl);
-    TISAVE(TIDAC_clock_select);
-    TISAVE(TIDAC_palette_page);
-    TISAVE(TIDAC_general_ctrl);
-    TISAVE(TIDAC_misc_ctrl);
-	    /* 0x2A & 0x2B are reserved */
-    TISAVE(TIDAC_key_over_low);
-    TISAVE(TIDAC_key_over_high);
-    TISAVE(TIDAC_key_red_low);
-    TISAVE(TIDAC_key_red_high);
-    TISAVE(TIDAC_key_green_low);
-    TISAVE(TIDAC_key_green_high);
-    TISAVE(TIDAC_key_blue_low);
-    TISAVE(TIDAC_key_blue_high);
-    TISAVE(TIDAC_key_ctrl);
-    TISAVE(TIDAC_clock_ctrl);
-    TISAVE(TIDAC_sense_test);
-    TISAVE(TIDAC_ind_curs_ctrl);
-}
-
-RamDacHelperRecPtr
-TIramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs)
-{
-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-    RamDacHelperRecPtr ramdacHelperPtr = NULL;
-    Bool RamDacIsSupported = FALSE;
-    int TIramdac_ID = -1;
-    int i;
-    unsigned char id, rev, rev2, id2;
-
-    /* read ID and revision */
-    rev = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_rev);
-    id = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_id);
-
-    /* check if ID and revision are read only */
-    (*ramdacPtr->WriteDAC)(pScrn, ~rev, 0, TIDAC_rev);
-    (*ramdacPtr->WriteDAC)(pScrn, ~id, 0, TIDAC_id);
-    rev2 = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_rev);
-    id2 = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_id);
-
-    switch (id) {
-	case TIDAC_TVP_3030_ID:
-		if (id == id2 && rev == rev2)  /* check for READ ONLY */
-		    TIramdac_ID = TI3030_RAMDAC;
-		break;
-	case TIDAC_TVP_3026_ID:
-		if (id == id2 && rev == rev2)  /* check for READ ONLY */
-		    TIramdac_ID = TI3026_RAMDAC;
-		break;
-    }
-
-    (*ramdacPtr->WriteDAC)(pScrn, rev, 0, TIDAC_rev);
-    (*ramdacPtr->WriteDAC)(pScrn, id, 0, TIDAC_id);
-
-    if (TIramdac_ID == -1) {
-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-		"Cannot determine TI RAMDAC type, aborting\n");
-	return NULL;
-    } else {
-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-		"Attached RAMDAC is %s\n", TIramdacDeviceInfo[TIramdac_ID&0xFFFF].DeviceName);
-    }
-
-    for (i=0;ramdacs[i].token != -1;i++) {
-	if (ramdacs[i].token == TIramdac_ID)
-	    RamDacIsSupported = TRUE;
-    }
-
-    if (!RamDacIsSupported) {
-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-		"This TI RAMDAC is NOT supported by this driver, aborting\n");
-	return NULL;
-    }
-
-    ramdacHelperPtr = RamDacHelperCreateInfoRec();
-    switch (TIramdac_ID) {
-	case TI3030_RAMDAC:
- 	    ramdacHelperPtr->SetBpp = TIramdac3030SetBpp;
-    	    ramdacHelperPtr->HWCursorInit = TIramdacHWCursorInit;
-	    break;
-	case TI3026_RAMDAC:
- 	    ramdacHelperPtr->SetBpp = TIramdac3026SetBpp;
-    	    ramdacHelperPtr->HWCursorInit = TIramdacHWCursorInit;
-	    break;
-    }
-    ramdacPtr->RamDacType = TIramdac_ID;
-    ramdacHelperPtr->RamDacType = TIramdac_ID;
-    ramdacHelperPtr->Save = TIramdacSave;
-    ramdacHelperPtr->Restore = TIramdacRestore;
-
-    return ramdacHelperPtr;
-}
-
-void
-TIramdac3026SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
-{
-    switch (pScrn->bitsPerPixel) {
-    case 32:
-	/* order is important */
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x46;
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x5c;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;
-	/* 0x2A & 0x2B are reserved */
-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
-	if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x06;
-	    ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;
-	    ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x01;
-	}
-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
-	break;
-    case 24:
-	/* order is important */
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x56;
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x58;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x25;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;
-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;
-	/* 0x2A & 0x2B are reserved */
-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
-	break;
-    case 16:
-	/* order is important */
-#if 0
-	/* Matrox driver uses this */
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x07;
-#else
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
-#endif
-	if (pScrn->depth == 16) {
-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x45;
-	} else {
-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x44;
-	}
-#if 0
-	/* Matrox driver uses this */
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x50;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x15;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;
-#else
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x54;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
-#endif
-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;
-	/* 0x2A & 0x2B are reserved */
-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
-	break;
-    case 8:
-	/* order is important */
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x80;
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x4c;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x1C;
-	/* 0x2A & 0x2B are reserved */
-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x00;
-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
-	break;
-    }
-}
-
-void
-TIramdac3030SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
-{
-    switch (pScrn->bitsPerPixel) {
-    case 32:
-	/* order is important */
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x46;
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x5D;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;
-	/* 0x2A & 0x2B are reserved */
-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
-	if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x06;
-	    ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;
-	    ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x01;
-	}
-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
-	break;
-    case 24:
-	/* order is important */
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x56;
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x58;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x25;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;
-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;
-	/* 0x2A & 0x2B are reserved */
-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
-	break;
-    case 16:
-	/* order is important */
-#if 0
-	/* Matrox driver uses this */
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x07;
-#else
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
-#endif
-	if (pScrn->depth == 16) {
-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x45;
-	} else {
-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x44;
-	}
-#if 0
-	/* Matrox driver uses this */
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x50;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x15;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;
-#else
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x55;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x85;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
-#endif
-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;
-	/* 0x2A & 0x2B are reserved */
-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
-	break;
-    case 8:
-	/* order is important */
-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x80;
-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x4d;
-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x1C;
-	/* 0x2A & 0x2B are reserved */
-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x00;
-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
-	break;
-    }
-}
-
-static void 
-TIramdacShowCursor(ScrnInfoPtr pScrn)
-{
-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-    /* Enable cursor - X11 mode */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_ind_curs_ctrl, 0, 0x03);
-}
-
-static void
-TIramdacHideCursor(ScrnInfoPtr pScrn)
-{
-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-    /* Disable cursor - X11 mode */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_ind_curs_ctrl, 0, 0x00);
-}
-
-static void
-TIramdacSetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
-{
-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-    x += 64;
-    y += 64;
-
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_XLOW,  0, x & 0xff);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_XHIGH, 0, (x >> 8) & 0x0f);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_YLOW,  0, y & 0xff);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_YHIGH, 0, (y >> 8) & 0x0f);
-}
-
-static void
-TIramdacSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
-{
-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-
-    /* Background color */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_WRITE_ADDR, 0, 1);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((bg&0x00ff0000) >> 16));
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((bg&0x0000ff00) >>  8));
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0,  (bg&0x000000ff)       );
-
-    /* Foreground color */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_WRITE_ADDR, 0, 2);
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((fg&0x00ff0000) >> 16));
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((fg&0x0000ff00) >>  8));
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0,  (fg&0x000000ff)       );
-}
-
-static void 
-TIramdacLoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
-{
-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
-    int i = 1024;
-
-    /* reset A9,A8 */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_ind_curs_ctrl, 0, 0x00); 
-    /* reset cursor RAM load address A7..A0 */
-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_INDEX, 0x00, 0x00); 
- 
-    while(i--) {
-	/* NOT_DONE: might need a delay here */
-	(*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_RAM_DATA, 0, *(src++));
-    }
-}
-
-static Bool 
-TIramdacUseHWCursor(ScreenPtr pScr, CursorPtr pCurs)
-{
-    return TRUE;
-}
-
-void
-TIramdacHWCursorInit(xf86CursorInfoPtr infoPtr)
-{
-    infoPtr->MaxWidth = 64;
-    infoPtr->MaxHeight = 64;
-    infoPtr->Flags = HARDWARE_CURSOR_BIT_ORDER_MSBFIRST |
-		     HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
-		     HARDWARE_CURSOR_SOURCE_MASK_NOT_INTERLEAVED;
-    infoPtr->SetCursorColors = TIramdacSetCursorColors;
-    infoPtr->SetCursorPosition = TIramdacSetCursorPosition;
-    infoPtr->LoadCursorImage = TIramdacLoadCursorImage;
-    infoPtr->HideCursor = TIramdacHideCursor;
-    infoPtr->ShowCursor = TIramdacShowCursor;
-    infoPtr->UseHWCursor = TIramdacUseHWCursor;
-}
-
-void TIramdacLoadPalette(
-    ScrnInfoPtr pScrn, 
-    int numColors, 
-    int *indices,
-    LOCO *colors,
-    VisualPtr pVisual
-){
-    RamDacRecPtr hwp = RAMDACSCRPTR(pScrn);
-    int i, index, shift;
-
-    if (pScrn->depth == 16) {
-    for(i = 0; i < numColors; i++) {
-	index = indices[i];
-    	(*hwp->WriteAddress)(pScrn, index << 2);
-	(*hwp->WriteData)(pScrn, colors[index >> 1].red);
-	(*hwp->WriteData)(pScrn, colors[index].green);
-	(*hwp->WriteData)(pScrn, colors[index >> 1].blue);
-
-	if(index <= 31) {
-	    (*hwp->WriteAddress)(pScrn, index << 3);
-	    (*hwp->WriteData)(pScrn, colors[index].red);
-	    (*hwp->WriteData)(pScrn, colors[(index << 1) + 1].green);
-	    (*hwp->WriteData)(pScrn, colors[index].blue);
-	}
-    }
-} else {
-    shift = (pScrn->depth == 15) ? 3 : 0;
-
-    for(i = 0; i < numColors; i++) {
-	index = indices[i];
-    	(*hwp->WriteAddress)(pScrn, index << shift);
-	(*hwp->WriteData)(pScrn, colors[index].red);
-	(*hwp->WriteData)(pScrn, colors[index].green);
-	(*hwp->WriteData)(pScrn, colors[index].blue);
-    }
-}
-}
-
-TIramdacLoadPaletteProc *TIramdacLoadPaletteWeak(void) {
-    return TIramdacLoadPalette;
-}
+/*

+ * Copyright 1998 by Alan Hourihane, Wigan, England.

+ *

+ * 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 Alan Hourihane not be used in

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

+ * specific, written prior permission.  Alan Hourihane makes no representations

+ * about the suitability of this software for any purpose.  It is provided

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

+ *

+ * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

+ * EVENT SHALL ALAN HOURIHANE 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.

+ *

+ * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>

+ *

+ * Modified from IBM.c to support TI RAMDAC routines 

+ *   by Jens Owen, <jens@tungstengraphics.com>.

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include "xf86Cursor.h"

+

+#define INIT_TI_RAMDAC_INFO

+#include "TIPriv.h"

+#include "xf86RamDacPriv.h"

+

+/* The following values are in kHz */

+#define TI_MIN_VCO_FREQ  110000

+#define TI_MAX_VCO_FREQ  220000

+

+unsigned long

+TIramdacCalculateMNPForClock(

+    unsigned long RefClock,	/* In 100Hz units */

+    unsigned long ReqClock,	/* In 100Hz units */

+    char IsPixClock,	/* boolean, is this the pixel or the sys clock */

+    unsigned long MinClock,	/* Min VCO rating */

+    unsigned long MaxClock,	/* Max VCO rating */

+    unsigned long *rM,	/* M Out */

+    unsigned long *rN,	/* N Out */

+    unsigned long *rP 	/* Min P In, P Out */

+)

+{

+    unsigned long   n, p;

+    unsigned long   best_m = 0, best_n = 0;

+    double          VCO, IntRef = (double)RefClock;

+    double          m_err, inc_m, calc_m;

+    unsigned long   ActualClock;

+

+    /* Make sure that MinClock <= ReqClock <= MaxClock */

+    if ( ReqClock < MinClock)

+	ReqClock = MinClock;

+    if ( ReqClock > MaxClock )

+	ReqClock = MaxClock;

+

+    /*

+     * ActualClock = VCO / 2 ^ p

+     * Choose p so that TI_MIN_VCO_FREQ <= VCO <= TI_MAX_VCO_FREQ

+     * Note that since TI_MAX_VCO_FREQ = 2 * TI_MIN_VCO_FREQ

+     * we don't have to bother checking for this maximum limit.

+     */

+    VCO = (double)ReqClock;

+    for ( p = 0; p < 3 && VCO < TI_MIN_VCO_FREQ; ( p )++ )

+	 VCO *= 2.0;

+

+    /*

+     * We avoid doing multiplications by ( 65 - n ),

+     * and add an increment instead - this keeps any error small.

+     */

+    inc_m = VCO / ( IntRef * 8.0 );

+

+    /* Initial value of calc_m for the loop */

+    calc_m = inc_m + inc_m + inc_m;

+

+    /* Initial amount of error for an integer - impossibly large */

+    m_err = 2.0;

+

+    /* Search for the closest INTEGER value of ( 65 - m ) */

+    for ( n = 3; n <= 25; ( n )++, calc_m += inc_m ) {

+

+	/* Ignore values of ( 65 - m ) which we can't use */

+	if ( calc_m < 3.0 || calc_m > 64.0 )

+	    continue;

+

+	/*

+	 * Pick the closest INTEGER (has smallest fractional part).

+	 * The optimizer should clean this up for us.

+	 */

+	if (( calc_m - ( int ) calc_m ) < m_err ) {

+	    m_err = calc_m - ( int ) calc_m;

+	    best_m = ( int ) calc_m;

+	    best_n = n;

+	}

+    }

+

+    /* 65 - ( 65 - x ) = x */

+    *rM = 65 - best_m;

+    *rN = 65 - best_n;

+    *rP = p;

+

+    /* Now all the calculations can be completed */

+    VCO = 8.0 * IntRef * best_m / best_n;

+    ActualClock = VCO / ( 1 << p );

+

+    DebugF( "f_out=%ld f_vco=%.1f n=%d m=%d p=%d\n",

+	    ActualClock, VCO, *rN, *rM, *rP);

+

+    return ActualClock;

+}

+

+void

+TIramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,

+				   RamDacRegRecPtr ramdacReg)

+{

+    int i;

+    unsigned long status;

+

+    /* Here we pass a short, so that we can evaluate a mask too

+     * So that the mask is the high byte and the data the low byte

+     * Order is important

+     */

+    TIRESTORE(TIDAC_latch_ctrl);

+    TIRESTORE(TIDAC_true_color_ctrl);

+    TIRESTORE(TIDAC_multiplex_ctrl);

+    TIRESTORE(TIDAC_clock_select);

+    TIRESTORE(TIDAC_palette_page);

+    TIRESTORE(TIDAC_general_ctrl);

+    TIRESTORE(TIDAC_misc_ctrl);

+	    /* 0x2A & 0x2B are reserved */

+    TIRESTORE(TIDAC_key_over_low);

+    TIRESTORE(TIDAC_key_over_high);

+    TIRESTORE(TIDAC_key_red_low);

+    TIRESTORE(TIDAC_key_red_high);

+    TIRESTORE(TIDAC_key_green_low);

+    TIRESTORE(TIDAC_key_green_high);

+    TIRESTORE(TIDAC_key_blue_low);

+    TIRESTORE(TIDAC_key_blue_high);

+    TIRESTORE(TIDAC_key_ctrl);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_clock_ctrl, 0, 0x30);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_clock_ctrl, 0, 0x38);

+    TIRESTORE(TIDAC_clock_ctrl);

+    TIRESTORE(TIDAC_sense_test);

+    TIRESTORE(TIDAC_ind_curs_ctrl);

+

+    /* only restore clocks if they were valid to begin with */

+

+    if (ramdacReg->DacRegs[TIDAC_PIXEL_VALID]) {

+    /* Reset pixel clock */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0, 0x3c);

+

+    /* Restore N, M & P values for pixel clocks */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0,

+					ramdacReg->DacRegs[TIDAC_PIXEL_N]);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0,

+					ramdacReg->DacRegs[TIDAC_PIXEL_M]);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0,

+					ramdacReg->DacRegs[TIDAC_PIXEL_P]);

+

+    /* wait for pixel clock to lock */

+    i = 1000000;

+    do {

+	status = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);

+    } while ((!(status & 0x40)) && (--i));

+    if (!(status & 0x40)) {

+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 

+			"Pixel clock setup timed out\n");

+	return;

+    }

+    }

+

+    if (ramdacReg->DacRegs[TIDAC_LOOP_VALID]) {

+    /* Reset loop clock */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0, 0x70);

+

+    /* Restore N, M & P values for pixel clocks */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0,

+					ramdacReg->DacRegs[TIDAC_LOOP_N]);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0,

+					ramdacReg->DacRegs[TIDAC_LOOP_M]);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0,

+					ramdacReg->DacRegs[TIDAC_LOOP_P]);

+

+    /* wait for loop clock to lock */

+    i = 1000000;

+    do {

+        status = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);

+    } while ((!(status & 0x40)) && (--i));

+    if (!(status & 0x40)) {

+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 

+			"Loop clock setup timed out\n");

+	    return;

+    }

+    }

+

+    /* restore palette */

+    (*ramdacPtr->WriteAddress)(pScrn, 0);

+#ifndef NOT_DONE

+    for (i=0;i<768;i++)

+	(*ramdacPtr->WriteData)(pScrn, ramdacReg->DAC[i]);

+#else

+	(*ramdacPtr->WriteData)(pScrn, 0);

+	(*ramdacPtr->WriteData)(pScrn, 0);

+	(*ramdacPtr->WriteData)(pScrn, 0);

+    for (i=0;i<765;i++)

+	(*ramdacPtr->WriteData)(pScrn, 0xff);

+#endif

+}

+

+void

+TIramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr, 

+				RamDacRegRecPtr ramdacReg)

+{

+    int i;

+

+    (*ramdacPtr->ReadAddress)(pScrn, 0);

+    for (i=0;i<768;i++)

+	ramdacReg->DAC[i] = (*ramdacPtr->ReadData)(pScrn);

+

+    /* Read back N,M and P values for pixel clock */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);

+    ramdacReg->DacRegs[TIDAC_PIXEL_N] = 

+			(*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x11);

+    ramdacReg->DacRegs[TIDAC_PIXEL_M] = 

+		    	(*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);

+    ramdacReg->DacRegs[TIDAC_PIXEL_P] = 

+		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);

+

+    /* Read back N,M and P values for loop clock */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);

+    ramdacReg->DacRegs[TIDAC_LOOP_N] = 

+		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x11);

+    ramdacReg->DacRegs[TIDAC_LOOP_M] = 

+		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);

+    ramdacReg->DacRegs[TIDAC_LOOP_P] = 

+		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);

+

+    /* Order is important */

+    TISAVE(TIDAC_latch_ctrl);

+    TISAVE(TIDAC_true_color_ctrl);

+    TISAVE(TIDAC_multiplex_ctrl);

+    TISAVE(TIDAC_clock_select);

+    TISAVE(TIDAC_palette_page);

+    TISAVE(TIDAC_general_ctrl);

+    TISAVE(TIDAC_misc_ctrl);

+	    /* 0x2A & 0x2B are reserved */

+    TISAVE(TIDAC_key_over_low);

+    TISAVE(TIDAC_key_over_high);

+    TISAVE(TIDAC_key_red_low);

+    TISAVE(TIDAC_key_red_high);

+    TISAVE(TIDAC_key_green_low);

+    TISAVE(TIDAC_key_green_high);

+    TISAVE(TIDAC_key_blue_low);

+    TISAVE(TIDAC_key_blue_high);

+    TISAVE(TIDAC_key_ctrl);

+    TISAVE(TIDAC_clock_ctrl);

+    TISAVE(TIDAC_sense_test);

+    TISAVE(TIDAC_ind_curs_ctrl);

+}

+

+RamDacHelperRecPtr

+TIramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs)

+{

+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+    RamDacHelperRecPtr ramdacHelperPtr = NULL;

+    Bool RamDacIsSupported = FALSE;

+    int TIramdac_ID = -1;

+    int i;

+    unsigned char id, rev, rev2, id2;

+

+    /* read ID and revision */

+    rev = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_rev);

+    id = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_id);

+

+    /* check if ID and revision are read only */

+    (*ramdacPtr->WriteDAC)(pScrn, ~rev, 0, TIDAC_rev);

+    (*ramdacPtr->WriteDAC)(pScrn, ~id, 0, TIDAC_id);

+    rev2 = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_rev);

+    id2 = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_id);

+

+    switch (id) {

+	case TIDAC_TVP_3030_ID:

+		if (id == id2 && rev == rev2)  /* check for READ ONLY */

+		    TIramdac_ID = TI3030_RAMDAC;

+		break;

+	case TIDAC_TVP_3026_ID:

+		if (id == id2 && rev == rev2)  /* check for READ ONLY */

+		    TIramdac_ID = TI3026_RAMDAC;

+		break;

+    }

+

+    (*ramdacPtr->WriteDAC)(pScrn, rev, 0, TIDAC_rev);

+    (*ramdacPtr->WriteDAC)(pScrn, id, 0, TIDAC_id);

+

+    if (TIramdac_ID == -1) {

+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

+		"Cannot determine TI RAMDAC type, aborting\n");

+	return NULL;

+    } else {

+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

+		"Attached RAMDAC is %s\n", TIramdacDeviceInfo[TIramdac_ID&0xFFFF].DeviceName);

+    }

+

+    for (i=0;ramdacs[i].token != -1;i++) {

+	if (ramdacs[i].token == TIramdac_ID)

+	    RamDacIsSupported = TRUE;

+    }

+

+    if (!RamDacIsSupported) {

+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

+		"This TI RAMDAC is NOT supported by this driver, aborting\n");

+	return NULL;

+    }

+

+    ramdacHelperPtr = RamDacHelperCreateInfoRec();

+    switch (TIramdac_ID) {

+	case TI3030_RAMDAC:

+ 	    ramdacHelperPtr->SetBpp = TIramdac3030SetBpp;

+    	    ramdacHelperPtr->HWCursorInit = TIramdacHWCursorInit;

+	    break;

+	case TI3026_RAMDAC:

+ 	    ramdacHelperPtr->SetBpp = TIramdac3026SetBpp;

+    	    ramdacHelperPtr->HWCursorInit = TIramdacHWCursorInit;

+	    break;

+    }

+    ramdacPtr->RamDacType = TIramdac_ID;

+    ramdacHelperPtr->RamDacType = TIramdac_ID;

+    ramdacHelperPtr->Save = TIramdacSave;

+    ramdacHelperPtr->Restore = TIramdacRestore;

+

+    return ramdacHelperPtr;

+}

+

+void

+TIramdac3026SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)

+{

+    switch (pScrn->bitsPerPixel) {

+    case 32:

+	/* order is important */

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

+	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x46;

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x5c;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;

+	/* 0x2A & 0x2B are reserved */

+	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

+	if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {

+	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x06;

+	    ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;

+	    ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x01;

+	}

+	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

+	break;

+    case 24:

+	/* order is important */

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

+	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x56;

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x58;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x25;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;

+	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;

+	/* 0x2A & 0x2B are reserved */

+	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

+	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

+	break;

+    case 16:

+	/* order is important */

+#if 0

+	/* Matrox driver uses this */

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x07;

+#else

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

+#endif

+	if (pScrn->depth == 16) {

+	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x45;

+	} else {

+	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x44;

+	}

+#if 0

+	/* Matrox driver uses this */

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x50;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x15;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;

+#else

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x54;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

+#endif

+	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;

+	/* 0x2A & 0x2B are reserved */

+	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

+	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

+	break;

+    case 8:

+	/* order is important */

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

+	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x80;

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x4c;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x1C;

+	/* 0x2A & 0x2B are reserved */

+	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x00;

+	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

+	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

+	break;

+    }

+}

+

+void

+TIramdac3030SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)

+{

+    switch (pScrn->bitsPerPixel) {

+    case 32:

+	/* order is important */

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

+	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x46;

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x5D;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;

+	/* 0x2A & 0x2B are reserved */

+	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

+	if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {

+	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x06;

+	    ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;

+	    ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x01;

+	}

+	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

+	break;

+    case 24:

+	/* order is important */

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

+	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x56;

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x58;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x25;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;

+	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;

+	/* 0x2A & 0x2B are reserved */

+	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

+	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

+	break;

+    case 16:

+	/* order is important */

+#if 0

+	/* Matrox driver uses this */

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x07;

+#else

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

+#endif

+	if (pScrn->depth == 16) {

+	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x45;

+	} else {

+	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x44;

+	}

+#if 0

+	/* Matrox driver uses this */

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x50;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x15;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;

+#else

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x55;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x85;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

+#endif

+	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;

+	/* 0x2A & 0x2B are reserved */

+	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

+	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

+	break;

+    case 8:

+	/* order is important */

+	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

+	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x80;

+	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x4d;

+	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

+	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

+	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

+	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x1C;

+	/* 0x2A & 0x2B are reserved */

+	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

+	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

+	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x00;

+	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

+	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

+	break;

+    }

+}

+

+static void 

+TIramdacShowCursor(ScrnInfoPtr pScrn)

+{

+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+    /* Enable cursor - X11 mode */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_ind_curs_ctrl, 0, 0x03);

+}

+

+static void

+TIramdacHideCursor(ScrnInfoPtr pScrn)

+{

+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+    /* Disable cursor - X11 mode */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_ind_curs_ctrl, 0, 0x00);

+}

+

+static void

+TIramdacSetCursorPosition(ScrnInfoPtr pScrn, int x, int y)

+{

+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+    x += 64;

+    y += 64;

+

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_XLOW,  0, x & 0xff);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_XHIGH, 0, (x >> 8) & 0x0f);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_YLOW,  0, y & 0xff);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_YHIGH, 0, (y >> 8) & 0x0f);

+}

+

+static void

+TIramdacSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)

+{

+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+

+    /* Background color */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_WRITE_ADDR, 0, 1);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((bg&0x00ff0000) >> 16));

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((bg&0x0000ff00) >>  8));

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0,  (bg&0x000000ff)       );

+

+    /* Foreground color */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_WRITE_ADDR, 0, 2);

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((fg&0x00ff0000) >> 16));

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((fg&0x0000ff00) >>  8));

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0,  (fg&0x000000ff)       );

+}

+

+static void 

+TIramdacLoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)

+{

+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

+    int i = 1024;

+

+    /* reset A9,A8 */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_ind_curs_ctrl, 0, 0x00); 

+    /* reset cursor RAM load address A7..A0 */

+    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_INDEX, 0x00, 0x00); 

+ 

+    while(i--) {

+	/* NOT_DONE: might need a delay here */

+	(*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_RAM_DATA, 0, *(src++));

+    }

+}

+

+static Bool 

+TIramdacUseHWCursor(ScreenPtr pScr, CursorPtr pCurs)

+{

+    return TRUE;

+}

+

+void

+TIramdacHWCursorInit(xf86CursorInfoPtr infoPtr)

+{

+    infoPtr->MaxWidth = 64;

+    infoPtr->MaxHeight = 64;

+    infoPtr->Flags = HARDWARE_CURSOR_BIT_ORDER_MSBFIRST |

+		     HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |

+		     HARDWARE_CURSOR_SOURCE_MASK_NOT_INTERLEAVED;

+    infoPtr->SetCursorColors = TIramdacSetCursorColors;

+    infoPtr->SetCursorPosition = TIramdacSetCursorPosition;

+    infoPtr->LoadCursorImage = TIramdacLoadCursorImage;

+    infoPtr->HideCursor = TIramdacHideCursor;

+    infoPtr->ShowCursor = TIramdacShowCursor;

+    infoPtr->UseHWCursor = TIramdacUseHWCursor;

+}

+

+void TIramdacLoadPalette(

+    ScrnInfoPtr pScrn, 

+    int numColors, 

+    int *indices,

+    LOCO *colors,

+    VisualPtr pVisual

+){

+    RamDacRecPtr hwp = RAMDACSCRPTR(pScrn);

+    int i, index, shift;

+

+    if (pScrn->depth == 16) {

+    for(i = 0; i < numColors; i++) {

+	index = indices[i];

+    	(*hwp->WriteAddress)(pScrn, index << 2);

+	(*hwp->WriteData)(pScrn, colors[index >> 1].red);

+	(*hwp->WriteData)(pScrn, colors[index].green);

+	(*hwp->WriteData)(pScrn, colors[index >> 1].blue);

+

+	if(index <= 31) {

+	    (*hwp->WriteAddress)(pScrn, index << 3);

+	    (*hwp->WriteData)(pScrn, colors[index].red);

+	    (*hwp->WriteData)(pScrn, colors[(index << 1) + 1].green);

+	    (*hwp->WriteData)(pScrn, colors[index].blue);

+	}

+    }

+} else {

+    shift = (pScrn->depth == 15) ? 3 : 0;

+

+    for(i = 0; i < numColors; i++) {

+	index = indices[i];

+    	(*hwp->WriteAddress)(pScrn, index << shift);

+	(*hwp->WriteData)(pScrn, colors[index].red);

+	(*hwp->WriteData)(pScrn, colors[index].green);

+	(*hwp->WriteData)(pScrn, colors[index].blue);

+    }

+}

+}

+

+TIramdacLoadPaletteProc *TIramdacLoadPaletteWeak(void) {

+    return TIramdacLoadPalette;

+}

diff --git a/xorg-server/hw/xfree86/ramdac/xf86Cursor.c b/xorg-server/hw/xfree86/ramdac/xf86Cursor.c
index 91b5795c3..421e35b51 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86Cursor.c
+++ b/xorg-server/hw/xfree86/ramdac/xf86Cursor.c
@@ -18,8 +18,7 @@
 #include "inputstr.h"

 extern InputInfo inputInfo;

 

-static int xf86CursorScreenKeyIndex;

-DevPrivateKey xf86CursorScreenKey = &xf86CursorScreenKeyIndex;

+DevPrivateKeyRec xf86CursorScreenKeyRec;

 

 /* sprite functions */

 

@@ -65,6 +64,9 @@ xf86InitCursor(
     if (!xf86InitHardwareCursor(pScreen, infoPtr))

 	return FALSE;

 

+    if (!dixRegisterPrivateKey(&xf86CursorScreenKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+

     ScreenPriv = calloc(1, sizeof(xf86CursorScreenRec));

     if (!ScreenPriv)

 	return FALSE;

diff --git a/xorg-server/hw/xfree86/ramdac/xf86CursorPriv.h b/xorg-server/hw/xfree86/ramdac/xf86CursorPriv.h
index 32be9c2f3..76e714b32 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86CursorPriv.h
+++ b/xorg-server/hw/xfree86/ramdac/xf86CursorPriv.h
@@ -1,50 +1,51 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#ifndef _XF86CURSORPRIV_H
-#define _XF86CURSORPRIV_H
-
-#include "xf86Cursor.h"
-#include "mipointrst.h"
-
-typedef struct {
-    Bool			SWCursor;
-    Bool			isUp;
-    Bool			showTransparent;
-    short			HotX;
-    short			HotY;
-    short			x;
-    short			y;
-    CursorPtr			CurrentCursor, CursorToRestore;
-    xf86CursorInfoPtr		CursorInfoPtr;
-    CloseScreenProcPtr          CloseScreen;
-    RecolorCursorProcPtr	RecolorCursor;
-    InstallColormapProcPtr	InstallColormap;
-    QueryBestSizeProcPtr	QueryBestSize;
-    miPointerSpriteFuncPtr	spriteFuncs;
-    Bool			PalettedCursor;
-    ColormapPtr			pInstalledMap;
-    Bool                	(*SwitchMode)(int, DisplayModePtr,int);
-    xf86EnableDisableFBAccessProc *EnableDisableFBAccess;
-    CursorPtr                   SavedCursor;
-
-    /* Number of requests to force HW cursor */
-    int				ForceHWCursorCount;
-    Bool			HWCursorForced;
-
-    pointer			transparentData;
-} xf86CursorScreenRec, *xf86CursorScreenPtr;
-
-void xf86SetCursor(ScreenPtr pScreen, CursorPtr pCurs, int x, int y);
-void xf86SetTransparentCursor(ScreenPtr pScreen);
-void xf86MoveCursor(ScreenPtr pScreen, int x, int y);
-void xf86RecolorCursor(ScreenPtr pScreen, CursorPtr pCurs, Bool displayed);
-Bool xf86InitHardwareCursor(ScreenPtr pScreen, xf86CursorInfoPtr infoPtr);
-
-CARD32 xf86ReverseBitOrder(CARD32 data);
-
-extern _X_EXPORT DevPrivateKey xf86CursorScreenKey;
-
-#endif /* _XF86CURSORPRIV_H */
+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#ifndef _XF86CURSORPRIV_H

+#define _XF86CURSORPRIV_H

+

+#include "xf86Cursor.h"

+#include "mipointrst.h"

+

+typedef struct {

+    Bool			SWCursor;

+    Bool			isUp;

+    Bool			showTransparent;

+    short			HotX;

+    short			HotY;

+    short			x;

+    short			y;

+    CursorPtr			CurrentCursor, CursorToRestore;

+    xf86CursorInfoPtr		CursorInfoPtr;

+    CloseScreenProcPtr          CloseScreen;

+    RecolorCursorProcPtr	RecolorCursor;

+    InstallColormapProcPtr	InstallColormap;

+    QueryBestSizeProcPtr	QueryBestSize;

+    miPointerSpriteFuncPtr	spriteFuncs;

+    Bool			PalettedCursor;

+    ColormapPtr			pInstalledMap;

+    Bool                	(*SwitchMode)(int, DisplayModePtr,int);

+    xf86EnableDisableFBAccessProc *EnableDisableFBAccess;

+    CursorPtr                   SavedCursor;

+

+    /* Number of requests to force HW cursor */

+    int				ForceHWCursorCount;

+    Bool			HWCursorForced;

+

+    pointer			transparentData;

+} xf86CursorScreenRec, *xf86CursorScreenPtr;

+

+void xf86SetCursor(ScreenPtr pScreen, CursorPtr pCurs, int x, int y);

+void xf86SetTransparentCursor(ScreenPtr pScreen);

+void xf86MoveCursor(ScreenPtr pScreen, int x, int y);

+void xf86RecolorCursor(ScreenPtr pScreen, CursorPtr pCurs, Bool displayed);

+Bool xf86InitHardwareCursor(ScreenPtr pScreen, xf86CursorInfoPtr infoPtr);

+

+CARD32 xf86ReverseBitOrder(CARD32 data);

+

+extern _X_EXPORT DevPrivateKeyRec xf86CursorScreenKeyRec;

+#define xf86CursorScreenKey (&xf86CursorScreenKeyRec)

+

+#endif /* _XF86CURSORPRIV_H */

diff --git a/xorg-server/hw/xfree86/ramdac/xf86RamDac.c b/xorg-server/hw/xfree86/ramdac/xf86RamDac.c
index 25d450c07..a170444a9 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86RamDac.c
+++ b/xorg-server/hw/xfree86/ramdac/xf86RamDac.c
@@ -82,7 +82,7 @@ RamDacInit(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPriv)
 	((RamDacScreenRecPtr) (pScrn)->privates[RamDacGetScreenIndex()].ptr);

     ramdacScrPtr->RamDacRec = ramdacPriv;

 

-    return(TRUE);

+    return TRUE;

 }

 

 void

@@ -132,12 +132,10 @@ RamDacFreeRec(ScrnInfoPtr pScrn)
     ramdacScrPtr = ((RamDacScreenRecPtr)

 				(pScrn)->privates[RamDacGetScreenIndex()].ptr);

     

-    if (ramdacHWPtr)

-	free(ramdacHWPtr);

+    free(ramdacHWPtr);

     ramdacHWPtr = NULL;

 

-    if (ramdacScrPtr)

-	free(ramdacScrPtr);

+    free(ramdacScrPtr);

     ramdacScrPtr = NULL;

 }

 

diff --git a/xorg-server/hw/xfree86/shadowfb/shadow.c b/xorg-server/hw/xfree86/shadowfb/shadow.c
index 9e847f4d2..4c7551de9 100644
--- a/xorg-server/hw/xfree86/shadowfb/shadow.c
+++ b/xorg-server/hw/xfree86/shadowfb/shadow.c
@@ -84,11 +84,11 @@ typedef struct {
    GCFuncs *funcs;

 } ShadowGCRec, *ShadowGCPtr;

 

+static DevPrivateKeyRec ShadowScreenKeyRec;

+#define ShadowScreenKey (&ShadowScreenKeyRec)

 

-static int ShadowScreenKeyIndex;

-static DevPrivateKey ShadowScreenKey = &ShadowScreenKeyIndex;

-static int ShadowGCKeyIndex;

-static DevPrivateKey ShadowGCKey = &ShadowGCKeyIndex;

+static DevPrivateKeyRec ShadowGCKeyRec;

+#define ShadowGCKey (&ShadowGCKeyRec)

 

 #define GET_SCREEN_PRIVATE(pScreen) \

     (ShadowScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, ShadowScreenKey)

@@ -162,7 +162,10 @@ ShadowFBInit2 (
 

     if(!preRefreshArea && !postRefreshArea) return FALSE;

     

-    if(!dixRequestPrivate(ShadowGCKey, sizeof(ShadowGCRec)))

+    if (!dixRegisterPrivateKey(&ShadowScreenKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+

+    if(!dixRegisterPrivateKey(&ShadowGCKeyRec, PRIVATE_GC, sizeof(ShadowGCRec)))

 	return FALSE;

 

     if(!(pPriv = (ShadowScreenPtr)malloc(sizeof(ShadowScreenRec))))

@@ -272,18 +275,18 @@ ShadowCopyWindow(
     RegionRec rgnDst;

 

     if (pPriv->vtSema) {

-        REGION_NULL(pWin->drawable.pScreen, &rgnDst);

-	REGION_COPY(pWin->drawable.pScreen, &rgnDst, prgn);

+        RegionNull(&rgnDst);

+	RegionCopy(&rgnDst, prgn);

         

-        REGION_TRANSLATE(pWin->drawable.pScreen, &rgnDst,

+        RegionTranslate(&rgnDst,

                          pWin->drawable.x - ptOldOrg.x,

                          pWin->drawable.y - ptOldOrg.y);

-        REGION_INTERSECT(pScreen, &rgnDst, &pWin->borderClip, &rgnDst);

-        if ((num = REGION_NUM_RECTS(&rgnDst))) {

+        RegionIntersect(&rgnDst, &pWin->borderClip, &rgnDst);

+        if ((num = RegionNumRects(&rgnDst))) {

             if(pPriv->preRefresh)

-                (*pPriv->preRefresh)(pPriv->pScrn, num, REGION_RECTS(&rgnDst));

+                (*pPriv->preRefresh)(pPriv->pScrn, num, RegionRects(&rgnDst));

         } else {

-            REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);

+            RegionUninit(&rgnDst);

         }

     }

     

@@ -293,8 +296,8 @@ ShadowCopyWindow(
     

     if (num) {

         if (pPriv->postRefresh)

-            (*pPriv->postRefresh)(pPriv->pScrn, num, REGION_RECTS(&rgnDst));

-        REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);

+            (*pPriv->postRefresh)(pPriv->pScrn, num, RegionRects(&rgnDst));

+        RegionUninit(&rgnDst);

     }

 }

 

@@ -1353,38 +1356,32 @@ ShadowFontToBox(BoxPtr BB, DrawablePtr pDrawable, GCPtr pGC, int x, int y,
 	}

 	right += pFont->info.maxbounds.rightSideBearing;

 	BB->x1 =

-	    max(pDrawable->x + x - left, (REGION_EXTENTS(pGC->pScreen,

-		&((WindowPtr) pDrawable)->winSize))->x1);

+	    max(pDrawable->x + x - left,

+		RegionExtents(&((WindowPtr) pDrawable)->winSize)->x1);

 	BB->y1 =

 	    max(pDrawable->y + y - ascent,

-	    (REGION_EXTENTS(pGC->pScreen,

-             &((WindowPtr) pDrawable)->winSize))->y1);

+		RegionExtents(&((WindowPtr) pDrawable)->winSize)->y1);

 	BB->x2 =

 	    min(pDrawable->x + x + right,

-	    (REGION_EXTENTS(pGC->pScreen,

-             &((WindowPtr) pDrawable)->winSize))->x2);

+		RegionExtents(&((WindowPtr) pDrawable)->winSize)->x2);

 	BB->y2 =

 	    min(pDrawable->y + y + descent,

-	    (REGION_EXTENTS(pGC->pScreen,

-             &((WindowPtr) pDrawable)->winSize))->y2);

+		RegionExtents(&((WindowPtr) pDrawable)->winSize)->y2);

     } else {

     	ShadowTextExtent(pFont, count, chars, wide ? (FONTLASTROW(pFont) == 0)

                          ? Linear16Bit : TwoD16Bit : Linear8Bit, BB);

 	BB->x1 =

-	    max(pDrawable->x + x + BB->x1, (REGION_EXTENTS(pGC->pScreen,

-		&((WindowPtr) pDrawable)->winSize))->x1);

+	    max(pDrawable->x + x + BB->x1,

+		RegionExtents(&((WindowPtr) pDrawable)->winSize)->x1);

 	BB->y1 =

 	    max(pDrawable->y + y + BB->y1,

-	    (REGION_EXTENTS(pGC->pScreen,

-             &((WindowPtr) pDrawable)->winSize))->y1);

+		RegionExtents(&((WindowPtr) pDrawable)->winSize)->y1);

 	BB->x2 =

 	    min(pDrawable->x + x + BB->x2,

-	    (REGION_EXTENTS(pGC->pScreen,

-	     &((WindowPtr) pDrawable)->winSize))->x2);

+		RegionExtents(&((WindowPtr) pDrawable)->winSize)->x2);

 	BB->y2 =

 	    min(pDrawable->y + y + BB->y2,

-	    (REGION_EXTENTS(pGC->pScreen, 

-	     &((WindowPtr) pDrawable)->winSize))->y2);

+		RegionExtents(&((WindowPtr) pDrawable)->winSize)->y2);

     }

 }

 

diff --git a/xorg-server/hw/xfree86/utils/gtf/gtf.c b/xorg-server/hw/xfree86/utils/gtf/gtf.c
index 8ce93276a..840626c66 100644
--- a/xorg-server/hw/xfree86/utils/gtf/gtf.c
+++ b/xorg-server/hw/xfree86/utils/gtf/gtf.c
@@ -1,741 +1,741 @@
-/* gtf.c  Generate mode timings using the GTF Timing Standard
- *
- * gcc gtf.c -o gtf -lm -Wall
- *
- * Copyright (c) 2001, Andy Ritger  aritger@nvidia.com
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * o Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * o Redistributions in binary form must reproduce the above copyright
- *   notice, this list of conditions and the following disclaimer
- *   in the documentation and/or other materials provided with the
- *   distribution.
- * o Neither the name of NVIDIA nor the names of its contributors
- *   may be used to endorse or promote products derived from this
- *   software without specific prior written permission.
- *
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
- * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- * 
- *
- * This program is based on the Generalized Timing Formula(GTF TM)
- * Standard Version: 1.0, Revision: 1.0
- *
- * The GTF Document contains the following Copyright information:
- *
- * Copyright (c) 1994, 1995, 1996 - Video Electronics Standards
- * Association. Duplication of this document within VESA member
- * companies for review purposes is permitted. All other rights
- * reserved.
- *
- * While every precaution has been taken in the preparation
- * of this standard, the Video Electronics Standards Association and
- * its contributors assume no responsibility for errors or omissions,
- * and make no warranties, expressed or implied, of functionality
- * of suitability for any purpose. The sample code contained within
- * this standard may be used without restriction.
- *
- * 
- *
- * The GTF EXCEL(TM) SPREADSHEET, a sample (and the definitive)
- * implementation of the GTF Timing Standard, is available at:
- *
- * ftp://ftp.vesa.org/pub/GTF/GTF_V1R1.xls
- *
- *
- *
- * This program takes a desired resolution and vertical refresh rate,
- * and computes mode timings according to the GTF Timing Standard.
- * These mode timings can then be formatted as an XServer modeline
- * or a mode description for use by fbset(8).
- *
- *
- *
- * NOTES:
- *
- * The GTF allows for computation of "margins" (the visible border
- * surrounding the addressable video); on most non-overscan type
- * systems, the margin period is zero.  I've implemented the margin
- * computations but not enabled it because 1) I don't really have
- * any experience with this, and 2) neither XServer modelines nor
- * fbset fb.modes provide an obvious way for margin timings to be
- * included in their mode descriptions (needs more investigation).
- * 
- * The GTF provides for computation of interlaced mode timings;
- * I've implemented the computations but not enabled them, yet.
- * I should probably enable and test this at some point.
- *
- * 
- *
- * TODO:
- *
- * o Add support for interlaced modes.
- *
- * o Implement the other portions of the GTF: compute mode timings
- *   given either the desired pixel clock or the desired horizontal
- *   frequency.
- *
- * o It would be nice if this were more general purpose to do things
- *   outside the scope of the GTF: like generate double scan mode
- *   timings, for example.
- *   
- * o Printing digits to the right of the decimal point when the
- *   digits are 0 annoys me.
- *
- * o Error checking.
- *
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-# include <xorg-config.h>
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-#define MARGIN_PERCENT    1.8   /* % of active vertical image                */
-#define CELL_GRAN         8.0   /* assumed character cell granularity        */
-#define MIN_PORCH         1     /* minimum front porch                       */
-#define V_SYNC_RQD        3     /* width of vsync in lines                   */
-#define H_SYNC_PERCENT    8.0   /* width of hsync as % of total line         */
-#define MIN_VSYNC_PLUS_BP 550.0 /* min time of vsync + back porch (microsec) */
-#define M                 600.0 /* blanking formula gradient                 */
-#define C                 40.0  /* blanking formula offset                   */
-#define K                 128.0 /* blanking formula scaling factor           */
-#define J                 20.0  /* blanking formula scaling factor           */
-
-/* C' and M' are part of the Blanking Duty Cycle computation */
-
-#define C_PRIME           (((C - J) * K/256.0) + J)
-#define M_PRIME           (K/256.0 * M)
-
-
-/* struct definitions */
-
-typedef struct __mode
-{
-    int hr, hss, hse, hfl;
-    int vr, vss, vse, vfl;
-    float pclk, h_freq, v_freq;
-} mode;
-
-
-typedef struct __options
-{
-    int x, y;
-    int xorgmode, fbmode;
-    float v_freq;
-} options;
-
-
-
-
-/* prototypes */
-
-void print_value(int n, char *name, float val);
-void print_xf86_mode (mode *m);
-void print_fb_mode (mode *m);
-mode *vert_refresh (int h_pixels, int v_lines, float freq,
-                    int interlaced, int margins);
-options *parse_command_line (int argc, char *argv[]);
-
-
-
-
-/*
- * print_value() - print the result of the named computation; this is
- * useful when comparing against the GTF EXCEL spreadsheet.
- */
-
-int global_verbose = 0;
-
-void print_value(int n, char *name, float val)
-{
-    if (global_verbose) {
-        printf("%2d: %-27s: %15f\n", n, name, val);
-    }
-}
-
-
-
-/* print_xf86_mode() - print the XServer modeline, given mode timings. */
-
-void print_xf86_mode (mode *m)
-{
-    printf ("\n");
-    printf ("  # %dx%d @ %.2f Hz (GTF) hsync: %.2f kHz; pclk: %.2f MHz\n",
-            m->hr, m->vr, m->v_freq, m->h_freq, m->pclk);
-    
-    printf ("  Modeline \"%dx%d_%.2f\"  %.2f"
-            "  %d %d %d %d"
-            "  %d %d %d %d"
-            "  -HSync +Vsync\n\n",
-            m->hr, m->vr, m->v_freq, m->pclk,
-            m->hr, m->hss, m->hse, m->hfl,
-            m->vr, m->vss, m->vse, m->vfl);
-    
-}
-
-
-
-/*
- * print_fb_mode() - print a mode description in fbset(8) format;
- * see the fb.modes(8) manpage.  The timing description used in
- * this is rather odd; they use "left and right margin" to refer
- * to the portion of the hblank before and after the sync pulse
- * by conceptually wrapping the portion of the blank after the pulse
- * to infront of the visible region; ie:
- * 
- *
- * Timing description I'm accustomed to:
- *
- *
- *
- *     <--------1--------> <--2--> <--3--> <--4-->
- *                                _________
- *    |-------------------|_______|       |_______
- *
- *                        R       SS      SE     FL
- *       
- * 1: visible image
- * 2: blank before sync (aka front porch)
- * 3: sync pulse
- * 4: blank after sync (aka back porch)
- * R: Resolution
- * SS: Sync Start
- * SE: Sync End
- * FL: Frame Length
- *
- *
- * But the fb.modes format is:
- *
- *
- *    <--4--> <--------1--------> <--2--> <--3--> 
- *                                       _________
- *    _______|-------------------|_______|       |
- *  
- * The fb.modes(8) manpage refers to <4> and <2> as the left and
- * right "margin" (as well as upper and lower margin in the vertical
- * direction) -- note that this has nothing to do with the term
- * "margin" used in the GTF Timing Standard.
- *
- * XXX always prints the 32 bit mode -- should I provide a command
- * line option to specify the bpp?  It's simple enough for a user
- * to edit the mode description after it's generated.
- */
-
-void print_fb_mode (mode *m)
-{
-    printf ("\n");
-    printf ("mode \"%dx%d %.2fHz 32bit (GTF)\"\n",
-            m->hr, m->vr, m->v_freq);
-    printf ("    # PCLK: %.2f MHz, H: %.2f kHz, V: %.2f Hz\n",
-            m->pclk, m->h_freq, m->v_freq);
-    printf ("    geometry %d %d %d %d 32\n",
-            m->hr, m->vr, m->hr, m->vr);
-    printf ("    timings %d %d %d %d %d %d %d\n",
-            (int) rint(1000000.0/m->pclk),/* pixclock in picoseconds */
-            m->hfl - m->hse,              /* left margin (in pixels) */
-            m->hss - m->hr,               /* right margin (in pixels) */
-            m->vfl - m->vse,              /* upper margin (in pixel lines) */
-            m->vss - m->vr,               /* lower margin (in pixel lines) */
-            m->hse - m->hss,              /* horizontal sync length (pixels) */
-            m->vse - m->vss);             /* vert sync length (pixel lines) */
-    printf ("    hsync low\n");
-    printf ("    vsync high\n");
-    printf ("endmode\n\n");
-    
-}
-
-
-
-
-/*
- * vert_refresh() - as defined by the GTF Timing Standard, compute the
- * Stage 1 Parameters using the vertical refresh frequency.  In other
- * words: input a desired resolution and desired refresh rate, and
- * output the GTF mode timings.
- *
- * XXX All the code is in place to compute interlaced modes, but I don't
- * feel like testing it right now.
- *
- * XXX margin computations are implemented but not tested (nor used by
- * XServer of fbset mode descriptions, from what I can tell).
- */
-
-mode *vert_refresh (int h_pixels, int v_lines, float freq,
-                    int interlaced, int margins)
-{
-    float h_pixels_rnd;
-    float v_lines_rnd;
-    float v_field_rate_rqd;
-    float top_margin;
-    float bottom_margin;
-    float interlace;
-    float h_period_est;
-    float vsync_plus_bp;
-    float v_back_porch;
-    float total_v_lines;
-    float v_field_rate_est;
-    float h_period;
-    float v_field_rate;
-    float v_frame_rate;
-    float left_margin;
-    float right_margin;
-    float total_active_pixels;
-    float ideal_duty_cycle;
-    float h_blank;
-    float total_pixels;
-    float pixel_freq;
-    float h_freq;
-
-    float h_sync;
-    float h_front_porch;
-    float v_odd_front_porch_lines;
-
-    mode *m = (mode*) malloc (sizeof (mode));
-    
-    
-    /*  1. In order to give correct results, the number of horizontal
-     *  pixels requested is first processed to ensure that it is divisible
-     *  by the character size, by rounding it to the nearest character
-     *  cell boundary:
-     *
-     *  [H PIXELS RND] = ((ROUND([H PIXELS]/[CELL GRAN RND],0))*[CELLGRAN RND])
-     */
-    
-    h_pixels_rnd = rint((float) h_pixels / CELL_GRAN) * CELL_GRAN;
-    
-    print_value(1, "[H PIXELS RND]", h_pixels_rnd);
-
-    
-    /*  2. If interlace is requested, the number of vertical lines assumed
-     *  by the calculation must be halved, as the computation calculates
-     *  the number of vertical lines per field. In either case, the
-     *  number of lines is rounded to the nearest integer.
-     *   
-     *  [V LINES RND] = IF([INT RQD?]="y", ROUND([V LINES]/2,0),
-     *                                     ROUND([V LINES],0))
-     */
-
-    v_lines_rnd = interlaced ?
-            rint((float) v_lines) / 2.0 :
-            rint((float) v_lines);
-    
-    print_value(2, "[V LINES RND]", v_lines_rnd);
-    
-    
-    /*  3. Find the frame rate required:
-     *
-     *  [V FIELD RATE RQD] = IF([INT RQD?]="y", [I/P FREQ RQD]*2,
-     *                                          [I/P FREQ RQD])
-     */
-
-    v_field_rate_rqd = interlaced ? (freq * 2.0) : (freq);
-
-    print_value(3, "[V FIELD RATE RQD]", v_field_rate_rqd);
-    
-
-    /*  4. Find number of lines in Top margin:
-     *
-     *  [TOP MARGIN (LINES)] = IF([MARGINS RQD?]="Y",
-     *          ROUND(([MARGIN%]/100*[V LINES RND]),0),
-     *          0)
-     */
-
-    top_margin = margins ? rint(MARGIN_PERCENT / 100.0 * v_lines_rnd) : (0.0);
-
-    print_value(4, "[TOP MARGIN (LINES)]", top_margin);
-    
-
-    /*  5. Find number of lines in Bottom margin:
-     *
-     *  [BOT MARGIN (LINES)] = IF([MARGINS RQD?]="Y",
-     *          ROUND(([MARGIN%]/100*[V LINES RND]),0),
-     *          0)
-     */
-
-    bottom_margin = margins ? rint(MARGIN_PERCENT/100.0 * v_lines_rnd) : (0.0);
-
-    print_value(5, "[BOT MARGIN (LINES)]", bottom_margin);
-
-    
-    /*  6. If interlace is required, then set variable [INTERLACE]=0.5:
-     *   
-     *  [INTERLACE]=(IF([INT RQD?]="y",0.5,0))
-     */
-
-    interlace = interlaced ? 0.5 : 0.0;
-
-    print_value(6, "[INTERLACE]", interlace);
-    
-
-    /*  7. Estimate the Horizontal period
-     *
-     *  [H PERIOD EST] = ((1/[V FIELD RATE RQD]) - [MIN VSYNC+BP]/1000000) /
-     *                    ([V LINES RND] + (2*[TOP MARGIN (LINES)]) +
-     *                     [MIN PORCH RND]+[INTERLACE]) * 1000000
-     */
-
-    h_period_est = (((1.0/v_field_rate_rqd) - (MIN_VSYNC_PLUS_BP/1000000.0))
-                    / (v_lines_rnd + (2*top_margin) + MIN_PORCH + interlace)
-                    * 1000000.0);
-
-    print_value(7, "[H PERIOD EST]", h_period_est);
-    
-
-    /*  8. Find the number of lines in V sync + back porch:
-     *
-     *  [V SYNC+BP] = ROUND(([MIN VSYNC+BP]/[H PERIOD EST]),0)
-     */
-
-    vsync_plus_bp = rint(MIN_VSYNC_PLUS_BP/h_period_est);
-
-    print_value(8, "[V SYNC+BP]", vsync_plus_bp);
-    
-    
-    /*  9. Find the number of lines in V back porch alone:
-     *
-     *  [V BACK PORCH] = [V SYNC+BP] - [V SYNC RND]
-     *
-     *  XXX is "[V SYNC RND]" a typo? should be [V SYNC RQD]?
-     */
-    
-    v_back_porch = vsync_plus_bp - V_SYNC_RQD;
-    
-    print_value(9, "[V BACK PORCH]", v_back_porch);
-    
-
-    /*  10. Find the total number of lines in Vertical field period:
-     *
-     *  [TOTAL V LINES] = [V LINES RND] + [TOP MARGIN (LINES)] +
-     *                    [BOT MARGIN (LINES)] + [V SYNC+BP] + [INTERLACE] +
-     *                    [MIN PORCH RND]
-     */
-
-    total_v_lines = v_lines_rnd + top_margin + bottom_margin + vsync_plus_bp +
-        interlace + MIN_PORCH;
-    
-    print_value(10, "[TOTAL V LINES]", total_v_lines);
-    
-
-    /*  11. Estimate the Vertical field frequency:
-     *
-     *  [V FIELD RATE EST] = 1 / [H PERIOD EST] / [TOTAL V LINES] * 1000000
-     */
-
-    v_field_rate_est = 1.0 / h_period_est / total_v_lines * 1000000.0;
-    
-    print_value(11, "[V FIELD RATE EST]", v_field_rate_est);
-    
-
-    /*  12. Find the actual horizontal period:
-     *
-     *  [H PERIOD] = [H PERIOD EST] / ([V FIELD RATE RQD] / [V FIELD RATE EST])
-     */
-
-    h_period = h_period_est / (v_field_rate_rqd / v_field_rate_est);
-    
-    print_value(12, "[H PERIOD]", h_period);
-    
-
-    /*  13. Find the actual Vertical field frequency:
-     *
-     *  [V FIELD RATE] = 1 / [H PERIOD] / [TOTAL V LINES] * 1000000
-     */
-
-    v_field_rate = 1.0 / h_period / total_v_lines * 1000000.0;
-
-    print_value(13, "[V FIELD RATE]", v_field_rate);
-    
-
-    /*  14. Find the Vertical frame frequency:
-     *
-     *  [V FRAME RATE] = (IF([INT RQD?]="y", [V FIELD RATE]/2, [V FIELD RATE]))
-     */
-
-    v_frame_rate = interlaced ? v_field_rate / 2.0 : v_field_rate;
-
-    print_value(14, "[V FRAME RATE]", v_frame_rate);
-    
-
-    /*  15. Find number of pixels in left margin:
-     *
-     *  [LEFT MARGIN (PIXELS)] = (IF( [MARGINS RQD?]="Y",
-     *          (ROUND( ([H PIXELS RND] * [MARGIN%] / 100 /
-     *                   [CELL GRAN RND]),0)) * [CELL GRAN RND],
-     *          0))
-     */
-
-    left_margin = margins ?
-        rint(h_pixels_rnd * MARGIN_PERCENT / 100.0 / CELL_GRAN) * CELL_GRAN :
-        0.0;
-    
-    print_value(15, "[LEFT MARGIN (PIXELS)]", left_margin);
-    
-
-    /*  16. Find number of pixels in right margin:
-     *
-     *  [RIGHT MARGIN (PIXELS)] = (IF( [MARGINS RQD?]="Y",
-     *          (ROUND( ([H PIXELS RND] * [MARGIN%] / 100 /
-     *                   [CELL GRAN RND]),0)) * [CELL GRAN RND],
-     *          0))
-     */
-    
-    right_margin = margins ?
-        rint(h_pixels_rnd * MARGIN_PERCENT / 100.0 / CELL_GRAN) * CELL_GRAN :
-        0.0;
-    
-    print_value(16, "[RIGHT MARGIN (PIXELS)]", right_margin);
-    
-
-    /*  17. Find total number of active pixels in image and left and right
-     *  margins:
-     *
-     *  [TOTAL ACTIVE PIXELS] = [H PIXELS RND] + [LEFT MARGIN (PIXELS)] +
-     *                          [RIGHT MARGIN (PIXELS)]
-     */
-
-    total_active_pixels = h_pixels_rnd + left_margin + right_margin;
-    
-    print_value(17, "[TOTAL ACTIVE PIXELS]", total_active_pixels);
-    
-    
-    /*  18. Find the ideal blanking duty cycle from the blanking duty cycle
-     *  equation:
-     *
-     *  [IDEAL DUTY CYCLE] = [C'] - ([M']*[H PERIOD]/1000)
-     */
-
-    ideal_duty_cycle = C_PRIME - (M_PRIME * h_period / 1000.0);
-    
-    print_value(18, "[IDEAL DUTY CYCLE]", ideal_duty_cycle);
-    
-
-    /*  19. Find the number of pixels in the blanking time to the nearest
-     *  double character cell:
-     *
-     *  [H BLANK (PIXELS)] = (ROUND(([TOTAL ACTIVE PIXELS] *
-     *                               [IDEAL DUTY CYCLE] /
-     *                               (100-[IDEAL DUTY CYCLE]) /
-     *                               (2*[CELL GRAN RND])), 0))
-     *                       * (2*[CELL GRAN RND])
-     */
-
-    h_blank = rint(total_active_pixels *
-                   ideal_duty_cycle /
-                   (100.0 - ideal_duty_cycle) /
-                   (2.0 * CELL_GRAN)) * (2.0 * CELL_GRAN);
-    
-    print_value(19, "[H BLANK (PIXELS)]", h_blank);
-    
-
-    /*  20. Find total number of pixels:
-     *
-     *  [TOTAL PIXELS] = [TOTAL ACTIVE PIXELS] + [H BLANK (PIXELS)]
-     */
-
-    total_pixels = total_active_pixels + h_blank;
-    
-    print_value(20, "[TOTAL PIXELS]", total_pixels);
-    
-
-    /*  21. Find pixel clock frequency:
-     *
-     *  [PIXEL FREQ] = [TOTAL PIXELS] / [H PERIOD]
-     */
-    
-    pixel_freq = total_pixels / h_period;
-    
-    print_value(21, "[PIXEL FREQ]", pixel_freq);
-    
-
-    /*  22. Find horizontal frequency:
-     *
-     *  [H FREQ] = 1000 / [H PERIOD]
-     */
-
-    h_freq = 1000.0 / h_period;
-    
-    print_value(22, "[H FREQ]", h_freq);
-    
-
-
-    /* Stage 1 computations are now complete; I should really pass
-       the results to another function and do the Stage 2
-       computations, but I only need a few more values so I'll just
-       append the computations here for now */
-
-    
-
-    /*  17. Find the number of pixels in the horizontal sync period:
-     *
-     *  [H SYNC (PIXELS)] =(ROUND(([H SYNC%] / 100 * [TOTAL PIXELS] /
-     *                             [CELL GRAN RND]),0))*[CELL GRAN RND]
-     */
-
-    h_sync = rint(H_SYNC_PERCENT/100.0 * total_pixels / CELL_GRAN) * CELL_GRAN;
-
-    print_value(17, "[H SYNC (PIXELS)]", h_sync);
-    
-
-    /*  18. Find the number of pixels in the horizontal front porch period:
-     *
-     *  [H FRONT PORCH (PIXELS)] = ([H BLANK (PIXELS)]/2)-[H SYNC (PIXELS)]
-     */
-
-    h_front_porch = (h_blank / 2.0) - h_sync;
-
-    print_value(18, "[H FRONT PORCH (PIXELS)]", h_front_porch);
-    
-    
-    /*  36. Find the number of lines in the odd front porch period:
-     *
-     *  [V ODD FRONT PORCH(LINES)]=([MIN PORCH RND]+[INTERLACE])
-     */
-    
-    v_odd_front_porch_lines = MIN_PORCH + interlace;
-    
-    print_value(36, "[V ODD FRONT PORCH(LINES)]", v_odd_front_porch_lines);
-    
-
-    /* finally, pack the results in the mode struct */
-    
-    m->hr  = (int) (h_pixels_rnd);
-    m->hss = (int) (h_pixels_rnd + h_front_porch);
-    m->hse = (int) (h_pixels_rnd + h_front_porch + h_sync);
-    m->hfl = (int) (total_pixels);
-
-    m->vr  = (int) (v_lines_rnd);
-    m->vss = (int) (v_lines_rnd + v_odd_front_porch_lines);
-    m->vse = (int) (int) (v_lines_rnd + v_odd_front_porch_lines + V_SYNC_RQD);
-    m->vfl = (int) (total_v_lines);
-
-    m->pclk   = pixel_freq;
-    m->h_freq = h_freq;
-    m->v_freq = freq;
-
-    return (m);
-    
-}
-
-
-
-
-/*
- * parse_command_line() - parse the command line and return an
- * alloced structure containing the results.  On error print usage
- * and return NULL.
- */ 
-
-options *parse_command_line (int argc, char *argv[])
-{
-    int n;
-
-    options *o = (options *) calloc (1, sizeof (options));
-
-    if (argc < 4) goto bad_option;
-
-    o->x = atoi (argv[1]);
-    o->y = atoi (argv[2]);
-    o->v_freq = atof (argv[3]);
-
-    /* XXX should check for errors in the above */
-    
-    n = 4;
-
-    while (n < argc) {
-        if ((strcmp (argv[n], "-v") == 0) ||
-            (strcmp (argv[n], "--verbose") == 0)) {
-            global_verbose = 1;
-        } else if ((strcmp (argv[n], "-f") == 0) ||
-                   (strcmp (argv[n], "--fbmode") == 0)) {
-            o->fbmode = 1;
-        } else if ((strcmp (argv[n], "-x") == 0) ||
-		   (strcmp (argv[n], "--xorgmode") == 0) ||
-                   (strcmp (argv[n], "--xf86mode") == 0)) {
-            o->xorgmode = 1;
-        } else {
-            goto bad_option;
-        }
-        
-        n++;
-    }
-
-    /* if neither xorgmode nor fbmode were requested, default to
-       xorgmode */
-
-    if (!o->fbmode && !o->xorgmode) o->xorgmode = 1;
-    
-    return (o);
-    
- bad_option:
-
-    fprintf (stderr, "\n");
-    fprintf (stderr, "usage: %s x y refresh [-v|--verbose] "
-             "[-f|--fbmode] [-x|--xorgmode]\n", argv[0]);
-
-    fprintf (stderr, "\n");
-    
-    fprintf (stderr, "            x : the desired horizontal "
-             "resolution (required)\n");
-    fprintf (stderr, "            y : the desired vertical "
-             "resolution (required)\n");
-    fprintf (stderr, "      refresh : the desired refresh "
-             "rate (required)\n");
-    fprintf (stderr, " -v|--verbose : enable verbose printouts "
-             "(traces each step of the computation)\n");
-    fprintf (stderr, "  -f|--fbmode : output an fbset(8)-style mode "
-             "description\n");
-    fprintf (stderr, " -x|--xorgmode : output an "__XSERVERNAME__"-style mode "
-             "description (this is the default\n"
-             "                if no mode description is requested)\n");
-    
-    fprintf (stderr, "\n");
-    
-    free (o);
-    return (NULL);
-
-}
-
-
-
-int main (int argc, char *argv[])
-{
-    mode *m;
-    options *o;
-
-    o = parse_command_line (argc, argv);
-    if (!o) exit (1);
-    
-    m = vert_refresh (o->x, o->y, o->v_freq, 0, 0);
-    if (!m) exit (1);
-
-    if (o->xorgmode)
-        print_xf86_mode(m);
-    
-    if (o->fbmode)
-        print_fb_mode(m);
-    
-    return 0;
-    
-}
+/* gtf.c  Generate mode timings using the GTF Timing Standard

+ *

+ * gcc gtf.c -o gtf -lm -Wall

+ *

+ * Copyright (c) 2001, Andy Ritger  aritger@nvidia.com

+ * All rights reserved.

+ * 

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 

+ * o Redistributions of source code must retain the above copyright

+ *   notice, this list of conditions and the following disclaimer.

+ * o Redistributions in binary form must reproduce the above copyright

+ *   notice, this list of conditions and the following disclaimer

+ *   in the documentation and/or other materials provided with the

+ *   distribution.

+ * o Neither the name of NVIDIA nor the names of its contributors

+ *   may be used to endorse or promote products derived from this

+ *   software without specific prior written permission.

+ *

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT

+ * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL

+ * THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

+ * POSSIBILITY OF SUCH DAMAGE.

+ *

+ * 

+ *

+ * This program is based on the Generalized Timing Formula(GTF TM)

+ * Standard Version: 1.0, Revision: 1.0

+ *

+ * The GTF Document contains the following Copyright information:

+ *

+ * Copyright (c) 1994, 1995, 1996 - Video Electronics Standards

+ * Association. Duplication of this document within VESA member

+ * companies for review purposes is permitted. All other rights

+ * reserved.

+ *

+ * While every precaution has been taken in the preparation

+ * of this standard, the Video Electronics Standards Association and

+ * its contributors assume no responsibility for errors or omissions,

+ * and make no warranties, expressed or implied, of functionality

+ * of suitability for any purpose. The sample code contained within

+ * this standard may be used without restriction.

+ *

+ * 

+ *

+ * The GTF EXCEL(TM) SPREADSHEET, a sample (and the definitive)

+ * implementation of the GTF Timing Standard, is available at:

+ *

+ * ftp://ftp.vesa.org/pub/GTF/GTF_V1R1.xls

+ *

+ *

+ *

+ * This program takes a desired resolution and vertical refresh rate,

+ * and computes mode timings according to the GTF Timing Standard.

+ * These mode timings can then be formatted as an XServer modeline

+ * or a mode description for use by fbset(8).

+ *

+ *

+ *

+ * NOTES:

+ *

+ * The GTF allows for computation of "margins" (the visible border

+ * surrounding the addressable video); on most non-overscan type

+ * systems, the margin period is zero.  I've implemented the margin

+ * computations but not enabled it because 1) I don't really have

+ * any experience with this, and 2) neither XServer modelines nor

+ * fbset fb.modes provide an obvious way for margin timings to be

+ * included in their mode descriptions (needs more investigation).

+ * 

+ * The GTF provides for computation of interlaced mode timings;

+ * I've implemented the computations but not enabled them, yet.

+ * I should probably enable and test this at some point.

+ *

+ * 

+ *

+ * TODO:

+ *

+ * o Add support for interlaced modes.

+ *

+ * o Implement the other portions of the GTF: compute mode timings

+ *   given either the desired pixel clock or the desired horizontal

+ *   frequency.

+ *

+ * o It would be nice if this were more general purpose to do things

+ *   outside the scope of the GTF: like generate double scan mode

+ *   timings, for example.

+ *   

+ * o Printing digits to the right of the decimal point when the

+ *   digits are 0 annoys me.

+ *

+ * o Error checking.

+ *

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+# include <xorg-config.h>

+#endif

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <math.h>

+

+#define MARGIN_PERCENT    1.8   /* % of active vertical image                */

+#define CELL_GRAN         8.0   /* assumed character cell granularity        */

+#define MIN_PORCH         1     /* minimum front porch                       */

+#define V_SYNC_RQD        3     /* width of vsync in lines                   */

+#define H_SYNC_PERCENT    8.0   /* width of hsync as % of total line         */

+#define MIN_VSYNC_PLUS_BP 550.0 /* min time of vsync + back porch (microsec) */

+#define M                 600.0 /* blanking formula gradient                 */

+#define C                 40.0  /* blanking formula offset                   */

+#define K                 128.0 /* blanking formula scaling factor           */

+#define J                 20.0  /* blanking formula scaling factor           */

+

+/* C' and M' are part of the Blanking Duty Cycle computation */

+

+#define C_PRIME           (((C - J) * K/256.0) + J)

+#define M_PRIME           (K/256.0 * M)

+

+

+/* struct definitions */

+

+typedef struct __mode

+{

+    int hr, hss, hse, hfl;

+    int vr, vss, vse, vfl;

+    float pclk, h_freq, v_freq;

+} mode;

+

+

+typedef struct __options

+{

+    int x, y;

+    int xorgmode, fbmode;

+    float v_freq;

+} options;

+

+

+

+

+/* prototypes */

+

+void print_value(int n, char *name, float val);

+void print_xf86_mode (mode *m);

+void print_fb_mode (mode *m);

+mode *vert_refresh (int h_pixels, int v_lines, float freq,

+                    int interlaced, int margins);

+options *parse_command_line (int argc, char *argv[]);

+

+

+

+

+/*

+ * print_value() - print the result of the named computation; this is

+ * useful when comparing against the GTF EXCEL spreadsheet.

+ */

+

+int global_verbose = 0;

+

+void print_value(int n, char *name, float val)

+{

+    if (global_verbose) {

+        printf("%2d: %-27s: %15f\n", n, name, val);

+    }

+}

+

+

+

+/* print_xf86_mode() - print the XServer modeline, given mode timings. */

+

+void print_xf86_mode (mode *m)

+{

+    printf ("\n");

+    printf ("  # %dx%d @ %.2f Hz (GTF) hsync: %.2f kHz; pclk: %.2f MHz\n",

+            m->hr, m->vr, m->v_freq, m->h_freq, m->pclk);

+    

+    printf ("  Modeline \"%dx%d_%.2f\"  %.2f"

+            "  %d %d %d %d"

+            "  %d %d %d %d"

+            "  -HSync +Vsync\n\n",

+            m->hr, m->vr, m->v_freq, m->pclk,

+            m->hr, m->hss, m->hse, m->hfl,

+            m->vr, m->vss, m->vse, m->vfl);

+    

+}

+

+

+

+/*

+ * print_fb_mode() - print a mode description in fbset(8) format;

+ * see the fb.modes(8) manpage.  The timing description used in

+ * this is rather odd; they use "left and right margin" to refer

+ * to the portion of the hblank before and after the sync pulse

+ * by conceptually wrapping the portion of the blank after the pulse

+ * to infront of the visible region; ie:

+ * 

+ *

+ * Timing description I'm accustomed to:

+ *

+ *

+ *

+ *     <--------1--------> <--2--> <--3--> <--4-->

+ *                                _________

+ *    |-------------------|_______|       |_______

+ *

+ *                        R       SS      SE     FL

+ *       

+ * 1: visible image

+ * 2: blank before sync (aka front porch)

+ * 3: sync pulse

+ * 4: blank after sync (aka back porch)

+ * R: Resolution

+ * SS: Sync Start

+ * SE: Sync End

+ * FL: Frame Length

+ *

+ *

+ * But the fb.modes format is:

+ *

+ *

+ *    <--4--> <--------1--------> <--2--> <--3--> 

+ *                                       _________

+ *    _______|-------------------|_______|       |

+ *  

+ * The fb.modes(8) manpage refers to <4> and <2> as the left and

+ * right "margin" (as well as upper and lower margin in the vertical

+ * direction) -- note that this has nothing to do with the term

+ * "margin" used in the GTF Timing Standard.

+ *

+ * XXX always prints the 32 bit mode -- should I provide a command

+ * line option to specify the bpp?  It's simple enough for a user

+ * to edit the mode description after it's generated.

+ */

+

+void print_fb_mode (mode *m)

+{

+    printf ("\n");

+    printf ("mode \"%dx%d %.2fHz 32bit (GTF)\"\n",

+            m->hr, m->vr, m->v_freq);

+    printf ("    # PCLK: %.2f MHz, H: %.2f kHz, V: %.2f Hz\n",

+            m->pclk, m->h_freq, m->v_freq);

+    printf ("    geometry %d %d %d %d 32\n",

+            m->hr, m->vr, m->hr, m->vr);

+    printf ("    timings %d %d %d %d %d %d %d\n",

+            (int) rint(1000000.0/m->pclk),/* pixclock in picoseconds */

+            m->hfl - m->hse,              /* left margin (in pixels) */

+            m->hss - m->hr,               /* right margin (in pixels) */

+            m->vfl - m->vse,              /* upper margin (in pixel lines) */

+            m->vss - m->vr,               /* lower margin (in pixel lines) */

+            m->hse - m->hss,              /* horizontal sync length (pixels) */

+            m->vse - m->vss);             /* vert sync length (pixel lines) */

+    printf ("    hsync low\n");

+    printf ("    vsync high\n");

+    printf ("endmode\n\n");

+    

+}

+

+

+

+

+/*

+ * vert_refresh() - as defined by the GTF Timing Standard, compute the

+ * Stage 1 Parameters using the vertical refresh frequency.  In other

+ * words: input a desired resolution and desired refresh rate, and

+ * output the GTF mode timings.

+ *

+ * XXX All the code is in place to compute interlaced modes, but I don't

+ * feel like testing it right now.

+ *

+ * XXX margin computations are implemented but not tested (nor used by

+ * XServer of fbset mode descriptions, from what I can tell).

+ */

+

+mode *vert_refresh (int h_pixels, int v_lines, float freq,

+                    int interlaced, int margins)

+{

+    float h_pixels_rnd;

+    float v_lines_rnd;

+    float v_field_rate_rqd;

+    float top_margin;

+    float bottom_margin;

+    float interlace;

+    float h_period_est;

+    float vsync_plus_bp;

+    float v_back_porch;

+    float total_v_lines;

+    float v_field_rate_est;

+    float h_period;

+    float v_field_rate;

+    float v_frame_rate;

+    float left_margin;

+    float right_margin;

+    float total_active_pixels;

+    float ideal_duty_cycle;

+    float h_blank;

+    float total_pixels;

+    float pixel_freq;

+    float h_freq;

+

+    float h_sync;

+    float h_front_porch;

+    float v_odd_front_porch_lines;

+

+    mode *m = (mode*) malloc (sizeof (mode));

+    

+    

+    /*  1. In order to give correct results, the number of horizontal

+     *  pixels requested is first processed to ensure that it is divisible

+     *  by the character size, by rounding it to the nearest character

+     *  cell boundary:

+     *

+     *  [H PIXELS RND] = ((ROUND([H PIXELS]/[CELL GRAN RND],0))*[CELLGRAN RND])

+     */

+    

+    h_pixels_rnd = rint((float) h_pixels / CELL_GRAN) * CELL_GRAN;

+    

+    print_value(1, "[H PIXELS RND]", h_pixels_rnd);

+

+    

+    /*  2. If interlace is requested, the number of vertical lines assumed

+     *  by the calculation must be halved, as the computation calculates

+     *  the number of vertical lines per field. In either case, the

+     *  number of lines is rounded to the nearest integer.

+     *   

+     *  [V LINES RND] = IF([INT RQD?]="y", ROUND([V LINES]/2,0),

+     *                                     ROUND([V LINES],0))

+     */

+

+    v_lines_rnd = interlaced ?

+            rint((float) v_lines) / 2.0 :

+            rint((float) v_lines);

+    

+    print_value(2, "[V LINES RND]", v_lines_rnd);

+    

+    

+    /*  3. Find the frame rate required:

+     *

+     *  [V FIELD RATE RQD] = IF([INT RQD?]="y", [I/P FREQ RQD]*2,

+     *                                          [I/P FREQ RQD])

+     */

+

+    v_field_rate_rqd = interlaced ? (freq * 2.0) : (freq);

+

+    print_value(3, "[V FIELD RATE RQD]", v_field_rate_rqd);

+    

+

+    /*  4. Find number of lines in Top margin:

+     *

+     *  [TOP MARGIN (LINES)] = IF([MARGINS RQD?]="Y",

+     *          ROUND(([MARGIN%]/100*[V LINES RND]),0),

+     *          0)

+     */

+

+    top_margin = margins ? rint(MARGIN_PERCENT / 100.0 * v_lines_rnd) : (0.0);

+

+    print_value(4, "[TOP MARGIN (LINES)]", top_margin);

+    

+

+    /*  5. Find number of lines in Bottom margin:

+     *

+     *  [BOT MARGIN (LINES)] = IF([MARGINS RQD?]="Y",

+     *          ROUND(([MARGIN%]/100*[V LINES RND]),0),

+     *          0)

+     */

+

+    bottom_margin = margins ? rint(MARGIN_PERCENT/100.0 * v_lines_rnd) : (0.0);

+

+    print_value(5, "[BOT MARGIN (LINES)]", bottom_margin);

+

+    

+    /*  6. If interlace is required, then set variable [INTERLACE]=0.5:

+     *   

+     *  [INTERLACE]=(IF([INT RQD?]="y",0.5,0))

+     */

+

+    interlace = interlaced ? 0.5 : 0.0;

+

+    print_value(6, "[INTERLACE]", interlace);

+    

+

+    /*  7. Estimate the Horizontal period

+     *

+     *  [H PERIOD EST] = ((1/[V FIELD RATE RQD]) - [MIN VSYNC+BP]/1000000) /

+     *                    ([V LINES RND] + (2*[TOP MARGIN (LINES)]) +

+     *                     [MIN PORCH RND]+[INTERLACE]) * 1000000

+     */

+

+    h_period_est = (((1.0/v_field_rate_rqd) - (MIN_VSYNC_PLUS_BP/1000000.0))

+                    / (v_lines_rnd + (2*top_margin) + MIN_PORCH + interlace)

+                    * 1000000.0);

+

+    print_value(7, "[H PERIOD EST]", h_period_est);

+    

+

+    /*  8. Find the number of lines in V sync + back porch:

+     *

+     *  [V SYNC+BP] = ROUND(([MIN VSYNC+BP]/[H PERIOD EST]),0)

+     */

+

+    vsync_plus_bp = rint(MIN_VSYNC_PLUS_BP/h_period_est);

+

+    print_value(8, "[V SYNC+BP]", vsync_plus_bp);

+    

+    

+    /*  9. Find the number of lines in V back porch alone:

+     *

+     *  [V BACK PORCH] = [V SYNC+BP] - [V SYNC RND]

+     *

+     *  XXX is "[V SYNC RND]" a typo? should be [V SYNC RQD]?

+     */

+    

+    v_back_porch = vsync_plus_bp - V_SYNC_RQD;

+    

+    print_value(9, "[V BACK PORCH]", v_back_porch);

+    

+

+    /*  10. Find the total number of lines in Vertical field period:

+     *

+     *  [TOTAL V LINES] = [V LINES RND] + [TOP MARGIN (LINES)] +

+     *                    [BOT MARGIN (LINES)] + [V SYNC+BP] + [INTERLACE] +

+     *                    [MIN PORCH RND]

+     */

+

+    total_v_lines = v_lines_rnd + top_margin + bottom_margin + vsync_plus_bp +

+        interlace + MIN_PORCH;

+    

+    print_value(10, "[TOTAL V LINES]", total_v_lines);

+    

+

+    /*  11. Estimate the Vertical field frequency:

+     *

+     *  [V FIELD RATE EST] = 1 / [H PERIOD EST] / [TOTAL V LINES] * 1000000

+     */

+

+    v_field_rate_est = 1.0 / h_period_est / total_v_lines * 1000000.0;

+    

+    print_value(11, "[V FIELD RATE EST]", v_field_rate_est);

+    

+

+    /*  12. Find the actual horizontal period:

+     *

+     *  [H PERIOD] = [H PERIOD EST] / ([V FIELD RATE RQD] / [V FIELD RATE EST])

+     */

+

+    h_period = h_period_est / (v_field_rate_rqd / v_field_rate_est);

+    

+    print_value(12, "[H PERIOD]", h_period);

+    

+

+    /*  13. Find the actual Vertical field frequency:

+     *

+     *  [V FIELD RATE] = 1 / [H PERIOD] / [TOTAL V LINES] * 1000000

+     */

+

+    v_field_rate = 1.0 / h_period / total_v_lines * 1000000.0;

+

+    print_value(13, "[V FIELD RATE]", v_field_rate);

+    

+

+    /*  14. Find the Vertical frame frequency:

+     *

+     *  [V FRAME RATE] = (IF([INT RQD?]="y", [V FIELD RATE]/2, [V FIELD RATE]))

+     */

+

+    v_frame_rate = interlaced ? v_field_rate / 2.0 : v_field_rate;

+

+    print_value(14, "[V FRAME RATE]", v_frame_rate);

+    

+

+    /*  15. Find number of pixels in left margin:

+     *

+     *  [LEFT MARGIN (PIXELS)] = (IF( [MARGINS RQD?]="Y",

+     *          (ROUND( ([H PIXELS RND] * [MARGIN%] / 100 /

+     *                   [CELL GRAN RND]),0)) * [CELL GRAN RND],

+     *          0))

+     */

+

+    left_margin = margins ?

+        rint(h_pixels_rnd * MARGIN_PERCENT / 100.0 / CELL_GRAN) * CELL_GRAN :

+        0.0;

+    

+    print_value(15, "[LEFT MARGIN (PIXELS)]", left_margin);

+    

+

+    /*  16. Find number of pixels in right margin:

+     *

+     *  [RIGHT MARGIN (PIXELS)] = (IF( [MARGINS RQD?]="Y",

+     *          (ROUND( ([H PIXELS RND] * [MARGIN%] / 100 /

+     *                   [CELL GRAN RND]),0)) * [CELL GRAN RND],

+     *          0))

+     */

+    

+    right_margin = margins ?

+        rint(h_pixels_rnd * MARGIN_PERCENT / 100.0 / CELL_GRAN) * CELL_GRAN :

+        0.0;

+    

+    print_value(16, "[RIGHT MARGIN (PIXELS)]", right_margin);

+    

+

+    /*  17. Find total number of active pixels in image and left and right

+     *  margins:

+     *

+     *  [TOTAL ACTIVE PIXELS] = [H PIXELS RND] + [LEFT MARGIN (PIXELS)] +

+     *                          [RIGHT MARGIN (PIXELS)]

+     */

+

+    total_active_pixels = h_pixels_rnd + left_margin + right_margin;

+    

+    print_value(17, "[TOTAL ACTIVE PIXELS]", total_active_pixels);

+    

+    

+    /*  18. Find the ideal blanking duty cycle from the blanking duty cycle

+     *  equation:

+     *

+     *  [IDEAL DUTY CYCLE] = [C'] - ([M']*[H PERIOD]/1000)

+     */

+

+    ideal_duty_cycle = C_PRIME - (M_PRIME * h_period / 1000.0);

+    

+    print_value(18, "[IDEAL DUTY CYCLE]", ideal_duty_cycle);

+    

+

+    /*  19. Find the number of pixels in the blanking time to the nearest

+     *  double character cell:

+     *

+     *  [H BLANK (PIXELS)] = (ROUND(([TOTAL ACTIVE PIXELS] *

+     *                               [IDEAL DUTY CYCLE] /

+     *                               (100-[IDEAL DUTY CYCLE]) /

+     *                               (2*[CELL GRAN RND])), 0))

+     *                       * (2*[CELL GRAN RND])

+     */

+

+    h_blank = rint(total_active_pixels *

+                   ideal_duty_cycle /

+                   (100.0 - ideal_duty_cycle) /

+                   (2.0 * CELL_GRAN)) * (2.0 * CELL_GRAN);

+    

+    print_value(19, "[H BLANK (PIXELS)]", h_blank);

+    

+

+    /*  20. Find total number of pixels:

+     *

+     *  [TOTAL PIXELS] = [TOTAL ACTIVE PIXELS] + [H BLANK (PIXELS)]

+     */

+

+    total_pixels = total_active_pixels + h_blank;

+    

+    print_value(20, "[TOTAL PIXELS]", total_pixels);

+    

+

+    /*  21. Find pixel clock frequency:

+     *

+     *  [PIXEL FREQ] = [TOTAL PIXELS] / [H PERIOD]

+     */

+    

+    pixel_freq = total_pixels / h_period;

+    

+    print_value(21, "[PIXEL FREQ]", pixel_freq);

+    

+

+    /*  22. Find horizontal frequency:

+     *

+     *  [H FREQ] = 1000 / [H PERIOD]

+     */

+

+    h_freq = 1000.0 / h_period;

+    

+    print_value(22, "[H FREQ]", h_freq);

+    

+

+

+    /* Stage 1 computations are now complete; I should really pass

+       the results to another function and do the Stage 2

+       computations, but I only need a few more values so I'll just

+       append the computations here for now */

+

+    

+

+    /*  17. Find the number of pixels in the horizontal sync period:

+     *

+     *  [H SYNC (PIXELS)] =(ROUND(([H SYNC%] / 100 * [TOTAL PIXELS] /

+     *                             [CELL GRAN RND]),0))*[CELL GRAN RND]

+     */

+

+    h_sync = rint(H_SYNC_PERCENT/100.0 * total_pixels / CELL_GRAN) * CELL_GRAN;

+

+    print_value(17, "[H SYNC (PIXELS)]", h_sync);

+    

+

+    /*  18. Find the number of pixels in the horizontal front porch period:

+     *

+     *  [H FRONT PORCH (PIXELS)] = ([H BLANK (PIXELS)]/2)-[H SYNC (PIXELS)]

+     */

+

+    h_front_porch = (h_blank / 2.0) - h_sync;

+

+    print_value(18, "[H FRONT PORCH (PIXELS)]", h_front_porch);

+    

+    

+    /*  36. Find the number of lines in the odd front porch period:

+     *

+     *  [V ODD FRONT PORCH(LINES)]=([MIN PORCH RND]+[INTERLACE])

+     */

+    

+    v_odd_front_porch_lines = MIN_PORCH + interlace;

+    

+    print_value(36, "[V ODD FRONT PORCH(LINES)]", v_odd_front_porch_lines);

+    

+

+    /* finally, pack the results in the mode struct */

+    

+    m->hr  = (int) (h_pixels_rnd);

+    m->hss = (int) (h_pixels_rnd + h_front_porch);

+    m->hse = (int) (h_pixels_rnd + h_front_porch + h_sync);

+    m->hfl = (int) (total_pixels);

+

+    m->vr  = (int) (v_lines_rnd);

+    m->vss = (int) (v_lines_rnd + v_odd_front_porch_lines);

+    m->vse = (int) (int) (v_lines_rnd + v_odd_front_porch_lines + V_SYNC_RQD);

+    m->vfl = (int) (total_v_lines);

+

+    m->pclk   = pixel_freq;

+    m->h_freq = h_freq;

+    m->v_freq = freq;

+

+    return m;

+    

+}

+

+

+

+

+/*

+ * parse_command_line() - parse the command line and return an

+ * alloced structure containing the results.  On error print usage

+ * and return NULL.

+ */ 

+

+options *parse_command_line (int argc, char *argv[])

+{

+    int n;

+

+    options *o = (options *) calloc (1, sizeof (options));

+

+    if (argc < 4) goto bad_option;

+

+    o->x = atoi (argv[1]);

+    o->y = atoi (argv[2]);

+    o->v_freq = atof (argv[3]);

+

+    /* XXX should check for errors in the above */

+    

+    n = 4;

+

+    while (n < argc) {

+        if ((strcmp (argv[n], "-v") == 0) ||

+            (strcmp (argv[n], "--verbose") == 0)) {

+            global_verbose = 1;

+        } else if ((strcmp (argv[n], "-f") == 0) ||

+                   (strcmp (argv[n], "--fbmode") == 0)) {

+            o->fbmode = 1;

+        } else if ((strcmp (argv[n], "-x") == 0) ||

+		   (strcmp (argv[n], "--xorgmode") == 0) ||

+                   (strcmp (argv[n], "--xf86mode") == 0)) {

+            o->xorgmode = 1;

+        } else {

+            goto bad_option;

+        }

+        

+        n++;

+    }

+

+    /* if neither xorgmode nor fbmode were requested, default to

+       xorgmode */

+

+    if (!o->fbmode && !o->xorgmode) o->xorgmode = 1;

+    

+    return o;

+    

+ bad_option:

+

+    fprintf (stderr, "\n");

+    fprintf (stderr, "usage: %s x y refresh [-v|--verbose] "

+             "[-f|--fbmode] [-x|--xorgmode]\n", argv[0]);

+

+    fprintf (stderr, "\n");

+    

+    fprintf (stderr, "            x : the desired horizontal "

+             "resolution (required)\n");

+    fprintf (stderr, "            y : the desired vertical "

+             "resolution (required)\n");

+    fprintf (stderr, "      refresh : the desired refresh "

+             "rate (required)\n");

+    fprintf (stderr, " -v|--verbose : enable verbose printouts "

+             "(traces each step of the computation)\n");

+    fprintf (stderr, "  -f|--fbmode : output an fbset(8)-style mode "

+             "description\n");

+    fprintf (stderr, " -x|--xorgmode : output an "__XSERVERNAME__"-style mode "

+             "description (this is the default\n"

+             "                if no mode description is requested)\n");

+    

+    fprintf (stderr, "\n");

+    

+    free (o);

+    return NULL;

+

+}

+

+

+

+int main (int argc, char *argv[])

+{

+    mode *m;

+    options *o;

+

+    o = parse_command_line (argc, argv);

+    if (!o) exit (1);

+    

+    m = vert_refresh (o->x, o->y, o->v_freq, 0, 0);

+    if (!m) exit (1);

+

+    if (o->xorgmode)

+        print_xf86_mode(m);

+    

+    if (o->fbmode)

+        print_fb_mode(m);

+    

+    return 0;

+    

+}

diff --git a/xorg-server/hw/xfree86/vbe/vbe.c b/xorg-server/hw/xfree86/vbe/vbe.c
index 21fe0c812..11b1f25eb 100644
--- a/xorg-server/hw/xfree86/vbe/vbe.c
+++ b/xorg-server/hw/xfree86/vbe/vbe.c
@@ -345,7 +345,7 @@ VBEGetVBEInfo(vbeInfoPtr pVbe)
     char *str;

     CARD16 major, *modes;

 

-    bzero(pVbe->memory, sizeof(VbeInfoBlock));

+    memset(pVbe->memory, 0, sizeof(VbeInfoBlock));

 

     /*

     Input:

@@ -370,7 +370,7 @@ VBEGetVBEInfo(vbeInfoPtr pVbe)
     xf86ExecX86int10(pVbe->pInt10);

 

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (NULL);

+	return NULL;

 

     block = calloc(sizeof(VbeInfoBlock), 1);

     block->VESASignature[0] = ((char*)pVbe->memory)[0];

@@ -418,7 +418,7 @@ VBEGetVBEInfo(vbeInfoPtr pVbe)
 	memcpy(&block->OemData, ((char*)pVbe->memory) + 256, 256);

     }

 

-    return (block);

+    return block;

 }

 

 void

@@ -493,10 +493,10 @@ VBEGetVBEMode(vbeInfoPtr pVbe, int *mode)
     if (R16(pVbe->pInt10->ax) == 0x4f) {

 	*mode = R16(pVbe->pInt10->bx);

 

-	return (TRUE);

+	return TRUE;

     }

 

-    return (FALSE);

+    return FALSE;

 }

 

 VbeModeInfoBlock *

@@ -504,7 +504,7 @@ VBEGetModeInfo(vbeInfoPtr pVbe, int mode)
 {

     VbeModeInfoBlock *block = NULL;

 

-    bzero(pVbe->memory, sizeof(VbeModeInfoBlock));

+    memset(pVbe->memory, 0, sizeof(VbeModeInfoBlock));

 

     /*

     Input:

@@ -525,7 +525,7 @@ VBEGetModeInfo(vbeInfoPtr pVbe, int mode)
     pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);

     xf86ExecX86int10(pVbe->pInt10);

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (NULL);

+	return NULL;

 

     block = calloc(sizeof(VbeModeInfoBlock), 1);

 

@@ -591,7 +591,7 @@ VBEGetModeInfo(vbeInfoPtr pVbe, int mode)
     else

 	memcpy(&block->PhysBasePtr, ((char*)pVbe->memory) + 40, 216);

 

-    return (block);

+    return block;

 }

 

 void

@@ -657,7 +657,7 @@ VBESaveRestore(vbeInfoPtr pVbe, vbeSaveRestoreFunction function,
 	    pVbe->pInt10->cx = 0x000f;

 	    xf86ExecX86int10(pVbe->pInt10);

 	    if (R16(pVbe->pInt10->ax) != 0x4f)

-	        return (FALSE);

+	        return FALSE;

 

 	    if (function == MODE_SAVE) {

 	        int npages = (R16(pVbe->pInt10->bx) * 64) / 4096 + 1;

@@ -665,7 +665,7 @@ VBESaveRestore(vbeInfoPtr pVbe, vbeSaveRestoreFunction function,
 						   real_mode_pages)) == NULL) {

 		    xf86DrvMsg(screen, X_ERROR,

 			       "Cannot allocate memory to save SVGA state.\n");

-		    return (FALSE);

+		    return FALSE;

 		}

 	    }

 	    *size = pVbe->pInt10->bx * 64;

@@ -716,9 +716,9 @@ VBEBankSwitch(vbeInfoPtr pVbe, unsigned int iBank, int window)
     xf86ExecX86int10(pVbe->pInt10);

 

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (FALSE);

+	return FALSE;

 

-    return (TRUE);

+    return TRUE;

 }

 

 Bool

@@ -726,7 +726,7 @@ VBESetGetLogicalScanlineLength(vbeInfoPtr pVbe, vbeScanwidthCommand command,
 				int width, int *pixels, int *bytes, int *max)

 {

     if (command < SCANWID_SET || command > SCANWID_GET_MAX)

-	return (FALSE);

+	return FALSE;

 

     /*

     Input:

@@ -755,7 +755,7 @@ VBESetGetLogicalScanlineLength(vbeInfoPtr pVbe, vbeScanwidthCommand command,
     xf86ExecX86int10(pVbe->pInt10);

 

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (FALSE);

+	return FALSE;

 

     if (command == SCANWID_GET || command == SCANWID_GET_MAX) {

 	if (pixels)

@@ -766,7 +766,7 @@ VBESetGetLogicalScanlineLength(vbeInfoPtr pVbe, vbeScanwidthCommand command,
 	    *max = R16(pVbe->pInt10->dx);

     }

 

-    return (TRUE);

+    return TRUE;

 }

 

 Bool

@@ -780,9 +780,9 @@ VBESetDisplayStart(vbeInfoPtr pVbe, int x, int y, Bool wait_retrace)
     xf86ExecX86int10(pVbe->pInt10);

 

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (FALSE);

+	return FALSE;

 

-    return (TRUE);

+    return TRUE;

 }

 

 Bool

@@ -794,12 +794,12 @@ VBEGetDisplayStart(vbeInfoPtr pVbe, int *x, int *y)
     xf86ExecX86int10(pVbe->pInt10);

 

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (FALSE);

+	return FALSE;

 

     *x = pVbe->pInt10->cx;

     *y = pVbe->pInt10->dx;

 

-    return (TRUE);

+    return TRUE;

 }

 

 int

@@ -827,7 +827,7 @@ VBESetGetDACPaletteFormat(vbeInfoPtr pVbe, int bits)
     xf86ExecX86int10(pVbe->pInt10);

 

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (0);

+	return 0;

 

     return (bits != 0 ? bits : (pVbe->pInt10->bx >> 8) & 0x00ff);

 }

@@ -878,15 +878,15 @@ VBESetGetPaletteData(vbeInfoPtr pVbe, Bool set, int first, int num,
     xf86ExecX86int10(pVbe->pInt10);

 

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (NULL);

+	return NULL;

 

     if (set)

-	return (data);

+	return data;

 

     data = malloc(num * sizeof(CARD32));

     memcpy(data, pVbe->memory, num * sizeof(CARD32));

 

-    return (data);

+    return data;

 }

 

 VBEpmi *

@@ -915,14 +915,14 @@ VBEGetVBEpmi(vbeInfoPtr pVbe)
     xf86ExecX86int10(pVbe->pInt10);

 

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (NULL);

+	return NULL;

 

     pmi = malloc(sizeof(VBEpmi));

     pmi->seg_tbl = R16(pVbe->pInt10->es);

     pmi->tbl_off = R16(pVbe->pInt10->di);

     pmi->tbl_len = R16(pVbe->pInt10->cx);

 

-    return (pmi);

+    return pmi;

 }

 

 #if 0

@@ -1034,9 +1034,9 @@ VBEGetPixelClock(vbeInfoPtr pVbe, int mode, int clock)
     xf86ExecX86int10(pVbe->pInt10);

 

     if (R16(pVbe->pInt10->ax) != 0x4f)

-	return (0);

+	return 0;

 

-    return (pVbe->pInt10->cx);

+    return pVbe->pInt10->cx;

 }

 

 Bool

diff --git a/xorg-server/hw/xfree86/vgahw/vgaCmap.c b/xorg-server/hw/xfree86/vgahw/vgaCmap.c
index e337b42c0..a65bb5e86 100644
--- a/xorg-server/hw/xfree86/vgahw/vgaCmap.c
+++ b/xorg-server/hw/xfree86/vgahw/vgaCmap.c
@@ -51,7 +51,7 @@ vgaListInstalledColormaps(pScreen, pmaps)
    * is always a colormap installed */

   

   *pmaps = GetInstalledmiColormap(pScreen)->mid;

-  return(1);

+  return 1;

 }

 

 int

@@ -63,7 +63,7 @@ vgaGetInstalledColormaps(pScreen, pmaps)
    * is always a colormap installed */

   

   *pmaps = GetInstalledmiColormap(pScreen);

-  return(1);

+  return 1;

 }

 

 int vgaCheckColorMap(ColormapPtr pmap)

diff --git a/xorg-server/hw/xfree86/vgahw/vgaHW.c b/xorg-server/hw/xfree86/vgahw/vgaHW.c
index 396a3cc62..7b1c95e62 100644
--- a/xorg-server/hw/xfree86/vgahw/vgaHW.c
+++ b/xorg-server/hw/xfree86/vgahw/vgaHW.c
@@ -658,7 +658,7 @@ vgaHWSaveScreen(ScreenPtr pScreen, int mode)
    if ((pScrn != NULL) && pScrn->vtSema) {

      vgaHWBlankScreen(pScrn, on);

    }

-   return (TRUE);

+   return TRUE;

 }

 

 

@@ -1351,7 +1351,7 @@ vgaHWInit(ScrnInfoPtr scrninfp, DisplayModePtr mode)
     regp->Attribute[19] = 0x00;

     regp->Attribute[20] = 0x00;

 

-    return(TRUE);

+    return TRUE;

 }

 

     /*

@@ -1479,8 +1479,7 @@ vgaHWGetHWRecPrivate(void)
 static void

 vgaHWFreeRegs(vgaRegPtr regp)

 {

-    if (regp->CRTC)

-        free(regp->CRTC);

+    free(regp->CRTC);

 

     regp->CRTC =

     regp->Sequencer =

diff --git a/xorg-server/hw/xfree86/xaa/xaaBitBlt.c b/xorg-server/hw/xfree86/xaa/xaaBitBlt.c
index b1fda1cd6..cc7e810ca 100644
--- a/xorg-server/hw/xfree86/xaa/xaaBitBlt.c
+++ b/xorg-server/hw/xfree86/xaa/xaaBitBlt.c
@@ -118,8 +118,8 @@ XAABitBlt(
 	    fastExpose = 0;

 	}

     } else {

-	REGION_INIT(pGC->pScreen, &rgnDst, &fastBox, 1);

-	REGION_INTERSECT(pGC->pScreen, &rgnDst, &rgnDst, prgnSrcClip);

+	RegionInit(&rgnDst, &fastBox, 1);

+	RegionIntersect(&rgnDst, &rgnDst, prgnSrcClip);

     }

 

     dstx += pDstDrawable->x;

@@ -128,9 +128,9 @@ XAABitBlt(
     if (pDstDrawable->type == DRAWABLE_WINDOW) {

 	if (!((WindowPtr)pDstDrawable)->realized) {

 	    if (!fastClip)

-		REGION_UNINIT(pGC->pScreen, &rgnDst);

+		RegionUninit(&rgnDst);

 	    if (freeSrcClip)

-		REGION_DESTROY(pGC->pScreen, prgnSrcClip);

+		RegionDestroy(prgnSrcClip);

 	    return NULL;

 	}

     }

@@ -153,8 +153,8 @@ XAABitBlt(
 	   blown region and call intersect */

 

 	cclip = pGC->pCompositeClip;

-        if (REGION_NUM_RECTS(cclip) == 1) {

-	    BoxPtr pBox = REGION_RECTS(cclip);

+        if (RegionNumRects(cclip) == 1) {

+	    BoxPtr pBox = RegionRects(cclip);

 

 	    if (fastBox.x1 < pBox->x1) fastBox.x1 = pBox->x1;

 	    if (fastBox.x2 > pBox->x2) fastBox.x2 = pBox->x2;

@@ -163,37 +163,37 @@ XAABitBlt(
 

 	    /* Check to see if the region is empty */

 	    if (fastBox.x1 >= fastBox.x2 || fastBox.y1 >= fastBox.y2) {

-		REGION_NULL(pGC->pScreen, &rgnDst);

+		RegionNull(&rgnDst);

 	    } else {

-		REGION_INIT(pGC->pScreen, &rgnDst, &fastBox, 1);

+		RegionInit(&rgnDst, &fastBox, 1);

 	    }

 	} else {

 	    /* We must turn off fastClip now, since we must create

 	       a full blown region.  It is intersected with the

 	       composite clip below. */

 	    fastClip = 0;

-	    REGION_INIT(pGC->pScreen, &rgnDst, &fastBox,1);

+	    RegionInit(&rgnDst, &fastBox,1);

 	}

     } else {

-        REGION_TRANSLATE(pGC->pScreen, &rgnDst, -dx, -dy);

+        RegionTranslate(&rgnDst, -dx, -dy);

     }

 

     if (!fastClip) {

-	REGION_INTERSECT(pGC->pScreen, &rgnDst, &rgnDst,

+	RegionIntersect(&rgnDst, &rgnDst,

 				 pGC->pCompositeClip);

     }

 

     /* Do bit blitting */

-    numRects = REGION_NUM_RECTS(&rgnDst);

+    numRects = RegionNumRects(&rgnDst);

     if (numRects && width && height) {

 	if(!(pptSrc = (DDXPointPtr)malloc(numRects *

 						  sizeof(DDXPointRec)))) {

-	    REGION_UNINIT(pGC->pScreen, &rgnDst);

+	    RegionUninit(&rgnDst);

 	    if (freeSrcClip)

-		REGION_DESTROY(pGC->pScreen, prgnSrcClip);

+		RegionDestroy(prgnSrcClip);

 	    return NULL;

 	}

-	pbox = REGION_RECTS(&rgnDst);

+	pbox = RegionRects(&rgnDst);

 	ppt = pptSrc;

 	for (i = numRects; --i >= 0; pbox++, ppt++) {

 	    ppt->x = pbox->x1 + dx;

@@ -214,8 +214,8 @@ XAABitBlt(
 				  (int)origSource.height,

 				  origDest.x, origDest.y, bitPlane);

     }

-    REGION_UNINIT(pGC->pScreen, &rgnDst);

+    RegionUninit(&rgnDst);

     if (freeSrcClip)

-	REGION_DESTROY(pGC->pScreen, prgnSrcClip);

+	RegionDestroy(prgnSrcClip);

     return prgnExposed;

 }

diff --git a/xorg-server/hw/xfree86/xaa/xaaCpyArea.c b/xorg-server/hw/xfree86/xaa/xaaCpyArea.c
index eefd8d38d..5e594633d 100644
--- a/xorg-server/hw/xfree86/xaa/xaaCpyArea.c
+++ b/xorg-server/hw/xfree86/xaa/xaaCpyArea.c
@@ -95,8 +95,8 @@ XAADoBitBlt(
                ((pSrc->type == DRAWABLE_WINDOW) &&

                 (pDst->type == DRAWABLE_WINDOW)));

 

-    pbox = REGION_RECTS(prgnDst);

-    nbox = REGION_NUM_RECTS(prgnDst);

+    pbox = RegionRects(prgnDst);

+    nbox = RegionNumRects(prgnDst);

 

     pboxNew1 = NULL;

     pptNew1 = NULL;

@@ -148,8 +148,8 @@ XAADoBitBlt(
 	    pboxNew2 = (BoxPtr)malloc(sizeof(BoxRec) * nbox);

 	    pptNew2 = (DDXPointPtr)malloc(sizeof(DDXPointRec) * nbox);

 	    if(!pboxNew2 || !pptNew2) {

-		if (pptNew2) free(pptNew2);

-		if (pboxNew2) free(pboxNew2);

+		free(pptNew2);

+		free(pboxNew2);

 		if (pboxNew1) {

 		    free(pptNew1);

 		    free(pboxNew1);

@@ -204,8 +204,8 @@ XAADoImageWrite(
     int srcwidth;

     unsigned char* psrcBase;			/* start of image */

     unsigned char* srcPntr;			/* index into the image */

-    BoxPtr pbox = REGION_RECTS(prgnDst);

-    int nbox = REGION_NUM_RECTS(prgnDst);

+    BoxPtr pbox = RegionRects(prgnDst);

+    int nbox = RegionNumRects(prgnDst);

     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

     int Bpp = pSrc->bitsPerPixel >> 3; 

 

@@ -233,8 +233,8 @@ XAADoImageRead(
     int dstwidth;

     unsigned char* pdstBase;			/* start of image */

     unsigned char* dstPntr;			/* index into the image */

-    BoxPtr pbox = REGION_RECTS(prgnDst);

-    int nbox = REGION_NUM_RECTS(prgnDst);

+    BoxPtr pbox = RegionRects(prgnDst);

+    int nbox = RegionNumRects(prgnDst);

     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

     int Bpp = pSrc->bitsPerPixel >> 3;  /* wouldn't get here unless both

                                            src and dst have same bpp */

diff --git a/xorg-server/hw/xfree86/xaa/xaaCpyPlane.c b/xorg-server/hw/xfree86/xaa/xaaCpyPlane.c
index 358cb6fb2..2d036c936 100644
--- a/xorg-server/hw/xfree86/xaa/xaaCpyPlane.c
+++ b/xorg-server/hw/xfree86/xaa/xaaCpyPlane.c
@@ -76,8 +76,8 @@ XAACopyPlane1toNColorExpand(
     DDXPointPtr   pptSrc )

 {

     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

-    BoxPtr pbox = REGION_RECTS(rgnDst);

-    int numrects = REGION_NUM_RECTS(rgnDst);

+    BoxPtr pbox = RegionRects(rgnDst);

+    int numrects = RegionNumRects(rgnDst);

     unsigned char *src = ((PixmapPtr)pSrc)->devPrivate.ptr;

     int srcwidth = ((PixmapPtr)pSrc)->devKind; 

     

@@ -101,8 +101,8 @@ XAACopyPlaneNtoNColorExpand(
     DDXPointPtr   pptSrc 

 ){

     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

-    BoxPtr pbox = REGION_RECTS(rgnDst);

-    int numrects = REGION_NUM_RECTS(rgnDst);

+    BoxPtr pbox = RegionRects(rgnDst);

+    int numrects = RegionNumRects(rgnDst);

     unsigned char *src = ((PixmapPtr)pSrc)->devPrivate.ptr;

     unsigned char *data, *srcPtr, *dataPtr;

     int srcwidth = ((PixmapPtr)pSrc)->devKind; 

@@ -168,14 +168,14 @@ XAAPushPixelsSolidColorExpansion(
     int xOrg, int yOrg )

 {

    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

-   int MaxBoxes = REGION_NUM_RECTS(pGC->pCompositeClip);

+   int MaxBoxes = RegionNumRects(pGC->pCompositeClip);

    BoxPtr	pbox, pClipBoxes;

    int		nboxes, srcx, srcy;

    xRectangle TheRect;

    unsigned char *src = pBitMap->devPrivate.ptr;

    int srcwidth = pBitMap->devKind;

 

-   if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+   if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

    TheRect.x = xOrg;

diff --git a/xorg-server/hw/xfree86/xaa/xaaCpyWin.c b/xorg-server/hw/xfree86/xaa/xaaCpyWin.c
index 34f460f24..d8608b095 100644
--- a/xorg-server/hw/xfree86/xaa/xaaCpyWin.c
+++ b/xorg-server/hw/xfree86/xaa/xaaCpyWin.c
@@ -47,20 +47,20 @@ XAACopyWindow(
     	return;

     }

 

-    pwinRoot = WindowTable[pScreen->myNum];

+    pwinRoot = pScreen->root;

 

-    REGION_NULL(pScreen, &rgnDst);

+    RegionNull(&rgnDst);

 

     dx = ptOldOrg.x - pWin->drawable.x;

     dy = ptOldOrg.y - pWin->drawable.y;

-    REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);

-    REGION_INTERSECT(pScreen, &rgnDst, &pWin->borderClip, prgnSrc);

+    RegionTranslate(prgnSrc, -dx, -dy);

+    RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);

 

-    pbox = REGION_RECTS(&rgnDst);

-    nbox = REGION_NUM_RECTS(&rgnDst);

+    pbox = RegionRects(&rgnDst);

+    nbox = RegionNumRects(&rgnDst);

     if(!nbox || 

       !(pptSrc = (DDXPointPtr )malloc(nbox * sizeof(DDXPointRec)))) {

-	REGION_UNINIT(pScreen, &rgnDst);

+	RegionUninit(&rgnDst);

 	return;

     }

     ppt = pptSrc;

@@ -78,5 +78,5 @@ XAACopyWindow(
         		&(infoRec->ScratchGC), &rgnDst, pptSrc);

 

     free(pptSrc);

-    REGION_UNINIT(pScreen, &rgnDst);

+    RegionUninit(&rgnDst);

 }

diff --git a/xorg-server/hw/xfree86/xaa/xaaDashLine.c b/xorg-server/hw/xfree86/xaa/xaaDashLine.c
index 63233e05d..adae2e583 100644
--- a/xorg-server/hw/xfree86/xaa/xaaDashLine.c
+++ b/xorg-server/hw/xfree86/xaa/xaaDashLine.c
@@ -1,334 +1,334 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <stdlib.h>
-
-#include <X11/X.h>
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "miline.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-
-void
-#ifdef POLYSEGMENT
-XAAPolySegmentDashed(
-    DrawablePtr	pDrawable,
-    GCPtr	pGC,
-    int		nseg,
-    xSegment	*pSeg
-#else
-XAAPolyLinesDashed(
-    DrawablePtr pDrawable,
-    GCPtr	pGC,
-    int		mode,		/* Origin or Previous */
-    int		npt,		/* number of points */
-    DDXPointPtr pptInit
-#endif
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAGCPtr   pGCPriv = (XAAGCPtr)dixLookupPrivate(&pGC->devPrivates,
-						    XAAGetGCKey());
-    BoxPtr pboxInit = REGION_RECTS(pGC->pCompositeClip);
-    int nboxInit = REGION_NUM_RECTS(pGC->pCompositeClip);
-    unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
-    int xorg = pDrawable->x;
-    int yorg = pDrawable->y;
-    int nbox;
-    BoxPtr pbox;
-#ifndef POLYSEGMENT
-    DDXPointPtr ppt;
-#endif
-    unsigned int oc1, oc2;
-    int dmin, dmaj, e, octant;
-    int x1, x2, y1, y2, tmp, len, offset;
-    int PatternLength, PatternOffset;
-
-    if(!nboxInit)
-	return;
-
-    if (infoRec->DashedLineFlags & LINE_LIMIT_COORDS) {
-	int minValX = infoRec->DashedLineLimits.x1;
-	int maxValX = infoRec->DashedLineLimits.x2;
-	int minValY = infoRec->DashedLineLimits.y1;
-	int maxValY = infoRec->DashedLineLimits.y2;
-#ifdef POLYSEGMENT
-	int n = nseg;
-	xSegment *s = pSeg;
-
-	while (n--)
-#else
-	int n = npt;
-	int xorgtmp = xorg;
-	int yorgtmp = yorg;
-
-	ppt = pptInit;
-	x2 = ppt->x + xorgtmp;
-	y2 = ppt->y + yorgtmp;
-	while (--n)
-#endif
-	{
-#ifdef POLYSEGMENT
-	    x1 = s->x1 + xorg;
-	    y1 = s->y1 + yorg;
-	    x2 = s->x2 + xorg;
-	    y2 = s->y2 + yorg;
-	    s++;
-#else
-	    x1 = x2;
-	    y1 = y2;
-	    ++ppt;
-	    if (mode == CoordModePrevious) {
-		xorgtmp = x1;
-		yorgtmp = y1;
-	    }
-	    x2 = ppt->x + xorgtmp;
-	    y2 = ppt->y + yorgtmp;
-#endif
-	    if (x1 > maxValX || x1 < minValX ||
-		x2 > maxValX || x2 < minValX ||
-		y1 > maxValY || y1 < minValY ||
-		y2 > maxValY || y2 < minValY) {
-#ifdef POLYSEGMENT
-		XAAFallbackOps.PolySegment(pDrawable, pGC, nseg, pSeg);
-#else
-		XAAFallbackOps.Polylines(pDrawable, pGC, mode, npt, pptInit);
-#endif
-		return;
-	    }
-	}
-    }
-
-    PatternLength = pGCPriv->DashLength; 
-    PatternOffset = pGC->dashOffset % PatternLength;
-
-    (*infoRec->SetupForDashedLine)(infoRec->pScrn, pGC->fgPixel,
-		(pGC->lineStyle == LineDoubleDash) ? pGC->bgPixel : -1,
-		pGC->alu, pGC->planemask, PatternLength, pGCPriv->DashPattern);
-
-
-#ifdef POLYSEGMENT
-    while (nseg--)
-#else
-    ppt = pptInit;
-    x2 = ppt->x + xorg;
-    y2 = ppt->y + yorg;
-    while(--npt)
-#endif
-    {
-	nbox = nboxInit;
-	pbox = pboxInit;
-
-#ifdef POLYSEGMENT
-	x1 = pSeg->x1 + xorg;	
-	y1 = pSeg->y1 + yorg;
-	x2 = pSeg->x2 + xorg;	
-	y2 = pSeg->y2 + yorg;
-	pSeg++;
-#else
-	x1 = x2; 
-	y1 = y2;
-	++ppt;
-	if (mode == CoordModePrevious) {
-	    xorg = x1; 
-	    yorg = y1;
-	}
-	x2 = ppt->x + xorg; 
-	y2 = ppt->y + yorg;
-#endif
-
-
-	if (infoRec->SubsequentDashedBresenhamLine) {
-	    if((dmaj = x2 - x1) < 0) {
-		dmaj = -dmaj;
-		octant = XDECREASING;
-	    } else octant = 0;		   
-
-	    if((dmin = y2 - y1) < 0) {
-		dmin = -dmin;
-		octant |= YDECREASING;
-	    }	
-	
-	    if(dmin >= dmaj){
-		tmp = dmin; dmin = dmaj; dmaj = tmp;
-		octant |= YMAJOR;
-	    }
-
-	    e = -dmaj - ((bias >> octant) & 1);
-	    len = dmaj;
-	    dmin <<= 1;
-	    dmaj <<= 1;
-	} else {	/* Muffle compiler */
-	    dmin = dmaj = e = octant = len = 0;
-	}
-
-	while(nbox--) {
-	    oc1 = oc2 = 0;
-	    OUTCODES(oc1, x1, y1, pbox);
-	    OUTCODES(oc2, x2, y2, pbox);
-	    if (!(oc1 | oc2)) {   /* uncliped */
-		if(infoRec->SubsequentDashedTwoPointLine) {
-		   (*infoRec->SubsequentDashedTwoPointLine)(
-				infoRec->pScrn, x1, y1, x2, y2, 
-#ifdef POLYSEGMENT
-			    	(pGC->capStyle != CapNotLast) ? 0 :
-#endif
-				OMIT_LAST, PatternOffset);
-		} else {
-		    (*infoRec->SubsequentDashedBresenhamLine)(
-				infoRec->pScrn, x1, y1, dmaj, dmin, e, 
-#ifdef POLYSEGMENT
-			    	(pGC->capStyle != CapNotLast) ? (len+1) :
-#endif
-			    	len, octant, PatternOffset);
-		}
-		break;
-	    } else if (oc1 & oc2) { /* completely clipped */
-		pbox++;
-	    } else if (infoRec->ClippingFlags & HARDWARE_CLIP_DASHED_LINE) {
-		(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-			pbox->x1, pbox->y1, pbox->x2 - 1, pbox->y2 - 1);
-
-		if(infoRec->SubsequentDashedBresenhamLine) {
-		    (*infoRec->SubsequentDashedBresenhamLine)(
-				infoRec->pScrn, x1, y1, dmaj, dmin, e, 
-#ifdef POLYSEGMENT
-			    	(pGC->capStyle != CapNotLast) ? (len+1) :
-#endif
-			    	len, octant, PatternOffset);
-		} else {
-			(*infoRec->SubsequentDashedTwoPointLine)(
-				infoRec->pScrn, x1, y1, x2, y2, 
-#ifdef POLYSEGMENT
-			    	(pGC->capStyle != CapNotLast) ? 0 :
-#endif
-				OMIT_LAST, PatternOffset
-			);
-		}
-		(*infoRec->DisableClipping)(infoRec->pScrn);
-		pbox++;
-	    } else {
-		int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
-		int clip1 = 0, clip2 = 0;
-		int err, adx, ady;
-		    
-		if(octant & YMAJOR) {
-		    ady = dmaj >> 1;
-		    adx = dmin >> 1;
-		} else {
-		    ady = dmin >> 1;
-		    adx = dmaj >> 1;
-		}
-
-		if (miZeroClipLine(pbox->x1, pbox->y1, 
-				       pbox->x2 - 1, pbox->y2 - 1,
-				       &new_x1, &new_y1, &new_x2, &new_y2,
-				       adx, ady, &clip1, &clip2,
-				       octant, bias, oc1, oc2) == -1)
-		{
-		    pbox++;
-		    continue;
-		}
-
-		if (octant & YMAJOR)
-		    len = abs(new_y2 - new_y1);
-		else
-		    len = abs(new_x2 - new_x1);
-#ifdef POLYSEGMENT
-		if (clip2 != 0 || pGC->capStyle != CapNotLast)
-		    len++;
-#else
-		len += (clip2 != 0);
-#endif
-		if (len) {
-		    int abserr, clipdx, clipdy;
-			/* unwind bresenham error term to first point */
-		    if (clip1) {
-			clipdx = abs(new_x1 - x1);
-			clipdy = abs(new_y1 - y1);
-
-			if (octant & YMAJOR)
-			    err = e + clipdy*dmin - clipdx*dmaj;
-			else
-			    err = e + clipdx*dmin - clipdy*dmaj;
-		    } else
-			err = e;
-
-#define range infoRec->DashedBresenhamLineErrorTermBits
-		    abserr = abs(err);			    
-		    while((abserr & range) || 
-			  (dmaj & range) ||
-			  (dmin & range)) {
-			dmin >>= 1;
-			dmaj >>= 1;
-			abserr >>= 1;
-			err /= 2;
-		    }
-
-		    if(octant & YMAJOR)
-			offset = abs(new_y1 - y1);
-		    else 
-			offset = abs(new_x1 - x1);
-
-		    offset += PatternOffset;
-		    offset %= PatternLength;
-
-		    (*infoRec->SubsequentDashedBresenhamLine)(
-				infoRec->pScrn, new_x1, new_y1,
-				dmaj, dmin, err, len, octant, offset);
-		}
-		pbox++;
-	    }
-	} /* while (nbox--) */
-#ifndef POLYSEGMENT
-	len = abs(y2 - y1);
-	tmp = abs(x2 - x1);
-	PatternOffset += (len > tmp) ? len : tmp;
-	PatternOffset %= PatternLength;
-#endif
-    } /* while (nline--) */
-
-#ifndef POLYSEGMENT
-    /* paint the last point if the end style isn't CapNotLast.
-       (Assume that a projecting, butt, or round cap that is one
-        pixel wide is the same as the single pixel of the endpoint.)
-    */
-
-    if ((pGC->capStyle != CapNotLast) &&
-	((ppt->x + xorg != pptInit->x + pDrawable->x) ||
-	 (ppt->y + yorg != pptInit->y + pDrawable->y) ||
-	 (ppt == pptInit + 1)))
-    {
-	nbox = nboxInit;
-	pbox = pboxInit;
-	while (nbox--) {
-	    if ((x2 >= pbox->x1) && (y2 >= pbox->y1) &&
-		(x2 <  pbox->x2) && (y2 <  pbox->y2))
-	    {
-		if(infoRec->SubsequentDashedTwoPointLine) {
-			(*infoRec->SubsequentDashedTwoPointLine)(
-				infoRec->pScrn, x2, y2, x2, y2, 0,
-				PatternOffset);
-		} else {
-			(*infoRec->SubsequentDashedBresenhamLine)(
-				infoRec->pScrn, x2, y2, 2, 0, -1, 
-				1, 0, PatternOffset);
-		}
-		break;
-	    } else
-		pbox++;
-	}
-    }
-#endif
-
-    SET_SYNC_FLAG(infoRec);
-}
-
+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <stdlib.h>

+

+#include <X11/X.h>

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "miline.h"

+#include "xf86str.h"

+#include "xaa.h"

+#include "xaalocal.h"

+

+

+void

+#ifdef POLYSEGMENT

+XAAPolySegmentDashed(

+    DrawablePtr	pDrawable,

+    GCPtr	pGC,

+    int		nseg,

+    xSegment	*pSeg

+#else

+XAAPolyLinesDashed(

+    DrawablePtr pDrawable,

+    GCPtr	pGC,

+    int		mode,		/* Origin or Previous */

+    int		npt,		/* number of points */

+    DDXPointPtr pptInit

+#endif

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    XAAGCPtr   pGCPriv = (XAAGCPtr)dixLookupPrivate(&pGC->devPrivates,

+						    XAAGetGCKey());

+    BoxPtr pboxInit = RegionRects(pGC->pCompositeClip);

+    int nboxInit = RegionNumRects(pGC->pCompositeClip);

+    unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);

+    int xorg = pDrawable->x;

+    int yorg = pDrawable->y;

+    int nbox;

+    BoxPtr pbox;

+#ifndef POLYSEGMENT

+    DDXPointPtr ppt;

+#endif

+    unsigned int oc1, oc2;

+    int dmin, dmaj, e, octant;

+    int x1, x2, y1, y2, tmp, len, offset;

+    int PatternLength, PatternOffset;

+

+    if(!nboxInit)

+	return;

+

+    if (infoRec->DashedLineFlags & LINE_LIMIT_COORDS) {

+	int minValX = infoRec->DashedLineLimits.x1;

+	int maxValX = infoRec->DashedLineLimits.x2;

+	int minValY = infoRec->DashedLineLimits.y1;

+	int maxValY = infoRec->DashedLineLimits.y2;

+#ifdef POLYSEGMENT

+	int n = nseg;

+	xSegment *s = pSeg;

+

+	while (n--)

+#else

+	int n = npt;

+	int xorgtmp = xorg;

+	int yorgtmp = yorg;

+

+	ppt = pptInit;

+	x2 = ppt->x + xorgtmp;

+	y2 = ppt->y + yorgtmp;

+	while (--n)

+#endif

+	{

+#ifdef POLYSEGMENT

+	    x1 = s->x1 + xorg;

+	    y1 = s->y1 + yorg;

+	    x2 = s->x2 + xorg;

+	    y2 = s->y2 + yorg;

+	    s++;

+#else

+	    x1 = x2;

+	    y1 = y2;

+	    ++ppt;

+	    if (mode == CoordModePrevious) {

+		xorgtmp = x1;

+		yorgtmp = y1;

+	    }

+	    x2 = ppt->x + xorgtmp;

+	    y2 = ppt->y + yorgtmp;

+#endif

+	    if (x1 > maxValX || x1 < minValX ||

+		x2 > maxValX || x2 < minValX ||

+		y1 > maxValY || y1 < minValY ||

+		y2 > maxValY || y2 < minValY) {

+#ifdef POLYSEGMENT

+		XAAFallbackOps.PolySegment(pDrawable, pGC, nseg, pSeg);

+#else

+		XAAFallbackOps.Polylines(pDrawable, pGC, mode, npt, pptInit);

+#endif

+		return;

+	    }

+	}

+    }

+

+    PatternLength = pGCPriv->DashLength; 

+    PatternOffset = pGC->dashOffset % PatternLength;

+

+    (*infoRec->SetupForDashedLine)(infoRec->pScrn, pGC->fgPixel,

+		(pGC->lineStyle == LineDoubleDash) ? pGC->bgPixel : -1,

+		pGC->alu, pGC->planemask, PatternLength, pGCPriv->DashPattern);

+

+

+#ifdef POLYSEGMENT

+    while (nseg--)

+#else

+    ppt = pptInit;

+    x2 = ppt->x + xorg;

+    y2 = ppt->y + yorg;

+    while(--npt)

+#endif

+    {

+	nbox = nboxInit;

+	pbox = pboxInit;

+

+#ifdef POLYSEGMENT

+	x1 = pSeg->x1 + xorg;	

+	y1 = pSeg->y1 + yorg;

+	x2 = pSeg->x2 + xorg;	

+	y2 = pSeg->y2 + yorg;

+	pSeg++;

+#else

+	x1 = x2; 

+	y1 = y2;

+	++ppt;

+	if (mode == CoordModePrevious) {

+	    xorg = x1; 

+	    yorg = y1;

+	}

+	x2 = ppt->x + xorg; 

+	y2 = ppt->y + yorg;

+#endif

+

+

+	if (infoRec->SubsequentDashedBresenhamLine) {

+	    if((dmaj = x2 - x1) < 0) {

+		dmaj = -dmaj;

+		octant = XDECREASING;

+	    } else octant = 0;		   

+

+	    if((dmin = y2 - y1) < 0) {

+		dmin = -dmin;

+		octant |= YDECREASING;

+	    }	

+	

+	    if(dmin >= dmaj){

+		tmp = dmin; dmin = dmaj; dmaj = tmp;

+		octant |= YMAJOR;

+	    }

+

+	    e = -dmaj - ((bias >> octant) & 1);

+	    len = dmaj;

+	    dmin <<= 1;

+	    dmaj <<= 1;

+	} else {	/* Muffle compiler */

+	    dmin = dmaj = e = octant = len = 0;

+	}

+

+	while(nbox--) {

+	    oc1 = oc2 = 0;

+	    OUTCODES(oc1, x1, y1, pbox);

+	    OUTCODES(oc2, x2, y2, pbox);

+	    if (!(oc1 | oc2)) {   /* uncliped */

+		if(infoRec->SubsequentDashedTwoPointLine) {

+		   (*infoRec->SubsequentDashedTwoPointLine)(

+				infoRec->pScrn, x1, y1, x2, y2, 

+#ifdef POLYSEGMENT

+			    	(pGC->capStyle != CapNotLast) ? 0 :

+#endif

+				OMIT_LAST, PatternOffset);

+		} else {

+		    (*infoRec->SubsequentDashedBresenhamLine)(

+				infoRec->pScrn, x1, y1, dmaj, dmin, e, 

+#ifdef POLYSEGMENT

+			    	(pGC->capStyle != CapNotLast) ? (len+1) :

+#endif

+			    	len, octant, PatternOffset);

+		}

+		break;

+	    } else if (oc1 & oc2) { /* completely clipped */

+		pbox++;

+	    } else if (infoRec->ClippingFlags & HARDWARE_CLIP_DASHED_LINE) {

+		(*infoRec->SetClippingRectangle)(infoRec->pScrn,

+			pbox->x1, pbox->y1, pbox->x2 - 1, pbox->y2 - 1);

+

+		if(infoRec->SubsequentDashedBresenhamLine) {

+		    (*infoRec->SubsequentDashedBresenhamLine)(

+				infoRec->pScrn, x1, y1, dmaj, dmin, e, 

+#ifdef POLYSEGMENT

+			    	(pGC->capStyle != CapNotLast) ? (len+1) :

+#endif

+			    	len, octant, PatternOffset);

+		} else {

+			(*infoRec->SubsequentDashedTwoPointLine)(

+				infoRec->pScrn, x1, y1, x2, y2, 

+#ifdef POLYSEGMENT

+			    	(pGC->capStyle != CapNotLast) ? 0 :

+#endif

+				OMIT_LAST, PatternOffset

+			);

+		}

+		(*infoRec->DisableClipping)(infoRec->pScrn);

+		pbox++;

+	    } else {

+		int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;

+		int clip1 = 0, clip2 = 0;

+		int err, adx, ady;

+		    

+		if(octant & YMAJOR) {

+		    ady = dmaj >> 1;

+		    adx = dmin >> 1;

+		} else {

+		    ady = dmin >> 1;

+		    adx = dmaj >> 1;

+		}

+

+		if (miZeroClipLine(pbox->x1, pbox->y1, 

+				       pbox->x2 - 1, pbox->y2 - 1,

+				       &new_x1, &new_y1, &new_x2, &new_y2,

+				       adx, ady, &clip1, &clip2,

+				       octant, bias, oc1, oc2) == -1)

+		{

+		    pbox++;

+		    continue;

+		}

+

+		if (octant & YMAJOR)

+		    len = abs(new_y2 - new_y1);

+		else

+		    len = abs(new_x2 - new_x1);

+#ifdef POLYSEGMENT

+		if (clip2 != 0 || pGC->capStyle != CapNotLast)

+		    len++;

+#else

+		len += (clip2 != 0);

+#endif

+		if (len) {

+		    int abserr, clipdx, clipdy;

+			/* unwind bresenham error term to first point */

+		    if (clip1) {

+			clipdx = abs(new_x1 - x1);

+			clipdy = abs(new_y1 - y1);

+

+			if (octant & YMAJOR)

+			    err = e + clipdy*dmin - clipdx*dmaj;

+			else

+			    err = e + clipdx*dmin - clipdy*dmaj;

+		    } else

+			err = e;

+

+#define range infoRec->DashedBresenhamLineErrorTermBits

+		    abserr = abs(err);			    

+		    while((abserr & range) || 

+			  (dmaj & range) ||

+			  (dmin & range)) {

+			dmin >>= 1;

+			dmaj >>= 1;

+			abserr >>= 1;

+			err /= 2;

+		    }

+

+		    if(octant & YMAJOR)

+			offset = abs(new_y1 - y1);

+		    else 

+			offset = abs(new_x1 - x1);

+

+		    offset += PatternOffset;

+		    offset %= PatternLength;

+

+		    (*infoRec->SubsequentDashedBresenhamLine)(

+				infoRec->pScrn, new_x1, new_y1,

+				dmaj, dmin, err, len, octant, offset);

+		}

+		pbox++;

+	    }

+	} /* while (nbox--) */

+#ifndef POLYSEGMENT

+	len = abs(y2 - y1);

+	tmp = abs(x2 - x1);

+	PatternOffset += (len > tmp) ? len : tmp;

+	PatternOffset %= PatternLength;

+#endif

+    } /* while (nline--) */

+

+#ifndef POLYSEGMENT

+    /* paint the last point if the end style isn't CapNotLast.

+       (Assume that a projecting, butt, or round cap that is one

+        pixel wide is the same as the single pixel of the endpoint.)

+    */

+

+    if ((pGC->capStyle != CapNotLast) &&

+	((ppt->x + xorg != pptInit->x + pDrawable->x) ||

+	 (ppt->y + yorg != pptInit->y + pDrawable->y) ||

+	 (ppt == pptInit + 1)))

+    {

+	nbox = nboxInit;

+	pbox = pboxInit;

+	while (nbox--) {

+	    if ((x2 >= pbox->x1) && (y2 >= pbox->y1) &&

+		(x2 <  pbox->x2) && (y2 <  pbox->y2))

+	    {

+		if(infoRec->SubsequentDashedTwoPointLine) {

+			(*infoRec->SubsequentDashedTwoPointLine)(

+				infoRec->pScrn, x2, y2, x2, y2, 0,

+				PatternOffset);

+		} else {

+			(*infoRec->SubsequentDashedBresenhamLine)(

+				infoRec->pScrn, x2, y2, 2, 0, -1, 

+				1, 0, PatternOffset);

+		}

+		break;

+	    } else

+		pbox++;

+	}

+    }

+#endif

+

+    SET_SYNC_FLAG(infoRec);

+}

+

diff --git a/xorg-server/hw/xfree86/xaa/xaaFillArc.c b/xorg-server/hw/xfree86/xaa/xaaFillArc.c
index d83922ce0..824d2af1d 100644
--- a/xorg-server/hw/xfree86/xaa/xaaFillArc.c
+++ b/xorg-server/hw/xfree86/xaa/xaaFillArc.c
@@ -1,213 +1,213 @@
-/*
- * Copyright 1996  The XFree86 Project
- *
- * Permission is hereby granted, free of charge, to any person obtaining a 
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation 
- * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
- * and/or sell copies of the Software, and to permit persons to whom the 
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
- * HARM HANEMAAYER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
- * SOFTWARE.
- * 
- * Written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net).
- */
- 
-/*
- * Filled solid arcs, based on cfbfillarc.c.
- *
- * Fill arc using calls to low-level span fill. Because the math for
- * each span can be done concurrently with the drawing of the span
- * with a graphics coprocessor operation, this is faster than just
- * using miPolyFillArc, which first calculates all the spans and then
- * calls FillSpans.
- *
- * Clipped arcs are dispatched to FillSpans.
- */
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <limits.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "mifillarc.h"
-#include "mi.h"
-
-/*
- * This is based on the integer-math versions from mi. Perhaps on a
- * Pentium, the floating-point (double)-math version is faster.
- */
-
-static void
-XAAFillEllipseSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    register int x, y, e;
-    int yk, xk, ym, xm, dx, dy, xorg, yorg;
-    int slw;
-    miFillArcRec info;
-
-    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,
-		pGC->planemask);
-
-    miFillArcSetup(arc, &info);
-    MIFILLARCSETUP();
-    if (pGC->miTranslate)
-    {
-	xorg += pDraw->x;
-	yorg += pDraw->y;
-    }
-    while (y > 0)
-    {
-	MIFILLARCSTEP(slw);
-	if (slw > 0) {
-	    (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn, xorg - x,
-		    yorg - y, slw, 1);
-            if (miFillArcLower(slw))
-		(*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,
-			xorg - x, yorg + y + dy, slw, 1);
-	}
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-
-#define ADDSPAN(l,r) \
-    if (r >= l) \
-	(*infoRec->SubsequentSolidFillRect)( \
-	    infoRec->pScrn, l, ya, r - l + 1, 1);
-
-#define ADDSLICESPANS(flip) \
-    if (!flip) \
-    { \
-	ADDSPAN(xl, xr); \
-    } \
-    else \
-    { \
-	xc = xorg - x; \
-	ADDSPAN(xc, xr); \
-	xc += slw - 1; \
-	ADDSPAN(xl, xc); \
-    }
-
-static void
-XAAFillArcSliceSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)
-{ 
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
-    register int x, y, e;
-    miFillArcRec info;
-    miArcSliceRec slice;
-    int ya, xl, xr, xc;
-
-    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,
-        pGC->planemask);
-
-    miFillArcSetup(arc, &info);
-    miFillArcSliceSetup(arc, &slice, pGC);
-    MIFILLARCSETUP();
-    slw = arc->height;
-    if (slice.flip_top || slice.flip_bot)
-	slw += (arc->height >> 1) + 1;
-    if (pGC->miTranslate)
-    {
-	xorg += pDraw->x;
-	yorg += pDraw->y;
-	slice.edge1.x += pDraw->x;
-	slice.edge2.x += pDraw->x;
-    }
-    while (y > 0)
-    {
-	MIFILLARCSTEP(slw);
-	MIARCSLICESTEP(slice.edge1);
-	MIARCSLICESTEP(slice.edge2);
-	if (miFillSliceUpper(slice))
-	{
-	    ya = yorg - y;
-	    MIARCSLICEUPPER(xl, xr, slice, slw);
-	    
-	    ADDSLICESPANS(slice.flip_top);
-	}
-	if (miFillSliceLower(slice))
-	{
-	    ya = yorg + y + dy;
-	    MIARCSLICELOWER(xl, xr, slice, slw);
-	    ADDSLICESPANS(slice.flip_bot);
-	}
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-
-void
-XAAPolyFillArcSolid(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
-{
-    register xArc *arc;
-    register int i;
-    int x2, y2;
-    BoxRec box;
-    RegionPtr cclip;
-
-    cclip = pGC->pCompositeClip;
-
-    if(!REGION_NUM_RECTS(cclip))
-	return;
-
-    for (arc = parcs, i = narcs; --i >= 0; arc++)
-    {
-	if (miFillArcEmpty(arc))
-	    continue;
-	if (miCanFillArc(arc))
-	{
-	    box.x1 = arc->x + pDraw->x;
-	    box.y1 = arc->y + pDraw->y;
- 	    /*
- 	     * Because box.x2 and box.y2 get truncated to 16 bits, and the
- 	     * RECT_IN_REGION test treats the resulting number as a signed
- 	     * integer, the RECT_IN_REGION test alone can go the wrong way.
- 	     * This can result in a server crash because the rendering
- 	     * routines in this file deal directly with cpu addresses
- 	     * of pixels to be stored, and do not clip or otherwise check
- 	     * that all such addresses are within their respective pixmaps.
- 	     * So we only allow the RECT_IN_REGION test to be used for
- 	     * values that can be expressed correctly in a signed short.
- 	     */
- 	    x2 = box.x1 + (int)arc->width + 1;
- 	    box.x2 = x2;
- 	    y2 = box.y1 + (int)arc->height + 1;
- 	    box.y2 = y2;
- 	    if ( (x2 <= SHRT_MAX) && (y2 <= SHRT_MAX) &&
- 		    (RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
-	    {
-		if ((arc->angle2 >= FULLCIRCLE) ||
-		    (arc->angle2 <= -FULLCIRCLE))
-		    XAAFillEllipseSolid(pDraw, pGC, arc);
-		else
-		    XAAFillArcSliceSolid(pDraw, pGC, arc);
-		continue;
-	    }
-	}
-	miPolyFillArc(pDraw, pGC, 1, arc);
-    }
-}
+/*

+ * Copyright 1996  The XFree86 Project

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a 

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation 

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 

+ * and/or sell copies of the Software, and to permit persons to whom the 

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 

+ * HARM HANEMAAYER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 

+ * SOFTWARE.

+ * 

+ * Written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net).

+ */

+ 

+/*

+ * Filled solid arcs, based on cfbfillarc.c.

+ *

+ * Fill arc using calls to low-level span fill. Because the math for

+ * each span can be done concurrently with the drawing of the span

+ * with a graphics coprocessor operation, this is faster than just

+ * using miPolyFillArc, which first calculates all the spans and then

+ * calls FillSpans.

+ *

+ * Clipped arcs are dispatched to FillSpans.

+ */

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <limits.h>

+

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include <X11/X.h>

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "xf86str.h"

+#include "xaa.h"

+#include "xaalocal.h"

+#include "mifillarc.h"

+#include "mi.h"

+

+/*

+ * This is based on the integer-math versions from mi. Perhaps on a

+ * Pentium, the floating-point (double)-math version is faster.

+ */

+

+static void

+XAAFillEllipseSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    register int x, y, e;

+    int yk, xk, ym, xm, dx, dy, xorg, yorg;

+    int slw;

+    miFillArcRec info;

+

+    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,

+		pGC->planemask);

+

+    miFillArcSetup(arc, &info);

+    MIFILLARCSETUP();

+    if (pGC->miTranslate)

+    {

+	xorg += pDraw->x;

+	yorg += pDraw->y;

+    }

+    while (y > 0)

+    {

+	MIFILLARCSTEP(slw);

+	if (slw > 0) {

+	    (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn, xorg - x,

+		    yorg - y, slw, 1);

+            if (miFillArcLower(slw))

+		(*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,

+			xorg - x, yorg + y + dy, slw, 1);

+	}

+    }

+

+    SET_SYNC_FLAG(infoRec);

+}

+

+

+#define ADDSPAN(l,r) \

+    if (r >= l) \

+	(*infoRec->SubsequentSolidFillRect)( \

+	    infoRec->pScrn, l, ya, r - l + 1, 1);

+

+#define ADDSLICESPANS(flip) \

+    if (!flip) \

+    { \

+	ADDSPAN(xl, xr); \

+    } \

+    else \

+    { \

+	xc = xorg - x; \

+	ADDSPAN(xc, xr); \

+	xc += slw - 1; \

+	ADDSPAN(xl, xc); \

+    }

+

+static void

+XAAFillArcSliceSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)

+{ 

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;

+    register int x, y, e;

+    miFillArcRec info;

+    miArcSliceRec slice;

+    int ya, xl, xr, xc;

+

+    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,

+        pGC->planemask);

+

+    miFillArcSetup(arc, &info);

+    miFillArcSliceSetup(arc, &slice, pGC);

+    MIFILLARCSETUP();

+    slw = arc->height;

+    if (slice.flip_top || slice.flip_bot)

+	slw += (arc->height >> 1) + 1;

+    if (pGC->miTranslate)

+    {

+	xorg += pDraw->x;

+	yorg += pDraw->y;

+	slice.edge1.x += pDraw->x;

+	slice.edge2.x += pDraw->x;

+    }

+    while (y > 0)

+    {

+	MIFILLARCSTEP(slw);

+	MIARCSLICESTEP(slice.edge1);

+	MIARCSLICESTEP(slice.edge2);

+	if (miFillSliceUpper(slice))

+	{

+	    ya = yorg - y;

+	    MIARCSLICEUPPER(xl, xr, slice, slw);

+	    

+	    ADDSLICESPANS(slice.flip_top);

+	}

+	if (miFillSliceLower(slice))

+	{

+	    ya = yorg + y + dy;

+	    MIARCSLICELOWER(xl, xr, slice, slw);

+	    ADDSLICESPANS(slice.flip_bot);

+	}

+    }

+

+    SET_SYNC_FLAG(infoRec);

+}

+

+

+void

+XAAPolyFillArcSolid(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)

+{

+    register xArc *arc;

+    register int i;

+    int x2, y2;

+    BoxRec box;

+    RegionPtr cclip;

+

+    cclip = pGC->pCompositeClip;

+

+    if(!RegionNumRects(cclip))

+	return;

+

+    for (arc = parcs, i = narcs; --i >= 0; arc++)

+    {

+	if (miFillArcEmpty(arc))

+	    continue;

+	if (miCanFillArc(arc))

+	{

+	    box.x1 = arc->x + pDraw->x;

+	    box.y1 = arc->y + pDraw->y;

+ 	    /*

+ 	     * Because box.x2 and box.y2 get truncated to 16 bits, and the

+ 	     * RECT_IN_REGION test treats the resulting number as a signed

+ 	     * integer, the RECT_IN_REGION test alone can go the wrong way.

+ 	     * This can result in a server crash because the rendering

+ 	     * routines in this file deal directly with cpu addresses

+ 	     * of pixels to be stored, and do not clip or otherwise check

+ 	     * that all such addresses are within their respective pixmaps.

+ 	     * So we only allow the RECT_IN_REGION test to be used for

+ 	     * values that can be expressed correctly in a signed short.

+ 	     */

+ 	    x2 = box.x1 + (int)arc->width + 1;

+ 	    box.x2 = x2;

+ 	    y2 = box.y1 + (int)arc->height + 1;

+ 	    box.y2 = y2;

+ 	    if ( (x2 <= SHRT_MAX) && (y2 <= SHRT_MAX) &&

+		    (RegionContainsRect(cclip, &box) == rgnIN) )

+	    {

+		if ((arc->angle2 >= FULLCIRCLE) ||

+		    (arc->angle2 <= -FULLCIRCLE))

+		    XAAFillEllipseSolid(pDraw, pGC, arc);

+		else

+		    XAAFillArcSliceSolid(pDraw, pGC, arc);

+		continue;

+	    }

+	}

+	miPolyFillArc(pDraw, pGC, 1, arc);

+    }

+}

diff --git a/xorg-server/hw/xfree86/xaa/xaaFillPoly.c b/xorg-server/hw/xfree86/xaa/xaaFillPoly.c
index 6f11e35ff..b8347b336 100644
--- a/xorg-server/hw/xfree86/xaa/xaaFillPoly.c
+++ b/xorg-server/hw/xfree86/xaa/xaaFillPoly.c
@@ -1,962 +1,962 @@
-
-/*
- * Copyright 1996  The XFree86 Project
- *
- * Permission is hereby granted, free of charge, to any person obtaining a 
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation 
- * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
- * and/or sell copies of the Software, and to permit persons to whom the 
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
- * HARM HANEMAAYER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
- * SOFTWARE.
- * 
- */
- 
-/*
- * Written by Mark Vojkovich.  Loosly based on an original version
- * written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net) which
- * only did solid rectangles and didn't have trapezoid support.
- *
- */
-
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "micoord.h"
-
-#include "xaa.h"
-#include "xaalocal.h"
-
-#define POLY_USE_MI		0
-#define POLY_FULLY_CLIPPED	1
-#define POLY_IS_EASY		2
-
-
-#define Setup(c,x,vertex,dx,dy,e,sign,step,DX) {\
-    x = intToX(vertex); \
-    if ((dy = intToY(c) - y)) { \
-    	DX = dx = intToX(c) - x; \
-	step = 0; \
-    	if (dx >= 0) \
-    	{ \
-	    e = 0; \
-	    sign = 1; \
-	    if (dx >= dy) {\
-	    	step = dx / dy; \
-	    	dx %= dy; \
-	    } \
-    	} \
-    	else \
-    	{ \
-	    e = 1 - dy; \
-	    sign = -1; \
-	    dx = -dx; \
-	    if (dx >= dy) { \
-		step = - (dx / dy); \
-		dx %= dy; \
-	    } \
-    	} \
-    } \
-    x += origin; \
-    vertex = c; \
-}
-
-#define Step(x,dx,dy,e,sign,step) {\
-    x += step; \
-    if ((e += dx) > 0) \
-    { \
-	x += sign; \
-	e -= dy; \
-    } \
-}
-
-#define FixError(x, dx, dy, e, sign, step, h)	{	\
-	   e += (h) * dx;				\
-	   x += (h) * step;				\
-	   if(e > 0) {					\
-		x += e * sign/dy;			\
-		e %= dy;				\
-	   	if(e) {					\
-		   x += sign;				\
-		   e -= dy;				\
-		}					\
-	   } 	 					\
-}
-
-
-/*
-   XAAIsEasyPoly -
-
-   Checks CoordModeOrigin one rect polygons to see if we need
-   to use Mi.
-   Returns: POLY_USE_MI, POLY_FULLY_CLIPPED or POLY_IS_EASY
-	as well as the pointer to the "top" point and the y
-	extents.
-*/
-
-int
-XAAIsEasyPolygon(
-   DDXPointPtr ptsIn,
-   int count, 
-   BoxPtr extents,
-   int origin,		
-   DDXPointPtr *topPoint, 	/* return */
-   int *topY, int *bottomY,	/* return */
-   int shape
-){
-    int c = 0, vertex1, vertex2;
-
-    *topY = 32767;
-    *bottomY = 0;
-
-    origin -= (origin & 0x8000) << 1;
-    vertex1 = extents->x1 - origin;
-    vertex2 = extents->x2 - origin /* - 0x00010001 */;
-                     /* I think this was an error in cfb ^ */
-
-    if (shape == Convex) {
-    	while (count--) {
-	    c = *((int*)ptsIn);
-	    if (((c - vertex1) | (vertex2 - c)) & 0x80008000)
-		return POLY_USE_MI;
-
-	    c = intToY(c);
-	    if (c < *topY) {
-	    	*topY = c;
-	    	*topPoint = ptsIn;
-	    }
-	    ptsIn++;
-	    if (c > *bottomY) *bottomY = c;
-    	}
-    } else {
-	int yFlip = 0;
-	int dx2, dx1, x1, x2;
-
-	x2 = x1 = -1;
-	dx2 = dx1 = 1;
-
-    	while (count--) {
-	    c = *((int*)ptsIn);
-	    if (((c - vertex1) | (vertex2 - c)) & 0x80008000)
-		return POLY_USE_MI;
-	    c = intToY(c);
-	    if (c < *topY) {
-	    	*topY = c;
-	    	*topPoint = ptsIn;
-	    }
-	    ptsIn++;
-	    if (c > *bottomY) *bottomY = c;
-	    if (c == x1)
-		continue;
-	    if (dx1 > 0) {
-		if (x2 < 0) x2 = c;
-		else	    dx2 = dx1 = (c - x1) >> 31;
-	    } else if ((c - x1) >> 31 != dx1) {
-		dx1 = ~dx1;
-		yFlip++;
-	    }
-	    x1 = c;
-       	}
-	x1 = (x2 - c) >> 31;
-	if (x1 != dx1) yFlip++;
-	if (x1 != dx2) yFlip++;
-	if (yFlip != 2) {
-	   if(*topY == *bottomY)
-		return POLY_FULLY_CLIPPED;
-	   else
-		return POLY_USE_MI;
-	}
-    }
-    if (*topY == *bottomY)
-	return POLY_FULLY_CLIPPED;
-
-    return POLY_IS_EASY;
-}
-
-void
-XAAFillPolygonSolid(
-    DrawablePtr	pDraw,
-    GCPtr	pGC,
-    int		shape,
-    int		mode,
-    int		count,
-    DDXPointPtr	ptsIn 
-){
-    XAAInfoRecPtr   infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int    	    origin, vertex1, vertex2;
-    int		    *vertex1p, *vertex2p, *endp;
-    int		    x1 = 0, x2 = 0;
-    int 	    dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;
-    int		    DX1 = 0, DX2 = 0, e1 = 0, e2 = 0;
-    int		    step1 = 0, step2 = 0, sign1 = 0, sign2 = 0;
-    int		    c, y, maxy, h, yoffset;
-    DDXPointPtr	    topPoint;
-
-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))
-	return;
-
-    if (mode == CoordModePrevious) {
-	register DDXPointPtr ppt = ptsIn + 1;
-
-	for (origin = 1; origin < count; origin++, ppt++) {
-	    ppt->x += (ppt-1)->x;
-	    ppt->y += (ppt-1)->y;
-	}
-        mode = CoordModeOrigin;
-    }
-    
-    if (REGION_NUM_RECTS(pGC->pCompositeClip) != 1) {
-	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);
-	return;
-    }
-
-    origin = coordToInt(pDraw->x, pDraw->y);
-
-    switch( XAAIsEasyPolygon(ptsIn, count, &pGC->pCompositeClip->extents, 
-		origin, &topPoint, &y, &maxy, shape) ) {
-    case POLY_USE_MI: 
-	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);
-    case POLY_FULLY_CLIPPED: 
-	return;
-    }
-
-    endp = (int*)ptsIn + count;
-    vertex2p = vertex1p = (int *)topPoint;
-    origin = pDraw->x;
-    yoffset = pDraw->y;
-    vertex2 = vertex1 = *vertex2p++;
-    if (vertex2p == endp)
-	vertex2p = (int *) ptsIn;
-
-    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,
-        pGC->planemask);
-
-    while(1) {
-	if (y == intToY(vertex1)) {
-	    do {
-	    	if (vertex1p == (int *) ptsIn)
-		    vertex1p = endp;
-	    	c = *--vertex1p;
-	    	Setup (c,x1,vertex1,dx1,dy1,e1,sign1,step1,DX1)
-	    } while (y >= intToY(vertex1));
-	    h = dy1;
-	} else {
-	    Step(x1,dx1,dy1,e1,sign1,step1)
-	    h = intToY(vertex1) - y;
-	}
-	if (y == intToY(vertex2)) {
-	    do {
-	    	c = *vertex2p++;
-	    	if (vertex2p == endp)
-		    vertex2p = (int *) ptsIn;
-	    	Setup (c,x2,vertex2,dx2,dy2,e2,sign2,step2,DX2)
-	    } while (y >= intToY(vertex2));
-	    if (dy2 < h)
-		h = dy2;
-	} else {
-	    Step(x2,dx2,dy2,e2,sign2,step2)
-	    if ((c = (intToY(vertex2) - y)) < h)
-		h = c;
-	}
-
-	/* fill spans for this segment */
-        if(DX1 | DX2) {
-      	  if(infoRec->SubsequentSolidFillTrap && (h > 6)) {
-	     if(x1 == x2) {
-		while(x1 == x2) {
-	     	   y++;
-	    	   if (!--h) break;
-	    	   Step(x1,dx1,dy1,e1,sign1,step1)
-	    	   Step(x2,dx2,dy2,e2,sign2,step2)
-		}
-		if(y == maxy) break;
-    		if(!h) continue;
-	     }
-
-             if(x1 < x2)
- 	     	(*infoRec->SubsequentSolidFillTrap)(infoRec->pScrn,
-					y + yoffset, h,
-					x1, DX1, dy1, e1, 
-					x2 - 1, DX2, dy2, e2);
-	     else
- 	     	(*infoRec->SubsequentSolidFillTrap)(infoRec->pScrn,
-					y + yoffset, h,
-					x2, DX2, dy2, e2, 
-					x1 - 1, DX1, dy1, e1);
-	     y += h;	
-             if(--h) {
-	     	FixError(x1,dx1,dy1,e1,sign1,step1,h);
-	     	FixError(x2,dx2,dy2,e2,sign2,step2,h);
-		h = 0;
-	     }  	
-	  } else {
-	     while(1) {
-	    	if (x2 > x1)
-	            (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,
-	            		x1, y + yoffset, x2 - x1, 1);
-	        else if (x1 > x2)
-	            (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,
-	                    x2, y + yoffset, x1 - x2, 1);
-	     	y++;
-	    	if (!--h) break;
-	    	Step(x1,dx1,dy1,e1,sign1,step1)
-	    	Step(x2,dx2,dy2,e2,sign2,step2)
-	     }
-	  }
-	} else {
-	    if (x2 > x1)
-	        (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,
-	            x1, y + yoffset, x2 - x1, h);
-	    else if (x1 > x2)
-	        (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,
-	                x2, y + yoffset, x1 - x2, h);
-
-	    y += h;
-	    h = 0;
-        } 
-	if (y == maxy) break;
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-
-
-
-void
-XAAFillPolygonHelper(
-    ScrnInfoPtr pScrn,
-    DDXPointPtr	ptsIn,
-    int 	count,
-    DDXPointPtr topPoint,
-    int 	y,
-    int		maxy,
-    int		origin,
-    RectFuncPtr RectFunc,
-    TrapFuncPtr TrapFunc,
-    int 	xorg,
-    int		yorg,
-    XAACacheInfoPtr pCache
-){
-    int		    *vertex1p, *vertex2p, *endp;
-    int		    vertex1, vertex2;
-    int		    x1 = 0, x2 = 0;
-    int		    dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;
-    int		    DX1 = 0, DX2 = 0, e1 = 0, e2 = 0;
-    int		    step1 = 0, step2 = 0, sign1 = 0, sign2 = 0;
-    int		    c, h, yoffset;
-
-
-    endp = (int*)ptsIn + count;
-    vertex2p = vertex1p = (int *)topPoint;
-    yoffset = intToY(origin);
-    origin = intToX(origin);
-    vertex2 = vertex1 = *vertex2p++;
-    if (vertex2p == endp)
-	vertex2p = (int *)ptsIn;
-
-    while(1) {
-	if (y == intToY(vertex1)) {
-	    do {
-	    	if (vertex1p == (int *) ptsIn)
-		    vertex1p = endp;
-	    	c = *--vertex1p;
-	    	Setup (c,x1,vertex1,dx1,dy1,e1,sign1,step1,DX1)
-	    } while (y >= intToY(vertex1));
-	    h = dy1;
-	} else {
-	    Step(x1,dx1,dy1,e1,sign1,step1)
-	    h = intToY(vertex1) - y;
-	}
-	if (y == intToY(vertex2)) {
-	    do {
-	    	c = *vertex2p++;
-	    	if (vertex2p == endp)
-		    vertex2p = (int *) ptsIn;
-	    	Setup (c,x2,vertex2,dx2,dy2,e2,sign2,step2,DX2)
-	    } while (y >= intToY(vertex2));
-	    if (dy2 < h)
-		h = dy2;
-	} else {
-	    Step(x2,dx2,dy2,e2,sign2,step2)
-	    if ((c = (intToY(vertex2) - y)) < h)
-		h = c;
-	}
-
-	/* fill spans for this segment */
-        if(DX1 | DX2) {
-      	  if(TrapFunc && (h > 6)) {
-	     if(x1 == x2) {
-		while(x1 == x2) {
-	     	   y++;
-	    	   if (!--h) break;
-	    	   Step(x1,dx1,dy1,e1,sign1,step1)
-	    	   Step(x2,dx2,dy2,e2,sign2,step2)
-		}
-		if(y == maxy) break;
-    		if(!h) continue;
-	     }
-
-             if(x1 < x2)
- 	     	(*TrapFunc)(pScrn, y + yoffset, h,
-				x1, DX1, dy1, e1, 
-				x2 - 1, DX2, dy2, e2, xorg, yorg, pCache);
-	     else
- 	     	(*TrapFunc)(pScrn, y + yoffset, h,
-				x2, DX2, dy2, e2, 
-				x1 - 1, DX1, dy1, e1, xorg, yorg, pCache);
-	     y += h;	
-             if(--h) {
-	     	FixError(x1,dx1,dy1,e1,sign1,step1,h);
-	     	FixError(x2,dx2,dy2,e2,sign2,step2,h);
-		h = 0;
-	     }  	
-	  } else {
-	     while(1) {
-	    	if (x2 > x1)
-	            (*RectFunc)(pScrn,
-	            	x1, y + yoffset, x2 - x1, 1, xorg, yorg, pCache);
-	        else if (x1 > x2)
-	            (*RectFunc)(pScrn,
-	                    x2, y + yoffset, x1 - x2, 1, xorg, yorg, pCache);
-	     	y++;
-	    	if (!--h) break;
-	    	Step(x1,dx1,dy1,e1,sign1,step1)
-	    	Step(x2,dx2,dy2,e2,sign2,step2)
-	     }
-	  }
-	} else {
-	    if (x2 > x1)
-	        (*RectFunc)(pScrn,
-	            x1, y + yoffset, x2 - x1, h, xorg, yorg, pCache);
-	    else if (x1 > x2)
-	        (*RectFunc)(pScrn,
-	                x2, y + yoffset, x1 - x2, h, xorg, yorg, pCache);
-
-	    y += h;
-	    h = 0;
-        } 
-	if (y == maxy) break;
-    }
-}
-
-        /*****************\
-	|  Solid Helpers  |
-	\*****************/
-
-static void
-SolidTrapHelper(
-   ScrnInfoPtr pScrn,
-   int y, int h,
-   int x1, int dx1, int dy1, int e1,
-   int x2, int dx2, int dy2, int e2,
-   int xorg, int yorg,
-   XAACacheInfoPtr pCache
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SubsequentSolidFillTrap) (pScrn, 
-		y, h, x1, dx1, dy1, e1, x2, dx2, dy2, e2);
-}
-
-static void
-SolidRectHelper (
-   ScrnInfoPtr pScrn,
-   int x, int y, int w, int h,
-   int xorg, int yorg,   
-   XAACacheInfoPtr pCache
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
-}
-
-
-	/*********************\
-	|  Mono 8x8 Patterns  |
-	\*********************/
-
-static void
-Mono8x8PatternTrapHelper_ScreenOrigin(
-   ScrnInfoPtr pScrn,
-   int y, int h,
-   int x1, int dx1, int dy1, int e1,
-   int x2, int dx2, int dy2, int e2,
-   int xorg, int yorg,
-   XAACacheInfoPtr pCache
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SubsequentMono8x8PatternFillTrap) (pScrn, xorg, yorg,
-		y, h, x1, dx1, dy1, e1, x2, dx2, dy2, e2);
-}
-
-static void
-Mono8x8PatternRectHelper_ScreenOrigin (
-   ScrnInfoPtr pScrn,
-   int x, int y, int w, int h,
-   int xorg, int yorg,   
-   XAACacheInfoPtr pCache
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn, xorg, yorg,
-						x, y, w, h);
-}
-
-static void
-Mono8x8PatternRectHelper (
-   ScrnInfoPtr pScrn,
-   int x, int y, int w, int h,
-   int xorg, int yorg,   
-   XAACacheInfoPtr pCache
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    xorg = (x - xorg) & 0x07;
-    yorg = (y - yorg) & 0x07;
-
-    if(!(infoRec->Mono8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	if(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_BITS) {
-		int patx = pCache->pat0; 
-		int paty = pCache->pat1;
-		XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-				(infoRec->Mono8x8PatternFillFlags & 		
-				BIT_ORDER_IN_BYTE_MSBFIRST));
-		xorg = patx; yorg = paty;
-	} else {
-		int slot = (yorg << 3) + xorg;
-	    	xorg = pCache->x + pCache->offsets[slot].x;
-	    	yorg = pCache->y + pCache->offsets[slot].y;
-	}
-     }
-
-
-    (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn, xorg, yorg,
-						x, y, w, h);
-}
-
-
-
-	/****************\
-	|  Cache Expand  |
-	\****************/
-
-
-static void
-CacheExpandRectHelper (
-   ScrnInfoPtr pScrn,
-   int X, int Y, int Width, int Height,
-   int xorg, int yorg,   
-   XAACacheInfoPtr pCache
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, phaseY, phaseX, skipleft, w, blit_w, blit_h;
-    int cacheWidth;
-
-    cacheWidth = (pCache->w * pScrn->bitsPerPixel) / 
-	infoRec->CacheColorExpandDensity;
-
-    phaseY = (Y - yorg) % pCache->orig_h;
-    if(phaseY < 0) phaseY += pCache->orig_h;
-    phaseX = (X - xorg) % pCache->orig_w;
-    if(phaseX < 0) phaseX += pCache->orig_w;
-	
-    while(1) {
-	w = Width; skipleft = phaseX; x = X;
-	blit_h = pCache->h - phaseY;
-	if(blit_h > Height) blit_h = Height;
-	
-	while(1) {
-		blit_w = cacheWidth - skipleft;
-		if(blit_w > w) blit_w = w;
-		(*infoRec->SubsequentScreenToScreenColorExpandFill)(
-			pScrn, x, Y, blit_w, blit_h,
-			pCache->x, pCache->y + phaseY, skipleft);
-		w -= blit_w;
-		if(!w) break;
-		x += blit_w;
-		skipleft = (skipleft + blit_w) % pCache->orig_w;
-	}
-	Height -= blit_h;
-	if(!Height) break;
-	Y += blit_h;
-	phaseY = (phaseY + blit_h) % pCache->orig_h;
-    }
-}
-
-
-
-	/**************\
-	|  Cache Blit  |
-	\**************/
-
-
-static void
-CacheBltRectHelper (
-   ScrnInfoPtr pScrn,
-   int X, int Y, int Width, int Height,
-   int xorg, int yorg,   
-   XAACacheInfoPtr pCache
-){
-     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-     int x, phaseY, phaseX, skipleft, w, blit_w, blit_h;
-
-     phaseY = (Y - yorg) % pCache->orig_h;
-     if(phaseY < 0) phaseY += pCache->orig_h;
-     phaseX = (X - xorg) % pCache->orig_w;
-     if(phaseX < 0) phaseX += pCache->orig_w;
-
-     while(1) {
-	w = Width; skipleft = phaseX; x = X;
-	blit_h = pCache->h - phaseY;
-	if(blit_h > Height) blit_h = Height;
-	
-	while(1) {
-	    blit_w = pCache->w - skipleft;
-	    if(blit_w > w) blit_w = w;
-	    (*infoRec->SubsequentScreenToScreenCopy)(pScrn,
-			pCache->x + skipleft, pCache->y + phaseY,
-			x, Y, blit_w, blit_h);
-	    w -= blit_w;
-	    if(!w) break;
-	    x += blit_w;
-	    skipleft = (skipleft + blit_w) % pCache->orig_w;
-	}
-	Height -= blit_h;
-	if(!Height) break;
-	Y += blit_h;
-	phaseY = (phaseY + blit_h) % pCache->orig_h;
-     }	
-}
-
-
-	/**********************\
-	|   Stippled Polygons  |
-	\**********************/
-
-
-void
-XAAFillPolygonStippled(
-    DrawablePtr	pDraw,
-    GCPtr	pGC,
-    int		shape,
-    int		mode,
-    int		count,
-    DDXPointPtr	ptsIn 
-){
-    XAAInfoRecPtr   infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAPixmapPtr    pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-    int    	    origin, type, patx, paty, fg, bg;
-    int		    y, maxy, xorg, yorg;
-    DDXPointPtr	    topPoint;
-    XAACacheInfoPtr pCache = NULL;
-    RectFuncPtr	    RectFunc = NULL;
-    TrapFuncPtr	    TrapFunc = NULL;
-
-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))
-	return;
-
-    if (mode == CoordModePrevious) {
-	register DDXPointPtr ppt = ptsIn + 1;
-
-	for (origin = 1; origin < count; origin++, ppt++) {
-	    ppt->x += (ppt-1)->x;
-	    ppt->y += (ppt-1)->y;
-	}
-        mode = CoordModeOrigin;
-    }
-    
-    if (REGION_NUM_RECTS(pGC->pCompositeClip) != 1) {
-	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);
-	return;
-    }
-
-
-    if(pGC->fillStyle == FillStippled) {
-    	type = (*infoRec->StippledFillChooser)(pGC);
-	fg = pGC->fgPixel;  bg = -1;
-    } else {
-    	type = (*infoRec->OpaqueStippledFillChooser)(pGC);
-	fg = pGC->fgPixel;  bg = pGC->bgPixel;
-    }
-
-
-    if(!type) {
-	(*XAAFallbackOps.FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn);
-	return;
-    }
-	
-    if((type == DO_COLOR_EXPAND) || (type == DO_COLOR_8x8)) {
-	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);
-	return;
-    }
-
-    origin = pDraw->x;
-
-    switch( XAAIsEasyPolygon(ptsIn, count, &pGC->pCompositeClip->extents,
-		 origin, &topPoint, &y, &maxy, shape) ) {
-    case POLY_USE_MI: 
-	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);
-    case POLY_FULLY_CLIPPED: 
-	return;
-    }
-
-    xorg = (pDraw->x + pGC->patOrg.x);
-    yorg = (pDraw->y + pGC->patOrg.y);
-
-
-    if((fg == bg) && (bg != -1) && infoRec->SetupForSolidFill) {
-
-	(*infoRec->SetupForSolidFill)(infoRec->pScrn, fg,
-				pGC->alu, pGC->planemask);
-
-	RectFunc = SolidRectHelper;
-        TrapFunc = infoRec->SubsequentSolidFillTrap ? SolidTrapHelper : NULL;
-    } else
-    switch(type) {
-	case DO_MONO_8x8:
-	    patx = pPriv->pattern0; paty = pPriv->pattern1;
-	    if(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_SCREEN_ORIGIN) {
-		xorg = (-xorg) & 0x07; yorg = (-yorg) & 0x07;
-		if(infoRec->Mono8x8PatternFillFlags & 
-					HARDWARE_PATTERN_PROGRAMMED_BITS) {
-		    if(!(infoRec->Mono8x8PatternFillFlags & 		
-					HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-		        XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-				(infoRec->Mono8x8PatternFillFlags & 		
-				BIT_ORDER_IN_BYTE_MSBFIRST));
-		        xorg = patx; yorg = paty;
-		    }
-	        } else {
-		    XAACacheInfoPtr pCache = (*infoRec->CacheMono8x8Pattern)(
-					infoRec->pScrn, patx, paty);
-		    patx = pCache->x;  paty = pCache->y;
-		    if(!(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-			int slot = (yorg << 3) + xorg;
-			patx += pCache->offsets[slot].x;
-			paty += pCache->offsets[slot].y;
-			xorg = patx;  yorg = paty;
-		    }
-	        }	
-		RectFunc = Mono8x8PatternRectHelper_ScreenOrigin;
-		if(infoRec->SubsequentMono8x8PatternFillTrap)
-		    TrapFunc = Mono8x8PatternTrapHelper_ScreenOrigin;
-	    } else {  /* !HARDWARE_PATTERN_SCREEN_ORIGIN */
-		if(!(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_BITS)){
-		    pCache = (*infoRec->CacheMono8x8Pattern)(
-					infoRec->pScrn, patx, paty);
-		    patx = pCache->x;  paty = pCache->y;
-	    	} else {
-                    pCache = &(infoRec->ScratchCacheInfoRec);
-                    pCache->pat0 = patx;
-                    pCache->pat1 = paty;
-                }
-		RectFunc = Mono8x8PatternRectHelper;
-       	    }
-
-	    (*infoRec->SetupForMono8x8PatternFill)(infoRec->pScrn, 
-				patx, paty, fg, bg, pGC->alu, pGC->planemask);
-	    break;
-	case DO_CACHE_EXPAND:
-	    pCache = (*infoRec->CacheMonoStipple)(infoRec->pScrn, pGC->stipple);
-
-	    (*infoRec->SetupForScreenToScreenColorExpandFill)(
-		infoRec->pScrn, fg, bg, pGC->alu, pGC->planemask);
-
-	    RectFunc = CacheExpandRectHelper;
-	    break;
-	case DO_CACHE_BLT:
-	    pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 
-							fg, bg);
-	    (*infoRec->SetupForScreenToScreenCopy)(infoRec->pScrn, 1, 1, 
-		pGC->alu, pGC->planemask, pCache->trans_color);
-
-	    RectFunc = CacheBltRectHelper;
-	    break;
-	default:
-	    return;
-    }
-        
-
-    XAAFillPolygonHelper(infoRec->pScrn, ptsIn, count, topPoint, 
-		y, maxy, origin, RectFunc, TrapFunc, xorg, yorg, pCache);
-
-    SET_SYNC_FLAG(infoRec);	
-}
-
-
-
-
-	/*******************\
-	|   Tiled Polygons  |
-	\*******************/
-
-
-void
-XAAFillPolygonTiled(
-    DrawablePtr	pDraw,
-    GCPtr	pGC,
-    int		shape,
-    int		mode,
-    int		count,
-    DDXPointPtr	ptsIn 
-){
-    XAAInfoRecPtr   infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAPixmapPtr    pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-    int    	    origin, type, patx, paty;
-    int		    y, maxy, xorg, yorg;
-    DDXPointPtr	    topPoint;
-    XAACacheInfoPtr pCache = NULL;
-    RectFuncPtr	    RectFunc = NULL;
-    TrapFuncPtr	    TrapFunc = NULL;
-
-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))
-	return;
-
-    if (mode == CoordModePrevious) {
-	register DDXPointPtr ppt = ptsIn + 1;
-
-	for (origin = 1; origin < count; origin++, ppt++) {
-	    ppt->x += (ppt-1)->x;
-	    ppt->y += (ppt-1)->y;
-	}
-        mode = CoordModeOrigin;
-    }
-    
-    if (REGION_NUM_RECTS(pGC->pCompositeClip) != 1) {
-	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);
-	return;
-    }
-
-
-    type = (*infoRec->TiledFillChooser)(pGC);
-
-    if(!type || (type == DO_IMAGE_WRITE)) {
-	(*XAAFallbackOps.FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn);
-	return;
-    }
-	
-    if(type == DO_COLOR_8x8) {
-	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);
-	return;
-    }
-
-    origin = pDraw->x;
-
-    switch( XAAIsEasyPolygon(ptsIn, count, &pGC->pCompositeClip->extents,
-		 origin, &topPoint, &y, &maxy, shape) ) {
-    case POLY_USE_MI: 
-	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);
-    case POLY_FULLY_CLIPPED: 
-	return;
-    }
-
-    xorg = (pDraw->x + pGC->patOrg.x);
-    yorg = (pDraw->y + pGC->patOrg.y);
-
-    switch(type) {
-	case DO_MONO_8x8:
-	    patx = pPriv->pattern0; paty = pPriv->pattern1;
-	    if(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_SCREEN_ORIGIN) {
-		xorg = (-xorg) & 0x07; yorg = (-yorg) & 0x07;
-		if(infoRec->Mono8x8PatternFillFlags & 
-					HARDWARE_PATTERN_PROGRAMMED_BITS) {
-		    if(!(infoRec->Mono8x8PatternFillFlags & 		
-					HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-		        XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-				(infoRec->Mono8x8PatternFillFlags & 		
-				BIT_ORDER_IN_BYTE_MSBFIRST));
-		        xorg = patx; yorg = paty;
-		    }
-	        } else {
-		    XAACacheInfoPtr pCache = (*infoRec->CacheMono8x8Pattern)(
-					infoRec->pScrn, patx, paty);
-		    patx = pCache->x;  paty = pCache->y;
-		    if(!(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-			int slot = (yorg << 3) + xorg;
-			patx += pCache->offsets[slot].x;
-			paty += pCache->offsets[slot].y;
-			xorg = patx;  yorg = paty;
-		    }
-	        }	
-		RectFunc = Mono8x8PatternRectHelper_ScreenOrigin;
-		if(infoRec->SubsequentMono8x8PatternFillTrap)
-		    TrapFunc = Mono8x8PatternTrapHelper_ScreenOrigin;
-	    } else {  /* !HARDWARE_PATTERN_SCREEN_ORIGIN */
-		if(!(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_BITS)){
-		    pCache = (*infoRec->CacheMono8x8Pattern)(
-					infoRec->pScrn, patx, paty);
-		    patx = pCache->x;  paty = pCache->y;
-	    	}
-		else {
-		  pCache = &(infoRec->ScratchCacheInfoRec);
-		  pCache->pat0 = patx;
-		  pCache->pat1 = paty;
-		}
-		RectFunc = Mono8x8PatternRectHelper;
-       	    }
-
-	    (*infoRec->SetupForMono8x8PatternFill)(infoRec->pScrn, 
-		 patx, paty, pPriv->fg, pPriv->bg, pGC->alu, pGC->planemask);
-	    break;
-	case DO_CACHE_BLT:
-            pCache = (*infoRec->CacheTile)(infoRec->pScrn, pGC->tile.pixmap);
-	    (*infoRec->SetupForScreenToScreenCopy)(infoRec->pScrn, 1, 1, 
-		pGC->alu, pGC->planemask, -1);
-
-	    RectFunc = CacheBltRectHelper;
-	    break;
-	case DO_PIXMAP_COPY:
-	    pCache = &(infoRec->ScratchCacheInfoRec);
-	    pCache->x = pPriv->offscreenArea->box.x1;
-	    pCache->y = pPriv->offscreenArea->box.y1;
-	    pCache->w = pCache->orig_w = 
-		pPriv->offscreenArea->box.x2 - pCache->x;
-	    pCache->h = pCache->orig_h = 
-		pPriv->offscreenArea->box.y2 - pCache->y;
-
-	    (*infoRec->SetupForScreenToScreenCopy)(infoRec->pScrn, 1, 1, 
-		pGC->alu, pGC->planemask, -1);
-
-	    RectFunc = CacheBltRectHelper;
-	    break;
-	default:
-	    return;
-    }
-
-    XAAFillPolygonHelper(infoRec->pScrn, ptsIn, count, topPoint, 
-		y, maxy, origin, RectFunc, TrapFunc, xorg, yorg, pCache);
-
-    SET_SYNC_FLAG(infoRec);	
-}
-
-
+

+/*

+ * Copyright 1996  The XFree86 Project

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a 

+ * copy of this software and associated documentation files (the "Software"), 

+ * to deal in the Software without restriction, including without limitation 

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 

+ * and/or sell copies of the Software, and to permit persons to whom the 

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ * 

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 

+ * HARM HANEMAAYER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 

+ * SOFTWARE.

+ * 

+ */

+ 

+/*

+ * Written by Mark Vojkovich.  Loosly based on an original version

+ * written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net) which

+ * only did solid rectangles and didn't have trapezoid support.

+ *

+ */

+

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include <X11/X.h>

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "xf86str.h"

+#include "mi.h"

+#include "micoord.h"

+

+#include "xaa.h"

+#include "xaalocal.h"

+

+#define POLY_USE_MI		0

+#define POLY_FULLY_CLIPPED	1

+#define POLY_IS_EASY		2

+

+

+#define Setup(c,x,vertex,dx,dy,e,sign,step,DX) {\

+    x = intToX(vertex); \

+    if ((dy = intToY(c) - y)) { \

+    	DX = dx = intToX(c) - x; \

+	step = 0; \

+    	if (dx >= 0) \

+    	{ \

+	    e = 0; \

+	    sign = 1; \

+	    if (dx >= dy) {\

+	    	step = dx / dy; \

+	    	dx %= dy; \

+	    } \

+    	} \

+    	else \

+    	{ \

+	    e = 1 - dy; \

+	    sign = -1; \

+	    dx = -dx; \

+	    if (dx >= dy) { \

+		step = - (dx / dy); \

+		dx %= dy; \

+	    } \

+    	} \

+    } \

+    x += origin; \

+    vertex = c; \

+}

+

+#define Step(x,dx,dy,e,sign,step) {\

+    x += step; \

+    if ((e += dx) > 0) \

+    { \

+	x += sign; \

+	e -= dy; \

+    } \

+}

+

+#define FixError(x, dx, dy, e, sign, step, h)	{	\

+	   e += (h) * dx;				\

+	   x += (h) * step;				\

+	   if(e > 0) {					\

+		x += e * sign/dy;			\

+		e %= dy;				\

+	   	if(e) {					\

+		   x += sign;				\

+		   e -= dy;				\

+		}					\

+	   } 	 					\

+}

+

+

+/*

+   XAAIsEasyPoly -

+

+   Checks CoordModeOrigin one rect polygons to see if we need

+   to use Mi.

+   Returns: POLY_USE_MI, POLY_FULLY_CLIPPED or POLY_IS_EASY

+	as well as the pointer to the "top" point and the y

+	extents.

+*/

+

+int

+XAAIsEasyPolygon(

+   DDXPointPtr ptsIn,

+   int count, 

+   BoxPtr extents,

+   int origin,		

+   DDXPointPtr *topPoint, 	/* return */

+   int *topY, int *bottomY,	/* return */

+   int shape

+){

+    int c = 0, vertex1, vertex2;

+

+    *topY = 32767;

+    *bottomY = 0;

+

+    origin -= (origin & 0x8000) << 1;

+    vertex1 = extents->x1 - origin;

+    vertex2 = extents->x2 - origin /* - 0x00010001 */;

+                     /* I think this was an error in cfb ^ */

+

+    if (shape == Convex) {

+    	while (count--) {

+	    c = *((int*)ptsIn);

+	    if (((c - vertex1) | (vertex2 - c)) & 0x80008000)

+		return POLY_USE_MI;

+

+	    c = intToY(c);

+	    if (c < *topY) {

+	    	*topY = c;

+	    	*topPoint = ptsIn;

+	    }

+	    ptsIn++;

+	    if (c > *bottomY) *bottomY = c;

+    	}

+    } else {

+	int yFlip = 0;

+	int dx2, dx1, x1, x2;

+

+	x2 = x1 = -1;

+	dx2 = dx1 = 1;

+

+    	while (count--) {

+	    c = *((int*)ptsIn);

+	    if (((c - vertex1) | (vertex2 - c)) & 0x80008000)

+		return POLY_USE_MI;

+	    c = intToY(c);

+	    if (c < *topY) {

+	    	*topY = c;

+	    	*topPoint = ptsIn;

+	    }

+	    ptsIn++;

+	    if (c > *bottomY) *bottomY = c;

+	    if (c == x1)

+		continue;

+	    if (dx1 > 0) {

+		if (x2 < 0) x2 = c;

+		else	    dx2 = dx1 = (c - x1) >> 31;

+	    } else if ((c - x1) >> 31 != dx1) {

+		dx1 = ~dx1;

+		yFlip++;

+	    }

+	    x1 = c;

+       	}

+	x1 = (x2 - c) >> 31;

+	if (x1 != dx1) yFlip++;

+	if (x1 != dx2) yFlip++;

+	if (yFlip != 2) {

+	   if(*topY == *bottomY)

+		return POLY_FULLY_CLIPPED;

+	   else

+		return POLY_USE_MI;

+	}

+    }

+    if (*topY == *bottomY)

+	return POLY_FULLY_CLIPPED;

+

+    return POLY_IS_EASY;

+}

+

+void

+XAAFillPolygonSolid(

+    DrawablePtr	pDraw,

+    GCPtr	pGC,

+    int		shape,

+    int		mode,

+    int		count,

+    DDXPointPtr	ptsIn 

+){

+    XAAInfoRecPtr   infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    int    	    origin, vertex1, vertex2;

+    int		    *vertex1p, *vertex2p, *endp;

+    int		    x1 = 0, x2 = 0;

+    int 	    dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;

+    int		    DX1 = 0, DX2 = 0, e1 = 0, e2 = 0;

+    int		    step1 = 0, step2 = 0, sign1 = 0, sign2 = 0;

+    int		    c, y, maxy, h, yoffset;

+    DDXPointPtr	    topPoint;

+

+    if(!RegionNumRects(pGC->pCompositeClip))

+	return;

+

+    if (mode == CoordModePrevious) {

+	register DDXPointPtr ppt = ptsIn + 1;

+

+	for (origin = 1; origin < count; origin++, ppt++) {

+	    ppt->x += (ppt-1)->x;

+	    ppt->y += (ppt-1)->y;

+	}

+        mode = CoordModeOrigin;

+    }

+    

+    if (RegionNumRects(pGC->pCompositeClip) != 1) {

+	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);

+	return;

+    }

+

+    origin = coordToInt(pDraw->x, pDraw->y);

+

+    switch( XAAIsEasyPolygon(ptsIn, count, &pGC->pCompositeClip->extents, 

+		origin, &topPoint, &y, &maxy, shape) ) {

+    case POLY_USE_MI: 

+	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);

+    case POLY_FULLY_CLIPPED: 

+	return;

+    }

+

+    endp = (int*)ptsIn + count;

+    vertex2p = vertex1p = (int *)topPoint;

+    origin = pDraw->x;

+    yoffset = pDraw->y;

+    vertex2 = vertex1 = *vertex2p++;

+    if (vertex2p == endp)

+	vertex2p = (int *) ptsIn;

+

+    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,

+        pGC->planemask);

+

+    while(1) {

+	if (y == intToY(vertex1)) {

+	    do {

+	    	if (vertex1p == (int *) ptsIn)

+		    vertex1p = endp;

+	    	c = *--vertex1p;

+	    	Setup (c,x1,vertex1,dx1,dy1,e1,sign1,step1,DX1)

+	    } while (y >= intToY(vertex1));

+	    h = dy1;

+	} else {

+	    Step(x1,dx1,dy1,e1,sign1,step1)

+	    h = intToY(vertex1) - y;

+	}

+	if (y == intToY(vertex2)) {

+	    do {

+	    	c = *vertex2p++;

+	    	if (vertex2p == endp)

+		    vertex2p = (int *) ptsIn;

+	    	Setup (c,x2,vertex2,dx2,dy2,e2,sign2,step2,DX2)

+	    } while (y >= intToY(vertex2));

+	    if (dy2 < h)

+		h = dy2;

+	} else {

+	    Step(x2,dx2,dy2,e2,sign2,step2)

+	    if ((c = (intToY(vertex2) - y)) < h)

+		h = c;

+	}

+

+	/* fill spans for this segment */

+        if(DX1 | DX2) {

+      	  if(infoRec->SubsequentSolidFillTrap && (h > 6)) {

+	     if(x1 == x2) {

+		while(x1 == x2) {

+	     	   y++;

+	    	   if (!--h) break;

+	    	   Step(x1,dx1,dy1,e1,sign1,step1)

+	    	   Step(x2,dx2,dy2,e2,sign2,step2)

+		}

+		if(y == maxy) break;

+    		if(!h) continue;

+	     }

+

+             if(x1 < x2)

+ 	     	(*infoRec->SubsequentSolidFillTrap)(infoRec->pScrn,

+					y + yoffset, h,

+					x1, DX1, dy1, e1, 

+					x2 - 1, DX2, dy2, e2);

+	     else

+ 	     	(*infoRec->SubsequentSolidFillTrap)(infoRec->pScrn,

+					y + yoffset, h,

+					x2, DX2, dy2, e2, 

+					x1 - 1, DX1, dy1, e1);

+	     y += h;	

+             if(--h) {

+	     	FixError(x1,dx1,dy1,e1,sign1,step1,h);

+	     	FixError(x2,dx2,dy2,e2,sign2,step2,h);

+		h = 0;

+	     }  	

+	  } else {

+	     while(1) {

+	    	if (x2 > x1)

+	            (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,

+	            		x1, y + yoffset, x2 - x1, 1);

+	        else if (x1 > x2)

+	            (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,

+	                    x2, y + yoffset, x1 - x2, 1);

+	     	y++;

+	    	if (!--h) break;

+	    	Step(x1,dx1,dy1,e1,sign1,step1)

+	    	Step(x2,dx2,dy2,e2,sign2,step2)

+	     }

+	  }

+	} else {

+	    if (x2 > x1)

+	        (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,

+	            x1, y + yoffset, x2 - x1, h);

+	    else if (x1 > x2)

+	        (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,

+	                x2, y + yoffset, x1 - x2, h);

+

+	    y += h;

+	    h = 0;

+        } 

+	if (y == maxy) break;

+    }

+    SET_SYNC_FLAG(infoRec);

+}

+

+

+

+

+void

+XAAFillPolygonHelper(

+    ScrnInfoPtr pScrn,

+    DDXPointPtr	ptsIn,

+    int 	count,

+    DDXPointPtr topPoint,

+    int 	y,

+    int		maxy,

+    int		origin,

+    RectFuncPtr RectFunc,

+    TrapFuncPtr TrapFunc,

+    int 	xorg,

+    int		yorg,

+    XAACacheInfoPtr pCache

+){

+    int		    *vertex1p, *vertex2p, *endp;

+    int		    vertex1, vertex2;

+    int		    x1 = 0, x2 = 0;

+    int		    dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;

+    int		    DX1 = 0, DX2 = 0, e1 = 0, e2 = 0;

+    int		    step1 = 0, step2 = 0, sign1 = 0, sign2 = 0;

+    int		    c, h, yoffset;

+

+

+    endp = (int*)ptsIn + count;

+    vertex2p = vertex1p = (int *)topPoint;

+    yoffset = intToY(origin);

+    origin = intToX(origin);

+    vertex2 = vertex1 = *vertex2p++;

+    if (vertex2p == endp)

+	vertex2p = (int *)ptsIn;

+

+    while(1) {

+	if (y == intToY(vertex1)) {

+	    do {

+	    	if (vertex1p == (int *) ptsIn)

+		    vertex1p = endp;

+	    	c = *--vertex1p;

+	    	Setup (c,x1,vertex1,dx1,dy1,e1,sign1,step1,DX1)

+	    } while (y >= intToY(vertex1));

+	    h = dy1;

+	} else {

+	    Step(x1,dx1,dy1,e1,sign1,step1)

+	    h = intToY(vertex1) - y;

+	}

+	if (y == intToY(vertex2)) {

+	    do {

+	    	c = *vertex2p++;

+	    	if (vertex2p == endp)

+		    vertex2p = (int *) ptsIn;

+	    	Setup (c,x2,vertex2,dx2,dy2,e2,sign2,step2,DX2)

+	    } while (y >= intToY(vertex2));

+	    if (dy2 < h)

+		h = dy2;

+	} else {

+	    Step(x2,dx2,dy2,e2,sign2,step2)

+	    if ((c = (intToY(vertex2) - y)) < h)

+		h = c;

+	}

+

+	/* fill spans for this segment */

+        if(DX1 | DX2) {

+      	  if(TrapFunc && (h > 6)) {

+	     if(x1 == x2) {

+		while(x1 == x2) {

+	     	   y++;

+	    	   if (!--h) break;

+	    	   Step(x1,dx1,dy1,e1,sign1,step1)

+	    	   Step(x2,dx2,dy2,e2,sign2,step2)

+		}

+		if(y == maxy) break;

+    		if(!h) continue;

+	     }

+

+             if(x1 < x2)

+ 	     	(*TrapFunc)(pScrn, y + yoffset, h,

+				x1, DX1, dy1, e1, 

+				x2 - 1, DX2, dy2, e2, xorg, yorg, pCache);

+	     else

+ 	     	(*TrapFunc)(pScrn, y + yoffset, h,

+				x2, DX2, dy2, e2, 

+				x1 - 1, DX1, dy1, e1, xorg, yorg, pCache);

+	     y += h;	

+             if(--h) {

+	     	FixError(x1,dx1,dy1,e1,sign1,step1,h);

+	     	FixError(x2,dx2,dy2,e2,sign2,step2,h);

+		h = 0;

+	     }  	

+	  } else {

+	     while(1) {

+	    	if (x2 > x1)

+	            (*RectFunc)(pScrn,

+	            	x1, y + yoffset, x2 - x1, 1, xorg, yorg, pCache);

+	        else if (x1 > x2)

+	            (*RectFunc)(pScrn,

+	                    x2, y + yoffset, x1 - x2, 1, xorg, yorg, pCache);

+	     	y++;

+	    	if (!--h) break;

+	    	Step(x1,dx1,dy1,e1,sign1,step1)

+	    	Step(x2,dx2,dy2,e2,sign2,step2)

+	     }

+	  }

+	} else {

+	    if (x2 > x1)

+	        (*RectFunc)(pScrn,

+	            x1, y + yoffset, x2 - x1, h, xorg, yorg, pCache);

+	    else if (x1 > x2)

+	        (*RectFunc)(pScrn,

+	                x2, y + yoffset, x1 - x2, h, xorg, yorg, pCache);

+

+	    y += h;

+	    h = 0;

+        } 

+	if (y == maxy) break;

+    }

+}

+

+        /*****************\

+	|  Solid Helpers  |

+	\*****************/

+

+static void

+SolidTrapHelper(

+   ScrnInfoPtr pScrn,

+   int y, int h,

+   int x1, int dx1, int dy1, int e1,

+   int x2, int dx2, int dy2, int e2,

+   int xorg, int yorg,

+   XAACacheInfoPtr pCache

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+

+    (*infoRec->SubsequentSolidFillTrap) (pScrn, 

+		y, h, x1, dx1, dy1, e1, x2, dx2, dy2, e2);

+}

+

+static void

+SolidRectHelper (

+   ScrnInfoPtr pScrn,

+   int x, int y, int w, int h,

+   int xorg, int yorg,   

+   XAACacheInfoPtr pCache

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+

+    (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);

+}

+

+

+	/*********************\

+	|  Mono 8x8 Patterns  |

+	\*********************/

+

+static void

+Mono8x8PatternTrapHelper_ScreenOrigin(

+   ScrnInfoPtr pScrn,

+   int y, int h,

+   int x1, int dx1, int dy1, int e1,

+   int x2, int dx2, int dy2, int e2,

+   int xorg, int yorg,

+   XAACacheInfoPtr pCache

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+

+    (*infoRec->SubsequentMono8x8PatternFillTrap) (pScrn, xorg, yorg,

+		y, h, x1, dx1, dy1, e1, x2, dx2, dy2, e2);

+}

+

+static void

+Mono8x8PatternRectHelper_ScreenOrigin (

+   ScrnInfoPtr pScrn,

+   int x, int y, int w, int h,

+   int xorg, int yorg,   

+   XAACacheInfoPtr pCache

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+

+    (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn, xorg, yorg,

+						x, y, w, h);

+}

+

+static void

+Mono8x8PatternRectHelper (

+   ScrnInfoPtr pScrn,

+   int x, int y, int w, int h,

+   int xorg, int yorg,   

+   XAACacheInfoPtr pCache

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+

+    xorg = (x - xorg) & 0x07;

+    yorg = (y - yorg) & 0x07;

+

+    if(!(infoRec->Mono8x8PatternFillFlags & 		

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	if(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_PROGRAMMED_BITS) {

+		int patx = pCache->pat0; 

+		int paty = pCache->pat1;

+		XAARotateMonoPattern(&patx, &paty, xorg, yorg,

+				(infoRec->Mono8x8PatternFillFlags & 		

+				BIT_ORDER_IN_BYTE_MSBFIRST));

+		xorg = patx; yorg = paty;

+	} else {

+		int slot = (yorg << 3) + xorg;

+	    	xorg = pCache->x + pCache->offsets[slot].x;

+	    	yorg = pCache->y + pCache->offsets[slot].y;

+	}

+     }

+

+

+    (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn, xorg, yorg,

+						x, y, w, h);

+}

+

+

+

+	/****************\

+	|  Cache Expand  |

+	\****************/

+

+

+static void

+CacheExpandRectHelper (

+   ScrnInfoPtr pScrn,

+   int X, int Y, int Width, int Height,

+   int xorg, int yorg,   

+   XAACacheInfoPtr pCache

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int x, phaseY, phaseX, skipleft, w, blit_w, blit_h;

+    int cacheWidth;

+

+    cacheWidth = (pCache->w * pScrn->bitsPerPixel) / 

+	infoRec->CacheColorExpandDensity;

+

+    phaseY = (Y - yorg) % pCache->orig_h;

+    if(phaseY < 0) phaseY += pCache->orig_h;

+    phaseX = (X - xorg) % pCache->orig_w;

+    if(phaseX < 0) phaseX += pCache->orig_w;

+	

+    while(1) {

+	w = Width; skipleft = phaseX; x = X;

+	blit_h = pCache->h - phaseY;

+	if(blit_h > Height) blit_h = Height;

+	

+	while(1) {

+		blit_w = cacheWidth - skipleft;

+		if(blit_w > w) blit_w = w;

+		(*infoRec->SubsequentScreenToScreenColorExpandFill)(

+			pScrn, x, Y, blit_w, blit_h,

+			pCache->x, pCache->y + phaseY, skipleft);

+		w -= blit_w;

+		if(!w) break;

+		x += blit_w;

+		skipleft = (skipleft + blit_w) % pCache->orig_w;

+	}

+	Height -= blit_h;

+	if(!Height) break;

+	Y += blit_h;

+	phaseY = (phaseY + blit_h) % pCache->orig_h;

+    }

+}

+

+

+

+	/**************\

+	|  Cache Blit  |

+	\**************/

+

+

+static void

+CacheBltRectHelper (

+   ScrnInfoPtr pScrn,

+   int X, int Y, int Width, int Height,

+   int xorg, int yorg,   

+   XAACacheInfoPtr pCache

+){

+     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+     int x, phaseY, phaseX, skipleft, w, blit_w, blit_h;

+

+     phaseY = (Y - yorg) % pCache->orig_h;

+     if(phaseY < 0) phaseY += pCache->orig_h;

+     phaseX = (X - xorg) % pCache->orig_w;

+     if(phaseX < 0) phaseX += pCache->orig_w;

+

+     while(1) {

+	w = Width; skipleft = phaseX; x = X;

+	blit_h = pCache->h - phaseY;

+	if(blit_h > Height) blit_h = Height;

+	

+	while(1) {

+	    blit_w = pCache->w - skipleft;

+	    if(blit_w > w) blit_w = w;

+	    (*infoRec->SubsequentScreenToScreenCopy)(pScrn,

+			pCache->x + skipleft, pCache->y + phaseY,

+			x, Y, blit_w, blit_h);

+	    w -= blit_w;

+	    if(!w) break;

+	    x += blit_w;

+	    skipleft = (skipleft + blit_w) % pCache->orig_w;

+	}

+	Height -= blit_h;

+	if(!Height) break;

+	Y += blit_h;

+	phaseY = (phaseY + blit_h) % pCache->orig_h;

+     }	

+}

+

+

+	/**********************\

+	|   Stippled Polygons  |

+	\**********************/

+

+

+void

+XAAFillPolygonStippled(

+    DrawablePtr	pDraw,

+    GCPtr	pGC,

+    int		shape,

+    int		mode,

+    int		count,

+    DDXPointPtr	ptsIn 

+){

+    XAAInfoRecPtr   infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    XAAPixmapPtr    pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);

+    int    	    origin, type, patx, paty, fg, bg;

+    int		    y, maxy, xorg, yorg;

+    DDXPointPtr	    topPoint;

+    XAACacheInfoPtr pCache = NULL;

+    RectFuncPtr	    RectFunc = NULL;

+    TrapFuncPtr	    TrapFunc = NULL;

+

+    if(!RegionNumRects(pGC->pCompositeClip))

+	return;

+

+    if (mode == CoordModePrevious) {

+	register DDXPointPtr ppt = ptsIn + 1;

+

+	for (origin = 1; origin < count; origin++, ppt++) {

+	    ppt->x += (ppt-1)->x;

+	    ppt->y += (ppt-1)->y;

+	}

+        mode = CoordModeOrigin;

+    }

+    

+    if (RegionNumRects(pGC->pCompositeClip) != 1) {

+	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);

+	return;

+    }

+

+

+    if(pGC->fillStyle == FillStippled) {

+    	type = (*infoRec->StippledFillChooser)(pGC);

+	fg = pGC->fgPixel;  bg = -1;

+    } else {

+    	type = (*infoRec->OpaqueStippledFillChooser)(pGC);

+	fg = pGC->fgPixel;  bg = pGC->bgPixel;

+    }

+

+

+    if(!type) {

+	(*XAAFallbackOps.FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn);

+	return;

+    }

+	

+    if((type == DO_COLOR_EXPAND) || (type == DO_COLOR_8x8)) {

+	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);

+	return;

+    }

+

+    origin = pDraw->x;

+

+    switch( XAAIsEasyPolygon(ptsIn, count, &pGC->pCompositeClip->extents,

+		 origin, &topPoint, &y, &maxy, shape) ) {

+    case POLY_USE_MI: 

+	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);

+    case POLY_FULLY_CLIPPED: 

+	return;

+    }

+

+    xorg = (pDraw->x + pGC->patOrg.x);

+    yorg = (pDraw->y + pGC->patOrg.y);

+

+

+    if((fg == bg) && (bg != -1) && infoRec->SetupForSolidFill) {

+

+	(*infoRec->SetupForSolidFill)(infoRec->pScrn, fg,

+				pGC->alu, pGC->planemask);

+

+	RectFunc = SolidRectHelper;

+        TrapFunc = infoRec->SubsequentSolidFillTrap ? SolidTrapHelper : NULL;

+    } else

+    switch(type) {

+	case DO_MONO_8x8:

+	    patx = pPriv->pattern0; paty = pPriv->pattern1;

+	    if(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_SCREEN_ORIGIN) {

+		xorg = (-xorg) & 0x07; yorg = (-yorg) & 0x07;

+		if(infoRec->Mono8x8PatternFillFlags & 

+					HARDWARE_PATTERN_PROGRAMMED_BITS) {

+		    if(!(infoRec->Mono8x8PatternFillFlags & 		

+					HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {

+		        XAARotateMonoPattern(&patx, &paty, xorg, yorg,

+				(infoRec->Mono8x8PatternFillFlags & 		

+				BIT_ORDER_IN_BYTE_MSBFIRST));

+		        xorg = patx; yorg = paty;

+		    }

+	        } else {

+		    XAACacheInfoPtr pCache = (*infoRec->CacheMono8x8Pattern)(

+					infoRec->pScrn, patx, paty);

+		    patx = pCache->x;  paty = pCache->y;

+		    if(!(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+			int slot = (yorg << 3) + xorg;

+			patx += pCache->offsets[slot].x;

+			paty += pCache->offsets[slot].y;

+			xorg = patx;  yorg = paty;

+		    }

+	        }	

+		RectFunc = Mono8x8PatternRectHelper_ScreenOrigin;

+		if(infoRec->SubsequentMono8x8PatternFillTrap)

+		    TrapFunc = Mono8x8PatternTrapHelper_ScreenOrigin;

+	    } else {  /* !HARDWARE_PATTERN_SCREEN_ORIGIN */

+		if(!(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_PROGRAMMED_BITS)){

+		    pCache = (*infoRec->CacheMono8x8Pattern)(

+					infoRec->pScrn, patx, paty);

+		    patx = pCache->x;  paty = pCache->y;

+	    	} else {

+                    pCache = &(infoRec->ScratchCacheInfoRec);

+                    pCache->pat0 = patx;

+                    pCache->pat1 = paty;

+                }

+		RectFunc = Mono8x8PatternRectHelper;

+       	    }

+

+	    (*infoRec->SetupForMono8x8PatternFill)(infoRec->pScrn, 

+				patx, paty, fg, bg, pGC->alu, pGC->planemask);

+	    break;

+	case DO_CACHE_EXPAND:

+	    pCache = (*infoRec->CacheMonoStipple)(infoRec->pScrn, pGC->stipple);

+

+	    (*infoRec->SetupForScreenToScreenColorExpandFill)(

+		infoRec->pScrn, fg, bg, pGC->alu, pGC->planemask);

+

+	    RectFunc = CacheExpandRectHelper;

+	    break;

+	case DO_CACHE_BLT:

+	    pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 

+							fg, bg);

+	    (*infoRec->SetupForScreenToScreenCopy)(infoRec->pScrn, 1, 1, 

+		pGC->alu, pGC->planemask, pCache->trans_color);

+

+	    RectFunc = CacheBltRectHelper;

+	    break;

+	default:

+	    return;

+    }

+        

+

+    XAAFillPolygonHelper(infoRec->pScrn, ptsIn, count, topPoint, 

+		y, maxy, origin, RectFunc, TrapFunc, xorg, yorg, pCache);

+

+    SET_SYNC_FLAG(infoRec);	

+}

+

+

+

+

+	/*******************\

+	|   Tiled Polygons  |

+	\*******************/

+

+

+void

+XAAFillPolygonTiled(

+    DrawablePtr	pDraw,

+    GCPtr	pGC,

+    int		shape,

+    int		mode,

+    int		count,

+    DDXPointPtr	ptsIn 

+){

+    XAAInfoRecPtr   infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    XAAPixmapPtr    pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);

+    int    	    origin, type, patx, paty;

+    int		    y, maxy, xorg, yorg;

+    DDXPointPtr	    topPoint;

+    XAACacheInfoPtr pCache = NULL;

+    RectFuncPtr	    RectFunc = NULL;

+    TrapFuncPtr	    TrapFunc = NULL;

+

+    if(!RegionNumRects(pGC->pCompositeClip))

+	return;

+

+    if (mode == CoordModePrevious) {

+	register DDXPointPtr ppt = ptsIn + 1;

+

+	for (origin = 1; origin < count; origin++, ppt++) {

+	    ppt->x += (ppt-1)->x;

+	    ppt->y += (ppt-1)->y;

+	}

+        mode = CoordModeOrigin;

+    }

+    

+    if (RegionNumRects(pGC->pCompositeClip) != 1) {

+	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);

+	return;

+    }

+

+

+    type = (*infoRec->TiledFillChooser)(pGC);

+

+    if(!type || (type == DO_IMAGE_WRITE)) {

+	(*XAAFallbackOps.FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn);

+	return;

+    }

+	

+    if(type == DO_COLOR_8x8) {

+	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);

+	return;

+    }

+

+    origin = pDraw->x;

+

+    switch( XAAIsEasyPolygon(ptsIn, count, &pGC->pCompositeClip->extents,

+		 origin, &topPoint, &y, &maxy, shape) ) {

+    case POLY_USE_MI: 

+	miFillPolygon (pDraw, pGC, shape, mode, count, ptsIn);

+    case POLY_FULLY_CLIPPED: 

+	return;

+    }

+

+    xorg = (pDraw->x + pGC->patOrg.x);

+    yorg = (pDraw->y + pGC->patOrg.y);

+

+    switch(type) {

+	case DO_MONO_8x8:

+	    patx = pPriv->pattern0; paty = pPriv->pattern1;

+	    if(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_SCREEN_ORIGIN) {

+		xorg = (-xorg) & 0x07; yorg = (-yorg) & 0x07;

+		if(infoRec->Mono8x8PatternFillFlags & 

+					HARDWARE_PATTERN_PROGRAMMED_BITS) {

+		    if(!(infoRec->Mono8x8PatternFillFlags & 		

+					HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {

+		        XAARotateMonoPattern(&patx, &paty, xorg, yorg,

+				(infoRec->Mono8x8PatternFillFlags & 		

+				BIT_ORDER_IN_BYTE_MSBFIRST));

+		        xorg = patx; yorg = paty;

+		    }

+	        } else {

+		    XAACacheInfoPtr pCache = (*infoRec->CacheMono8x8Pattern)(

+					infoRec->pScrn, patx, paty);

+		    patx = pCache->x;  paty = pCache->y;

+		    if(!(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+			int slot = (yorg << 3) + xorg;

+			patx += pCache->offsets[slot].x;

+			paty += pCache->offsets[slot].y;

+			xorg = patx;  yorg = paty;

+		    }

+	        }	

+		RectFunc = Mono8x8PatternRectHelper_ScreenOrigin;

+		if(infoRec->SubsequentMono8x8PatternFillTrap)

+		    TrapFunc = Mono8x8PatternTrapHelper_ScreenOrigin;

+	    } else {  /* !HARDWARE_PATTERN_SCREEN_ORIGIN */

+		if(!(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_PROGRAMMED_BITS)){

+		    pCache = (*infoRec->CacheMono8x8Pattern)(

+					infoRec->pScrn, patx, paty);

+		    patx = pCache->x;  paty = pCache->y;

+	    	}

+		else {

+		  pCache = &(infoRec->ScratchCacheInfoRec);

+		  pCache->pat0 = patx;

+		  pCache->pat1 = paty;

+		}

+		RectFunc = Mono8x8PatternRectHelper;

+       	    }

+

+	    (*infoRec->SetupForMono8x8PatternFill)(infoRec->pScrn, 

+		 patx, paty, pPriv->fg, pPriv->bg, pGC->alu, pGC->planemask);

+	    break;

+	case DO_CACHE_BLT:

+            pCache = (*infoRec->CacheTile)(infoRec->pScrn, pGC->tile.pixmap);

+	    (*infoRec->SetupForScreenToScreenCopy)(infoRec->pScrn, 1, 1, 

+		pGC->alu, pGC->planemask, -1);

+

+	    RectFunc = CacheBltRectHelper;

+	    break;

+	case DO_PIXMAP_COPY:

+	    pCache = &(infoRec->ScratchCacheInfoRec);

+	    pCache->x = pPriv->offscreenArea->box.x1;

+	    pCache->y = pPriv->offscreenArea->box.y1;

+	    pCache->w = pCache->orig_w = 

+		pPriv->offscreenArea->box.x2 - pCache->x;

+	    pCache->h = pCache->orig_h = 

+		pPriv->offscreenArea->box.y2 - pCache->y;

+

+	    (*infoRec->SetupForScreenToScreenCopy)(infoRec->pScrn, 1, 1, 

+		pGC->alu, pGC->planemask, -1);

+

+	    RectFunc = CacheBltRectHelper;

+	    break;

+	default:

+	    return;

+    }

+

+    XAAFillPolygonHelper(infoRec->pScrn, ptsIn, count, topPoint, 

+		y, maxy, origin, RectFunc, TrapFunc, xorg, yorg, pCache);

+

+    SET_SYNC_FLAG(infoRec);	

+}

+

+

diff --git a/xorg-server/hw/xfree86/xaa/xaaFillRect.c b/xorg-server/hw/xfree86/xaa/xaaFillRect.c
index 0b83ef3ee..724ff37a2 100644
--- a/xorg-server/hw/xfree86/xaa/xaaFillRect.c
+++ b/xorg-server/hw/xfree86/xaa/xaaFillRect.c
@@ -1,1095 +1,1095 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-
-static void XAARenderSolidRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderColor8x8Rects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderMono8x8Rects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderColorExpandRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderCacheExpandRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderCacheBltRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderImageWriteRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderPixmapCopyRects(GCPtr, int, BoxPtr, int, int);
-
-void
-XAAPolyFillRect(
-    DrawablePtr pDraw,
-    GCPtr pGC,
-    int		nrectFill, 	/* number of rectangles to fill */
-    xRectangle	*prectInit   	/* Pointer to first rectangle to fill */
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int		xorg = pDraw->x;
-    int		yorg = pDraw->y;
-    int		type = 0;
-    ClipAndRenderRectsFunc function;
-
-    if((nrectFill <= 0) || !pGC->planemask)
-        return;
-
-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))
-	return;
-
-    switch(pGC->fillStyle) {
-    case FillSolid:
-	type = DO_SOLID;
-	break;
-    case FillStippled:
-	type = (*infoRec->StippledFillChooser)(pGC);
-	break;
-    case FillOpaqueStippled:
-	if((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSolidRects &&
-                CHECK_PLANEMASK(pGC,infoRec->FillSolidRectsFlags) &&
-                CHECK_ROP(pGC,infoRec->FillSolidRectsFlags) &&
-                CHECK_ROPSRC(pGC,infoRec->FillSolidRectsFlags) &&
-                CHECK_FG(pGC,infoRec->FillSolidRectsFlags))
-	    type = DO_SOLID;
-	else
-	    type = (*infoRec->OpaqueStippledFillChooser)(pGC);
-	break;
-    case FillTiled:
-	type = (*infoRec->TiledFillChooser)(pGC);
-	break;
-    }
-
-    switch(type) {
-    case DO_SOLID:
-	function = XAARenderSolidRects;	
-	break;	
-    case DO_COLOR_8x8:
-	function = XAARenderColor8x8Rects;	
-	break;	
-    case DO_MONO_8x8:
-	function = XAARenderMono8x8Rects;	
-	break;	
-    case DO_CACHE_BLT:
-	function = XAARenderCacheBltRects;	
-	break;	
-    case DO_COLOR_EXPAND:
-	function = XAARenderColorExpandRects;	
-	break;	
-    case DO_CACHE_EXPAND:
-	function = XAARenderCacheExpandRects;	
-	break;	
-    case DO_IMAGE_WRITE:
-	function = XAARenderImageWriteRects;	
-	break;	
-    case DO_PIXMAP_COPY:
-	function = XAARenderPixmapCopyRects;	
-	break;	
-    default:
-	(*XAAFallbackOps.PolyFillRect)(pDraw, pGC, nrectFill, prectInit);
-	return;
-    }
-
-    if(xorg | yorg) {
-	int n = nrectFill;
-	xRectangle *prect = prectInit;
-
-	while(n--) {
-	    prect->x += xorg;
-	    prect->y += yorg;
-	    prect++;
-	}
-    }
-
-    
-    XAAClipAndRenderRects(pGC, function, nrectFill, prectInit, xorg, yorg);
-}
-
-
-
-	/*********************\
-	|     Solid Rects     |
-	\*********************/
-
-static void
-XAARenderSolidRects(
-   GCPtr pGC,
-   int nboxes,
-   BoxPtr pClipBoxes,
-   int xorg, int yorg
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-   (*infoRec->FillSolidRects) (infoRec->pScrn, 
-               pGC->fgPixel, pGC->alu, pGC->planemask, nboxes, pClipBoxes);
-}
-
-
-	/************************\
-	|     Mono 8x8 Rects     |
-	\************************/
-
-static void
-XAARenderMono8x8Rects(
-   GCPtr pGC,
-   int nboxes,
-   BoxPtr pClipBoxes,
-   int xorg, int yorg
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAAPixmapPtr pPriv;
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   case FillTiled:
-      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-      fg = pPriv->fg;  bg = pPriv->bg;
-      break;
-   default:	/* Muffle compiler */
-      pPriv = NULL;	/* Kaboom */
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   (*infoRec->FillMono8x8PatternRects) (infoRec->pScrn, 
-                fg, bg, pGC->alu, pGC->planemask, 
-                nboxes, pClipBoxes, pPriv->pattern0, pPriv->pattern1, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));
-}
-
-	/*************************\
-	|     Color 8x8 Rects     |
-	\*************************/
-
-static void
-XAARenderColor8x8Rects(
-   GCPtr pGC,
-   int nboxes,
-   BoxPtr pClipBoxes,
-   int xorg, int yorg
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAACacheInfoPtr pCache;
-   PixmapPtr pPix;
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      pPix = pGC->stipple;
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      pPix = pGC->stipple;
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   case FillTiled:
-      pPix = pGC->tile.pixmap;
-      fg = -1;  bg = -1;
-      break;
-   default:	/* Muffle compiler */
-      pPix = NULL;
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   pCache = (*infoRec->CacheColor8x8Pattern)(infoRec->pScrn, pPix, fg, bg);
-   (*infoRec->FillColor8x8PatternRects) (infoRec->pScrn,
-                pGC->alu, pGC->planemask, nboxes, pClipBoxes, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y), pCache);
-}
-
-
-	/****************************\
-	|     Color Expand Rects     |
-	\****************************/
-
-static void
-XAARenderColorExpandRects(
-   GCPtr pGC,
-   int nboxes,
-   BoxPtr pClipBoxes,
-   int xorg, int yorg
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   default:	/* Muffle compiler */
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   (*infoRec->FillColorExpandRects) (infoRec->pScrn, fg, bg, 
-                pGC->alu, pGC->planemask, nboxes, pClipBoxes, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),
-		pGC->stipple);
-}
-
-
-	/*************************\
-	|     Cache Blt Rects     |
-	\*************************/
-
-static void
-XAARenderCacheBltRects(
-   GCPtr pGC,
-   int nboxes,
-   BoxPtr pClipBoxes,
-   int xorg, int yorg
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAACacheInfoPtr pCache;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 
-					pGC->fgPixel, -1);
-      break;
-   case FillOpaqueStippled:
-      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 
-					pGC->fgPixel, pGC->bgPixel);
-      break;
-   case FillTiled:
-      pCache = (*infoRec->CacheTile)(infoRec->pScrn, pGC->tile.pixmap);
-      break;
-   default:	/* Muffle compiler */
-      pCache = NULL;
-      break;
-   }
-
-   (*infoRec->FillCacheBltRects) (infoRec->pScrn, pGC->alu, 
-                pGC->planemask, nboxes, pClipBoxes, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y), pCache);
-}
-
-
-	/****************************\
-	|     Cache Expand Rects     |
-	\****************************/
-
-static void
-XAARenderCacheExpandRects(
-   GCPtr pGC,
-   int nboxes,
-   BoxPtr pClipBoxes,
-   int xorg, int yorg
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   default:	/* Muffle compiler */
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   (*infoRec->FillCacheExpandRects) (infoRec->pScrn, fg, bg,
-                pGC->alu, pGC->planemask, nboxes, pClipBoxes, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y), 
-                pGC->stipple);
-}
-
-
-
-	/***************************\
-	|     Image Write Rects     |
-	\***************************/
-
-static void
-XAARenderImageWriteRects(
-   GCPtr pGC,
-   int nboxes,
-   BoxPtr pClipBoxes,
-   int xorg, int yorg
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-   (*infoRec->FillImageWriteRects) (infoRec->pScrn, pGC->alu, 
-                pGC->planemask, nboxes, pClipBoxes, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),
-                pGC->tile.pixmap);
-}
-
-
-
-	/***************************\
-	|     Pixmap Copy Rects     |
-	\***************************/
-
-static void
-XAARenderPixmapCopyRects(
-   GCPtr pGC,
-   int nboxes,
-   BoxPtr pClipBoxes,
-   int xorg, int yorg
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);
-   XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-
-   pCache->x = pPriv->offscreenArea->box.x1;
-   pCache->y = pPriv->offscreenArea->box.y1;
-   pCache->w = pCache->orig_w = 
-		pPriv->offscreenArea->box.x2 - pCache->x;
-   pCache->h = pCache->orig_h = 
-		pPriv->offscreenArea->box.y2 - pCache->y;
-   pCache->trans_color = -1;
-
-   (*infoRec->FillCacheBltRects) (infoRec->pScrn, pGC->alu, 
-                pGC->planemask, nboxes, pClipBoxes, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y), 
-                pCache);
-}
-
-
-
-	/************\
-	|   Solid    |
-	\************/
-
-void
-XAAFillSolidRects(
-    ScrnInfoPtr pScrn,
-    int	fg, int rop,
-    unsigned int planemask,
-    int		nBox, 		/* number of rectangles to fill */
-    BoxPtr	pBox  		/* Pointer to first rectangle to fill */
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SetupForSolidFill)(pScrn, fg, rop, planemask);
-     while(nBox--) {
-        (*infoRec->SubsequentSolidFillRect)(pScrn, pBox->x1, pBox->y1,
- 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);
-	pBox++;
-     }
-     SET_SYNC_FLAG(infoRec);
-}
-
-
-
-
-	/*********************\
-	|  8x8 Mono Patterns  |
-	\*********************/
-
-
-void
-XAAFillMono8x8PatternRectsScreenOrigin(
-    ScrnInfoPtr pScrn,
-    int	fg, int bg, int rop,
-    unsigned int planemask,
-    int	nBox,
-    BoxPtr pBox,
-    int pattern0, int pattern1,
-    int xorigin, int yorigin
-)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-
-    if(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {
-   	if(!(infoRec->Mono8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-				(infoRec->Mono8x8PatternFillFlags &
-				 BIT_ORDER_IN_BYTE_MSBFIRST));
-	    xorg = patx; yorg = paty;
-        }
-    } else {
-	XAACacheInfoPtr pCache =
-		(*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);
-	patx = pCache->x;  paty = pCache->y;
-   	if(!(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    int slot = (yorg << 3) + xorg;
-	    patx += pCache->offsets[slot].x;
-	    paty += pCache->offsets[slot].y;
-	    xorg = patx;  yorg = paty;
-	}	
-    }
-
-    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,
-					fg, bg, rop, planemask);
-
-     while(nBox--) {
-        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 
-			xorg, yorg, pBox->x1, pBox->y1,
- 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);
-	pBox++;
-     }
-     SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAFillMono8x8PatternRects(
-    ScrnInfoPtr pScrn,
-    int	fg, int bg, int rop,
-    unsigned int planemask,
-    int	nBox,
-    BoxPtr pBox,
-    int pattern0, int pattern1,
-    int xorigin, int yorigin
-)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg, yorg;
-    XAACacheInfoPtr pCache = NULL;
-
-
-    if(!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)){
-	pCache = (*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);
-	patx = pCache->x;  paty = pCache->y;
-    }
-
-
-    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,
-					fg, bg, rop, planemask);
-
-
-     while(nBox--) {
-	xorg = (pBox->x1 - xorigin) & 0x07;
-	yorg = (pBox->y1 - yorigin) & 0x07;
-
-   	if(!(infoRec->Mono8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    if(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_BITS) {
-		patx = pattern0; paty = pattern1;
-		XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-				(infoRec->Mono8x8PatternFillFlags & 		
-				BIT_ORDER_IN_BYTE_MSBFIRST));
-		xorg = patx; yorg = paty;
-	    } else {
-		int slot = (yorg << 3) + xorg;
-	    	xorg = patx + pCache->offsets[slot].x;
-	    	yorg = paty + pCache->offsets[slot].y;
-	    }
-        }
-
-        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 
-			xorg, yorg, pBox->x1, pBox->y1,
- 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);
-	pBox++;
-     }
-
-     SET_SYNC_FLAG(infoRec);
-}
-
-
-	/**********************\
-	|  8x8 Color Patterns  |
-	\**********************/
-
-
-void
-XAAFillColor8x8PatternRectsScreenOrigin(
-   ScrnInfoPtr pScrn,
-   int rop,
-   unsigned int planemask,
-   int nBox,
-   BoxPtr pBox,
-   int xorigin, int yorigin,
-   XAACacheInfoPtr pCache
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pCache->x, paty = pCache->y;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-    if(!(infoRec->Color8x8PatternFillFlags & 
-					HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	int slot = (yorg << 3) + xorg;
-	paty += pCache->offsets[slot].y;
-	patx += pCache->offsets[slot].x;
-	xorg = patx;  yorg = paty;
-    }	
-
-    (*infoRec->SetupForColor8x8PatternFill)(pScrn, patx, paty,
-			 rop, planemask, pCache->trans_color);
-
-    while(nBox--) {
-        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 
-			xorg, yorg, pBox->x1, pBox->y1,
- 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);
-	pBox++;
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAFillColor8x8PatternRects(
-   ScrnInfoPtr pScrn,
-   int rop,
-   unsigned int planemask,
-   int nBox,
-   BoxPtr pBox,
-   int xorigin, int yorigin,
-   XAACacheInfoPtr pCache
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int xorg, yorg;
-
-    (*infoRec->SetupForColor8x8PatternFill)(pScrn, pCache->x, pCache->y,
-			 rop, planemask, pCache->trans_color);
-
-     while(nBox--) {
-	xorg = (pBox->x1 - xorigin) & 0x07;
-	yorg = (pBox->y1 - yorigin) & 0x07;
-
-   	if(!(infoRec->Color8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    int slot = (yorg << 3) + xorg;
-	    yorg = pCache->y + pCache->offsets[slot].y;
-	    xorg = pCache->x + pCache->offsets[slot].x;
-        }
-
-        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 
-			xorg, yorg, pBox->x1, pBox->y1,
- 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);
-	pBox++;
-     }
-
-     SET_SYNC_FLAG(infoRec);
-}
-
-
-	/***************\
-	|  Cache Blits  |
-	\***************/
-
-void
-XAAFillCacheBltRects(
-   ScrnInfoPtr pScrn,
-   int rop,
-   unsigned int planemask,
-   int nBox,
-   BoxPtr pBox,
-   int xorg, int yorg,
-   XAACacheInfoPtr pCache
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;
-
-    (*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, rop, planemask,
-		pCache->trans_color);
-
-    while(nBox--) {
-	y = pBox->y1;
-	phaseY = (y - yorg) % pCache->orig_h;
-	if(phaseY < 0) phaseY += pCache->orig_h;
-	phaseX = (pBox->x1 - xorg) % pCache->orig_w;
-	if(phaseX < 0) phaseX += pCache->orig_w;
-	height = pBox->y2 - y;
-	width = pBox->x2 - pBox->x1;
-	
-#if 0
-	if (rop == GXcopy) {
-	    while(1) {
-		w = width; skipleft = phaseX; x = pBox->x1;
-		blit_h = pCache->h - phaseY;
-		if(blit_h > height) blit_h = height;
-	
-		while(1) {
-		    blit_w = pCache->w - skipleft;
-		    if(blit_w > w) blit_w = w;
-		    (*infoRec->SubsequentScreenToScreenCopy)(pScrn,
-			pCache->x + skipleft, pCache->y + phaseY,
-			x, y, blit_w, blit_h);
-		    w -= blit_w;
-		    if(!w) break;
-		    x += blit_w;
-		    skipleft = (skipleft + blit_w) % pCache->orig_w;
-		    if(blit_w >= pCache->orig_w) break;
-		}
-
-		/* Expand horizontally */
-		if (w) {
-		    skipleft -= phaseX;
-		    if (skipleft < 0) skipleft += pCache->orig_w;
-		    blit_w = x - pBox->x1 - skipleft;
-		    while(w) {
-			if (blit_w > w) blit_w = w;
-			(*infoRec->SubsequentScreenToScreenCopy)(pScrn,
-			    pBox->x1 + skipleft, y, x, y, blit_w, blit_h);
-			w -= blit_w;
-			x += blit_w;
-			blit_w <<= 1;
-		    }
-		}
-
-		height -= blit_h;
-		if(!height) break;
-		y += blit_h;
-		phaseY = (phaseY + blit_h) % pCache->orig_h;
-		if(blit_h >= pCache->orig_h) break;
-	    }
-
-	    /* Expand vertically */
-	    if (height) {
-		blit_w = pBox->x2 - pBox->x1;
-		phaseY -= (pBox->y1 - yorg) % pCache->orig_h;
-		if (phaseY < 0) phaseY += pCache->orig_h;
-		blit_h = y - pBox->y1  - phaseY;
-		while(height) {
-		    if (blit_h > height) blit_h = height;
-		    (*infoRec->SubsequentScreenToScreenCopy)(pScrn, pBox->x1,
-			pBox->y1 + phaseY, pBox->x1, y, blit_w, blit_h);
-		    height -= blit_h;
-		    y += blit_h;
-		    blit_h <<= 1;
-		}
-	    }
-	} else 
-#endif
-	{
-	    while(1) {
-		w = width; skipleft = phaseX; x = pBox->x1;
-		blit_h = pCache->h - phaseY;
-		if(blit_h > height) blit_h = height;
-	
-		while(1) {
-		    blit_w = pCache->w - skipleft;
-		    if(blit_w > w) blit_w = w;
-		    (*infoRec->SubsequentScreenToScreenCopy)(pScrn,
-			pCache->x + skipleft, pCache->y + phaseY,
-			x, y, blit_w, blit_h);
-		    w -= blit_w;
-		    if(!w) break;
-		    x += blit_w;
-		    skipleft = (skipleft + blit_w) % pCache->orig_w;
-		}
-		height -= blit_h;
-		if(!height) break;
-		y += blit_h;
-		phaseY = (phaseY + blit_h) % pCache->orig_h;
-	    }
-	}
-	pBox++;
-    }
-    
-    SET_SYNC_FLAG(infoRec);
-}
-
-
-
-
-	/*******************\
-	|  Cache Expansion  |
-	\*******************/
-
-
-
-void
-XAAFillCacheExpandRects(
-   ScrnInfoPtr pScrn,
-   int fg, int bg, int rop,
-   unsigned int planemask,
-   int nBox,
-   BoxPtr pBox,
-   int xorg, int yorg,
-   PixmapPtr pPix
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;
-    int cacheWidth;
-    XAACacheInfoPtr pCache;
-
-    pCache = (*infoRec->CacheMonoStipple)(pScrn, pPix);
-
-    cacheWidth = (pCache->w * pScrn->bitsPerPixel) / 
-	infoRec->CacheColorExpandDensity;
-
-    (*infoRec->SetupForScreenToScreenColorExpandFill)(pScrn, fg, bg, rop, 
-							planemask);
-
-    while(nBox--) {
-	y = pBox->y1;
-	phaseY = (y - yorg) % pCache->orig_h;
-	if(phaseY < 0) phaseY += pCache->orig_h;
-	phaseX = (pBox->x1 - xorg) % pCache->orig_w;
-	if(phaseX < 0) phaseX += pCache->orig_w;
-	height = pBox->y2 - y;
-	width = pBox->x2 - pBox->x1;
-	
-	while(1) {
-	    w = width; skipleft = phaseX; x = pBox->x1;
-	    blit_h = pCache->h - phaseY;
-	    if(blit_h > height) blit_h = height;
-	
-	    while(1) {
-		blit_w = cacheWidth - skipleft;
-		if(blit_w > w) blit_w = w;
-		(*infoRec->SubsequentScreenToScreenColorExpandFill)(
-			pScrn, x, y, blit_w, blit_h,
-			pCache->x, pCache->y + phaseY, skipleft);
-		w -= blit_w;
-		if(!w) break;
-		x += blit_w;
-		skipleft = (skipleft + blit_w) % pCache->orig_w;
-	    }
-	    height -= blit_h;
-	    if(!height) break;
-	    y += blit_h;
-	    phaseY = (phaseY + blit_h) % pCache->orig_h;
-	}
-	pBox++;
-    }
-    
-    SET_SYNC_FLAG(infoRec);
-}
-
-
-	/******************\
-	|   Image Writes   |
-	\******************/
-
-
-
-/*  This requires all LEFT_EDGE clipping.  You get too many problems
-    with reading past the edge of the pattern otherwise */
-
-static void
-WriteColumn(
-    ScrnInfoPtr pScrn,
-    unsigned char *pSrc,
-    int x, int y, int w, int h,
-    int xoff, int yoff,
-    int pHeight,
-    int srcwidth,
-    int Bpp
-) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    unsigned char *src;
-    Bool PlusOne = FALSE;
-    int skipleft, dwords;
-
-    pSrc += (Bpp * xoff);
-   
-    if((skipleft = (long)pSrc & 0x03L)) {
-        if(Bpp == 3)
-           skipleft = 4 - skipleft;
-        else
-           skipleft /= Bpp;
-
-        x -= skipleft;       
-        w += skipleft;
-        
-        if(Bpp == 3)
-           pSrc -= 3 * skipleft;  
-        else   /* is this Alpha friendly ? */
-           pSrc = (unsigned char*)((long)pSrc & ~0x03L);     
-    }
-
-    src = pSrc + (yoff * srcwidth);
-
-    dwords = bytes_to_int32(w * Bpp);
-
-    if((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) && 
-                                                ((dwords * h) & 0x01)) {
-        PlusOne = TRUE;
-    } 
-
-    (*infoRec->SubsequentImageWriteRect)(pScrn, x, y, w, h, skipleft);
-
-    if(dwords > infoRec->ImageWriteRange) {
-        while(h--) {
-            XAAMoveDWORDS_FixedBase((CARD32*)infoRec->ImageWriteBase,
-                (CARD32*)src, dwords);
-            src += srcwidth;
-	    yoff++;
-	    if(yoff >= pHeight) {
-		yoff = 0;
-		src = pSrc;
-	    }
-        }
-    } else {
-        if(srcwidth == (dwords << 2)) {
-           int maxLines = infoRec->ImageWriteRange/dwords;
-	   int step;
-
-	   while(h) {
-		step = pHeight - yoff;
-		if(step > maxLines) step = maxLines;
-		if(step > h) step = h;
-
-                XAAMoveDWORDS((CARD32*)infoRec->ImageWriteBase,
-                        (CARD32*)src, dwords * step);
-
-                src += (srcwidth * step);
-		yoff += step;
-		if(yoff >= pHeight) {
-		    yoff = 0;
-		    src = pSrc;
-		}
-                h -= step;		
-	   }
-        } else {
-            while(h--) {
-                XAAMoveDWORDS((CARD32*)infoRec->ImageWriteBase,
-                        (CARD32*)src, dwords);
-                src += srcwidth;
-		yoff++;
-		if(yoff >= pHeight) {
-		    yoff = 0;
-		    src = pSrc;
-		}
-            }
-        }
-    }
-
-    if(PlusOne) {
-        CARD32* base = (CARD32*)infoRec->ImageWriteBase;
-        *base = 0x00000000;
-    }
-}
-
-void
-XAAFillImageWriteRects(
-    ScrnInfoPtr pScrn,
-    int rop,
-    unsigned int planemask,
-    int nBox,
-    BoxPtr pBox,
-    int xorg, int yorg,
-    PixmapPtr pPix
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, phaseY, phaseX, height, width, blit_w;
-    int pHeight = pPix->drawable.height;
-    int pWidth = pPix->drawable.width;
-    int Bpp = pPix->drawable.bitsPerPixel >> 3;
-    int srcwidth = pPix->devKind;
-
-    (*infoRec->SetupForImageWrite)(pScrn, rop, planemask, -1,
-		pPix->drawable.bitsPerPixel, pPix->drawable.depth);
-
-    while(nBox--) {
-	x = pBox->x1;
-	phaseY = (pBox->y1 - yorg) % pHeight;
-	if(phaseY < 0) phaseY += pHeight;
-	phaseX = (x - xorg) % pWidth;
-	if(phaseX < 0) phaseX += pWidth;
-	height = pBox->y2 - pBox->y1;
-	width = pBox->x2 - x;
-	
-	while(1) {
-	    blit_w = pWidth - phaseX;
-	    if(blit_w > width) blit_w = width;
-
-	    WriteColumn(pScrn, pPix->devPrivate.ptr, x, pBox->y1, 
-		blit_w, height, phaseX, phaseY, pHeight, srcwidth, Bpp);
-
-	    width -= blit_w;
-	    if(!width) break;
-	    x += blit_w;
-	    phaseX = (phaseX + blit_w) % pWidth;
-	}
-	pBox++;
-    }
-
-    if(infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)
-        (*infoRec->Sync)(pScrn);
-    else SET_SYNC_FLAG(infoRec);
-}
-
-
-	/*************\
-	|  Utilities  |
-	\*************/
-
-
-void
-XAAClipAndRenderRects(
-   GCPtr pGC, 
-   ClipAndRenderRectsFunc BoxFunc, 
-   int nrectFill, 
-   xRectangle *prect, 
-   int xorg, int yorg
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int 	Right, Bottom, MaxBoxes;
-    BoxPtr 	pextent, pboxClipped, pboxClippedBase;
-
-    MaxBoxes = infoRec->PreAllocSize/sizeof(BoxRec);  
-    pboxClippedBase = (BoxPtr)infoRec->PreAllocMem;
-    pboxClipped = pboxClippedBase;
-
-    if (REGION_NUM_RECTS(pGC->pCompositeClip) == 1) {
-	pextent = REGION_RECTS(pGC->pCompositeClip);
-    	while (nrectFill--) {
-	    pboxClipped->x1 = max(pextent->x1, prect->x);
-	    pboxClipped->y1 = max(pextent->y1, prect->y);
-
-	    Right = (int)prect->x + (int)prect->width;
-	    pboxClipped->x2 = min(pextent->x2, Right);
-    
-	    Bottom = (int)prect->y + (int)prect->height;
-	    pboxClipped->y2 = min(pextent->y2, Bottom);
-
-	    prect++;
-	    if ((pboxClipped->x1 < pboxClipped->x2) &&
-		(pboxClipped->y1 < pboxClipped->y2)) {
-		pboxClipped++;
-		if(pboxClipped >= (pboxClippedBase + MaxBoxes)) {
-		    (*BoxFunc)(pGC, MaxBoxes, pboxClippedBase, xorg, yorg); 
-		    pboxClipped = pboxClippedBase;
-		}
-	    }
-    	}
-    } else {
-	pextent = REGION_EXTENTS(pGC->pScreen, pGC->pCompositeClip);
-    	while (nrectFill--) {
-	    int n;
-	    BoxRec box, *pbox;
-   
-	    box.x1 = max(pextent->x1, prect->x);
-   	    box.y1 = max(pextent->y1, prect->y);
-     
-	    Right = (int)prect->x + (int)prect->width;
-	    box.x2 = min(pextent->x2, Right);
-  
-	    Bottom = (int)prect->y + (int)prect->height;
-	    box.y2 = min(pextent->y2, Bottom);
-    
-	    prect++;
-    
-	    if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
-	    	continue;
-    
-	    n = REGION_NUM_RECTS (pGC->pCompositeClip);
-	    pbox = REGION_RECTS(pGC->pCompositeClip);
-    
-	    /* clip the rectangle to each box in the clip region
-	       this is logically equivalent to calling Intersect()
-	    */
-	    while(n--) {
-		pboxClipped->x1 = max(box.x1, pbox->x1);
-		pboxClipped->y1 = max(box.y1, pbox->y1);
-		pboxClipped->x2 = min(box.x2, pbox->x2);
-		pboxClipped->y2 = min(box.y2, pbox->y2);
-		pbox++;
-
-		/* see if clipping left anything */
-		if(pboxClipped->x1 < pboxClipped->x2 && 
-		   pboxClipped->y1 < pboxClipped->y2) {
-		    pboxClipped++;
-		    if(pboxClipped >= (pboxClippedBase + MaxBoxes)) {
-			(*BoxFunc)(pGC, MaxBoxes, pboxClippedBase, xorg, yorg); 
-			pboxClipped = pboxClippedBase;
-		    }
-		}
-	    }
-    	}
-    }
-
-    if(pboxClipped != pboxClippedBase)
-	(*BoxFunc)(pGC, pboxClipped - pboxClippedBase, pboxClippedBase, 
-					xorg, yorg); 
-}
-
-
-int
-XAAGetRectClipBoxes(
-    GCPtr pGC,
-    BoxPtr pboxClippedBase,
-    int nrectFill,
-    xRectangle *prectInit
-){
-    int 	Right, Bottom;
-    BoxPtr 	pextent, pboxClipped = pboxClippedBase;
-    xRectangle	*prect = prectInit;
-    RegionPtr   prgnClip = pGC->pCompositeClip;
-
-    if (REGION_NUM_RECTS(prgnClip) == 1) {
-	pextent = REGION_RECTS(prgnClip);
-    	while (nrectFill--) {
-	    pboxClipped->x1 = max(pextent->x1, prect->x);
-	    pboxClipped->y1 = max(pextent->y1, prect->y);
-
-	    Right = (int)prect->x + (int)prect->width;
-	    pboxClipped->x2 = min(pextent->x2, Right);
-    
-	    Bottom = (int)prect->y + (int)prect->height;
-	    pboxClipped->y2 = min(pextent->y2, Bottom);
-
-	    prect++;
-	    if ((pboxClipped->x1 < pboxClipped->x2) &&
-		(pboxClipped->y1 < pboxClipped->y2)) {
-		pboxClipped++;
-	    }
-    	}
-    } else {
-	pextent = REGION_EXTENTS(pGC->pScreen, prgnClip);
-    	while (nrectFill--) {
-	    int n;
-	    BoxRec box, *pbox;
-   
-	    box.x1 = max(pextent->x1, prect->x);
-   	    box.y1 = max(pextent->y1, prect->y);
-     
-	    Right = (int)prect->x + (int)prect->width;
-	    box.x2 = min(pextent->x2, Right);
-  
-	    Bottom = (int)prect->y + (int)prect->height;
-	    box.y2 = min(pextent->y2, Bottom);
-    
-	    prect++;
-    
-	    if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
-	    	continue;
-    
-	    n = REGION_NUM_RECTS (prgnClip);
-	    pbox = REGION_RECTS(prgnClip);
-    
-	    /* clip the rectangle to each box in the clip region
-	       this is logically equivalent to calling Intersect()
-	    */
-	    while(n--) {
-		pboxClipped->x1 = max(box.x1, pbox->x1);
-		pboxClipped->y1 = max(box.y1, pbox->y1);
-		pboxClipped->x2 = min(box.x2, pbox->x2);
-		pboxClipped->y2 = min(box.y2, pbox->y2);
-		pbox++;
-
-		/* see if clipping left anything */
-		if(pboxClipped->x1 < pboxClipped->x2 && 
-		   pboxClipped->y1 < pboxClipped->y2) {
-		    pboxClipped++;
-		}
-	    }
-    	}
-    }
-
-    return(pboxClipped - pboxClippedBase);  
-}
-
+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include <X11/X.h>

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "xf86str.h"

+#include "xaa.h"

+#include "xaalocal.h"

+

+

+static void XAARenderSolidRects(GCPtr, int, BoxPtr, int, int);

+static void XAARenderColor8x8Rects(GCPtr, int, BoxPtr, int, int);

+static void XAARenderMono8x8Rects(GCPtr, int, BoxPtr, int, int);

+static void XAARenderColorExpandRects(GCPtr, int, BoxPtr, int, int);

+static void XAARenderCacheExpandRects(GCPtr, int, BoxPtr, int, int);

+static void XAARenderCacheBltRects(GCPtr, int, BoxPtr, int, int);

+static void XAARenderImageWriteRects(GCPtr, int, BoxPtr, int, int);

+static void XAARenderPixmapCopyRects(GCPtr, int, BoxPtr, int, int);

+

+void

+XAAPolyFillRect(

+    DrawablePtr pDraw,

+    GCPtr pGC,

+    int		nrectFill, 	/* number of rectangles to fill */

+    xRectangle	*prectInit   	/* Pointer to first rectangle to fill */

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    int		xorg = pDraw->x;

+    int		yorg = pDraw->y;

+    int		type = 0;

+    ClipAndRenderRectsFunc function;

+

+    if((nrectFill <= 0) || !pGC->planemask)

+        return;

+

+    if(!RegionNumRects(pGC->pCompositeClip))

+	return;

+

+    switch(pGC->fillStyle) {

+    case FillSolid:

+	type = DO_SOLID;

+	break;

+    case FillStippled:

+	type = (*infoRec->StippledFillChooser)(pGC);

+	break;

+    case FillOpaqueStippled:

+	if((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSolidRects &&

+                CHECK_PLANEMASK(pGC,infoRec->FillSolidRectsFlags) &&

+                CHECK_ROP(pGC,infoRec->FillSolidRectsFlags) &&

+                CHECK_ROPSRC(pGC,infoRec->FillSolidRectsFlags) &&

+                CHECK_FG(pGC,infoRec->FillSolidRectsFlags))

+	    type = DO_SOLID;

+	else

+	    type = (*infoRec->OpaqueStippledFillChooser)(pGC);

+	break;

+    case FillTiled:

+	type = (*infoRec->TiledFillChooser)(pGC);

+	break;

+    }

+

+    switch(type) {

+    case DO_SOLID:

+	function = XAARenderSolidRects;	

+	break;	

+    case DO_COLOR_8x8:

+	function = XAARenderColor8x8Rects;	

+	break;	

+    case DO_MONO_8x8:

+	function = XAARenderMono8x8Rects;	

+	break;	

+    case DO_CACHE_BLT:

+	function = XAARenderCacheBltRects;	

+	break;	

+    case DO_COLOR_EXPAND:

+	function = XAARenderColorExpandRects;	

+	break;	

+    case DO_CACHE_EXPAND:

+	function = XAARenderCacheExpandRects;	

+	break;	

+    case DO_IMAGE_WRITE:

+	function = XAARenderImageWriteRects;	

+	break;	

+    case DO_PIXMAP_COPY:

+	function = XAARenderPixmapCopyRects;	

+	break;	

+    default:

+	(*XAAFallbackOps.PolyFillRect)(pDraw, pGC, nrectFill, prectInit);

+	return;

+    }

+

+    if(xorg | yorg) {

+	int n = nrectFill;

+	xRectangle *prect = prectInit;

+

+	while(n--) {

+	    prect->x += xorg;

+	    prect->y += yorg;

+	    prect++;

+	}

+    }

+

+    

+    XAAClipAndRenderRects(pGC, function, nrectFill, prectInit, xorg, yorg);

+}

+

+

+

+	/*********************\

+	|     Solid Rects     |

+	\*********************/

+

+static void

+XAARenderSolidRects(

+   GCPtr pGC,

+   int nboxes,

+   BoxPtr pClipBoxes,

+   int xorg, int yorg

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+

+   (*infoRec->FillSolidRects) (infoRec->pScrn, 

+               pGC->fgPixel, pGC->alu, pGC->planemask, nboxes, pClipBoxes);

+}

+

+

+	/************************\

+	|     Mono 8x8 Rects     |

+	\************************/

+

+static void

+XAARenderMono8x8Rects(

+   GCPtr pGC,

+   int nboxes,

+   BoxPtr pClipBoxes,

+   int xorg, int yorg

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   XAAPixmapPtr pPriv;

+   int fg, bg;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);

+      fg = pGC->fgPixel;  bg = -1;

+      break;

+   case FillOpaqueStippled:

+      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);

+      fg = pGC->fgPixel;  bg = pGC->bgPixel;

+      break;

+   case FillTiled:

+      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);

+      fg = pPriv->fg;  bg = pPriv->bg;

+      break;

+   default:	/* Muffle compiler */

+      pPriv = NULL;	/* Kaboom */

+      fg = -1;  bg = -1;

+      break;

+   }

+

+   (*infoRec->FillMono8x8PatternRects) (infoRec->pScrn, 

+                fg, bg, pGC->alu, pGC->planemask, 

+                nboxes, pClipBoxes, pPriv->pattern0, pPriv->pattern1, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));

+}

+

+	/*************************\

+	|     Color 8x8 Rects     |

+	\*************************/

+

+static void

+XAARenderColor8x8Rects(

+   GCPtr pGC,

+   int nboxes,

+   BoxPtr pClipBoxes,

+   int xorg, int yorg

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   XAACacheInfoPtr pCache;

+   PixmapPtr pPix;

+   int fg, bg;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      pPix = pGC->stipple;

+      fg = pGC->fgPixel;  bg = -1;

+      break;

+   case FillOpaqueStippled:

+      pPix = pGC->stipple;

+      fg = pGC->fgPixel;  bg = pGC->bgPixel;

+      break;

+   case FillTiled:

+      pPix = pGC->tile.pixmap;

+      fg = -1;  bg = -1;

+      break;

+   default:	/* Muffle compiler */

+      pPix = NULL;

+      fg = -1;  bg = -1;

+      break;

+   }

+

+   pCache = (*infoRec->CacheColor8x8Pattern)(infoRec->pScrn, pPix, fg, bg);

+   (*infoRec->FillColor8x8PatternRects) (infoRec->pScrn,

+                pGC->alu, pGC->planemask, nboxes, pClipBoxes, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y), pCache);

+}

+

+

+	/****************************\

+	|     Color Expand Rects     |

+	\****************************/

+

+static void

+XAARenderColorExpandRects(

+   GCPtr pGC,

+   int nboxes,

+   BoxPtr pClipBoxes,

+   int xorg, int yorg

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   int fg, bg;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      fg = pGC->fgPixel;  bg = -1;

+      break;

+   case FillOpaqueStippled:

+      fg = pGC->fgPixel;  bg = pGC->bgPixel;

+      break;

+   default:	/* Muffle compiler */

+      fg = -1;  bg = -1;

+      break;

+   }

+

+   (*infoRec->FillColorExpandRects) (infoRec->pScrn, fg, bg, 

+                pGC->alu, pGC->planemask, nboxes, pClipBoxes, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),

+		pGC->stipple);

+}

+

+

+	/*************************\

+	|     Cache Blt Rects     |

+	\*************************/

+

+static void

+XAARenderCacheBltRects(

+   GCPtr pGC,

+   int nboxes,

+   BoxPtr pClipBoxes,

+   int xorg, int yorg

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   XAACacheInfoPtr pCache;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 

+					pGC->fgPixel, -1);

+      break;

+   case FillOpaqueStippled:

+      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 

+					pGC->fgPixel, pGC->bgPixel);

+      break;

+   case FillTiled:

+      pCache = (*infoRec->CacheTile)(infoRec->pScrn, pGC->tile.pixmap);

+      break;

+   default:	/* Muffle compiler */

+      pCache = NULL;

+      break;

+   }

+

+   (*infoRec->FillCacheBltRects) (infoRec->pScrn, pGC->alu, 

+                pGC->planemask, nboxes, pClipBoxes, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y), pCache);

+}

+

+

+	/****************************\

+	|     Cache Expand Rects     |

+	\****************************/

+

+static void

+XAARenderCacheExpandRects(

+   GCPtr pGC,

+   int nboxes,

+   BoxPtr pClipBoxes,

+   int xorg, int yorg

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   int fg, bg;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      fg = pGC->fgPixel;  bg = -1;

+      break;

+   case FillOpaqueStippled:

+      fg = pGC->fgPixel;  bg = pGC->bgPixel;

+      break;

+   default:	/* Muffle compiler */

+      fg = -1;  bg = -1;

+      break;

+   }

+

+   (*infoRec->FillCacheExpandRects) (infoRec->pScrn, fg, bg,

+                pGC->alu, pGC->planemask, nboxes, pClipBoxes, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y), 

+                pGC->stipple);

+}

+

+

+

+	/***************************\

+	|     Image Write Rects     |

+	\***************************/

+

+static void

+XAARenderImageWriteRects(

+   GCPtr pGC,

+   int nboxes,

+   BoxPtr pClipBoxes,

+   int xorg, int yorg

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+

+   (*infoRec->FillImageWriteRects) (infoRec->pScrn, pGC->alu, 

+                pGC->planemask, nboxes, pClipBoxes, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),

+                pGC->tile.pixmap);

+}

+

+

+

+	/***************************\

+	|     Pixmap Copy Rects     |

+	\***************************/

+

+static void

+XAARenderPixmapCopyRects(

+   GCPtr pGC,

+   int nboxes,

+   BoxPtr pClipBoxes,

+   int xorg, int yorg

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);

+   XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);

+

+   pCache->x = pPriv->offscreenArea->box.x1;

+   pCache->y = pPriv->offscreenArea->box.y1;

+   pCache->w = pCache->orig_w = 

+		pPriv->offscreenArea->box.x2 - pCache->x;

+   pCache->h = pCache->orig_h = 

+		pPriv->offscreenArea->box.y2 - pCache->y;

+   pCache->trans_color = -1;

+

+   (*infoRec->FillCacheBltRects) (infoRec->pScrn, pGC->alu, 

+                pGC->planemask, nboxes, pClipBoxes, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y), 

+                pCache);

+}

+

+

+

+	/************\

+	|   Solid    |

+	\************/

+

+void

+XAAFillSolidRects(

+    ScrnInfoPtr pScrn,

+    int	fg, int rop,

+    unsigned int planemask,

+    int		nBox, 		/* number of rectangles to fill */

+    BoxPtr	pBox  		/* Pointer to first rectangle to fill */

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+

+    (*infoRec->SetupForSolidFill)(pScrn, fg, rop, planemask);

+     while(nBox--) {

+        (*infoRec->SubsequentSolidFillRect)(pScrn, pBox->x1, pBox->y1,

+ 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);

+	pBox++;

+     }

+     SET_SYNC_FLAG(infoRec);

+}

+

+

+

+

+	/*********************\

+	|  8x8 Mono Patterns  |

+	\*********************/

+

+

+void

+XAAFillMono8x8PatternRectsScreenOrigin(

+    ScrnInfoPtr pScrn,

+    int	fg, int bg, int rop,

+    unsigned int planemask,

+    int	nBox,

+    BoxPtr pBox,

+    int pattern0, int pattern1,

+    int xorigin, int yorigin

+)

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int patx = pattern0, paty = pattern1;

+    int xorg = (-xorigin) & 0x07;

+    int yorg = (-yorigin) & 0x07;

+

+

+    if(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {

+   	if(!(infoRec->Mono8x8PatternFillFlags & 		

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	    XAARotateMonoPattern(&patx, &paty, xorg, yorg,

+				(infoRec->Mono8x8PatternFillFlags &

+				 BIT_ORDER_IN_BYTE_MSBFIRST));

+	    xorg = patx; yorg = paty;

+        }

+    } else {

+	XAACacheInfoPtr pCache =

+		(*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);

+	patx = pCache->x;  paty = pCache->y;

+   	if(!(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	    int slot = (yorg << 3) + xorg;

+	    patx += pCache->offsets[slot].x;

+	    paty += pCache->offsets[slot].y;

+	    xorg = patx;  yorg = paty;

+	}	

+    }

+

+    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,

+					fg, bg, rop, planemask);

+

+     while(nBox--) {

+        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 

+			xorg, yorg, pBox->x1, pBox->y1,

+ 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);

+	pBox++;

+     }

+     SET_SYNC_FLAG(infoRec);

+}

+

+void

+XAAFillMono8x8PatternRects(

+    ScrnInfoPtr pScrn,

+    int	fg, int bg, int rop,

+    unsigned int planemask,

+    int	nBox,

+    BoxPtr pBox,

+    int pattern0, int pattern1,

+    int xorigin, int yorigin

+)

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int patx = pattern0, paty = pattern1;

+    int xorg, yorg;

+    XAACacheInfoPtr pCache = NULL;

+

+

+    if(!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)){

+	pCache = (*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);

+	patx = pCache->x;  paty = pCache->y;

+    }

+

+

+    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,

+					fg, bg, rop, planemask);

+

+

+     while(nBox--) {

+	xorg = (pBox->x1 - xorigin) & 0x07;

+	yorg = (pBox->y1 - yorigin) & 0x07;

+

+   	if(!(infoRec->Mono8x8PatternFillFlags & 		

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	    if(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_PROGRAMMED_BITS) {

+		patx = pattern0; paty = pattern1;

+		XAARotateMonoPattern(&patx, &paty, xorg, yorg,

+				(infoRec->Mono8x8PatternFillFlags & 		

+				BIT_ORDER_IN_BYTE_MSBFIRST));

+		xorg = patx; yorg = paty;

+	    } else {

+		int slot = (yorg << 3) + xorg;

+	    	xorg = patx + pCache->offsets[slot].x;

+	    	yorg = paty + pCache->offsets[slot].y;

+	    }

+        }

+

+        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 

+			xorg, yorg, pBox->x1, pBox->y1,

+ 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);

+	pBox++;

+     }

+

+     SET_SYNC_FLAG(infoRec);

+}

+

+

+	/**********************\

+	|  8x8 Color Patterns  |

+	\**********************/

+

+

+void

+XAAFillColor8x8PatternRectsScreenOrigin(

+   ScrnInfoPtr pScrn,

+   int rop,

+   unsigned int planemask,

+   int nBox,

+   BoxPtr pBox,

+   int xorigin, int yorigin,

+   XAACacheInfoPtr pCache

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int patx = pCache->x, paty = pCache->y;

+    int xorg = (-xorigin) & 0x07;

+    int yorg = (-yorigin) & 0x07;

+

+    if(!(infoRec->Color8x8PatternFillFlags & 

+					HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	int slot = (yorg << 3) + xorg;

+	paty += pCache->offsets[slot].y;

+	patx += pCache->offsets[slot].x;

+	xorg = patx;  yorg = paty;

+    }	

+

+    (*infoRec->SetupForColor8x8PatternFill)(pScrn, patx, paty,

+			 rop, planemask, pCache->trans_color);

+

+    while(nBox--) {

+        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 

+			xorg, yorg, pBox->x1, pBox->y1,

+ 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);

+	pBox++;

+    }

+    SET_SYNC_FLAG(infoRec);

+}

+

+void

+XAAFillColor8x8PatternRects(

+   ScrnInfoPtr pScrn,

+   int rop,

+   unsigned int planemask,

+   int nBox,

+   BoxPtr pBox,

+   int xorigin, int yorigin,

+   XAACacheInfoPtr pCache

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int xorg, yorg;

+

+    (*infoRec->SetupForColor8x8PatternFill)(pScrn, pCache->x, pCache->y,

+			 rop, planemask, pCache->trans_color);

+

+     while(nBox--) {

+	xorg = (pBox->x1 - xorigin) & 0x07;

+	yorg = (pBox->y1 - yorigin) & 0x07;

+

+   	if(!(infoRec->Color8x8PatternFillFlags & 		

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	    int slot = (yorg << 3) + xorg;

+	    yorg = pCache->y + pCache->offsets[slot].y;

+	    xorg = pCache->x + pCache->offsets[slot].x;

+        }

+

+        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 

+			xorg, yorg, pBox->x1, pBox->y1,

+ 			pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);

+	pBox++;

+     }

+

+     SET_SYNC_FLAG(infoRec);

+}

+

+

+	/***************\

+	|  Cache Blits  |

+	\***************/

+

+void

+XAAFillCacheBltRects(

+   ScrnInfoPtr pScrn,

+   int rop,

+   unsigned int planemask,

+   int nBox,

+   BoxPtr pBox,

+   int xorg, int yorg,

+   XAACacheInfoPtr pCache

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;

+

+    (*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, rop, planemask,

+		pCache->trans_color);

+

+    while(nBox--) {

+	y = pBox->y1;

+	phaseY = (y - yorg) % pCache->orig_h;

+	if(phaseY < 0) phaseY += pCache->orig_h;

+	phaseX = (pBox->x1 - xorg) % pCache->orig_w;

+	if(phaseX < 0) phaseX += pCache->orig_w;

+	height = pBox->y2 - y;

+	width = pBox->x2 - pBox->x1;

+	

+#if 0

+	if (rop == GXcopy) {

+	    while(1) {

+		w = width; skipleft = phaseX; x = pBox->x1;

+		blit_h = pCache->h - phaseY;

+		if(blit_h > height) blit_h = height;

+	

+		while(1) {

+		    blit_w = pCache->w - skipleft;

+		    if(blit_w > w) blit_w = w;

+		    (*infoRec->SubsequentScreenToScreenCopy)(pScrn,

+			pCache->x + skipleft, pCache->y + phaseY,

+			x, y, blit_w, blit_h);

+		    w -= blit_w;

+		    if(!w) break;

+		    x += blit_w;

+		    skipleft = (skipleft + blit_w) % pCache->orig_w;

+		    if(blit_w >= pCache->orig_w) break;

+		}

+

+		/* Expand horizontally */

+		if (w) {

+		    skipleft -= phaseX;

+		    if (skipleft < 0) skipleft += pCache->orig_w;

+		    blit_w = x - pBox->x1 - skipleft;

+		    while(w) {

+			if (blit_w > w) blit_w = w;

+			(*infoRec->SubsequentScreenToScreenCopy)(pScrn,

+			    pBox->x1 + skipleft, y, x, y, blit_w, blit_h);

+			w -= blit_w;

+			x += blit_w;

+			blit_w <<= 1;

+		    }

+		}

+

+		height -= blit_h;

+		if(!height) break;

+		y += blit_h;

+		phaseY = (phaseY + blit_h) % pCache->orig_h;

+		if(blit_h >= pCache->orig_h) break;

+	    }

+

+	    /* Expand vertically */

+	    if (height) {

+		blit_w = pBox->x2 - pBox->x1;

+		phaseY -= (pBox->y1 - yorg) % pCache->orig_h;

+		if (phaseY < 0) phaseY += pCache->orig_h;

+		blit_h = y - pBox->y1  - phaseY;

+		while(height) {

+		    if (blit_h > height) blit_h = height;

+		    (*infoRec->SubsequentScreenToScreenCopy)(pScrn, pBox->x1,

+			pBox->y1 + phaseY, pBox->x1, y, blit_w, blit_h);

+		    height -= blit_h;

+		    y += blit_h;

+		    blit_h <<= 1;

+		}

+	    }

+	} else 

+#endif

+	{

+	    while(1) {

+		w = width; skipleft = phaseX; x = pBox->x1;

+		blit_h = pCache->h - phaseY;

+		if(blit_h > height) blit_h = height;

+	

+		while(1) {

+		    blit_w = pCache->w - skipleft;

+		    if(blit_w > w) blit_w = w;

+		    (*infoRec->SubsequentScreenToScreenCopy)(pScrn,

+			pCache->x + skipleft, pCache->y + phaseY,

+			x, y, blit_w, blit_h);

+		    w -= blit_w;

+		    if(!w) break;

+		    x += blit_w;

+		    skipleft = (skipleft + blit_w) % pCache->orig_w;

+		}

+		height -= blit_h;

+		if(!height) break;

+		y += blit_h;

+		phaseY = (phaseY + blit_h) % pCache->orig_h;

+	    }

+	}

+	pBox++;

+    }

+    

+    SET_SYNC_FLAG(infoRec);

+}

+

+

+

+

+	/*******************\

+	|  Cache Expansion  |

+	\*******************/

+

+

+

+void

+XAAFillCacheExpandRects(

+   ScrnInfoPtr pScrn,

+   int fg, int bg, int rop,

+   unsigned int planemask,

+   int nBox,

+   BoxPtr pBox,

+   int xorg, int yorg,

+   PixmapPtr pPix

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;

+    int cacheWidth;

+    XAACacheInfoPtr pCache;

+

+    pCache = (*infoRec->CacheMonoStipple)(pScrn, pPix);

+

+    cacheWidth = (pCache->w * pScrn->bitsPerPixel) / 

+	infoRec->CacheColorExpandDensity;

+

+    (*infoRec->SetupForScreenToScreenColorExpandFill)(pScrn, fg, bg, rop, 

+							planemask);

+

+    while(nBox--) {

+	y = pBox->y1;

+	phaseY = (y - yorg) % pCache->orig_h;

+	if(phaseY < 0) phaseY += pCache->orig_h;

+	phaseX = (pBox->x1 - xorg) % pCache->orig_w;

+	if(phaseX < 0) phaseX += pCache->orig_w;

+	height = pBox->y2 - y;

+	width = pBox->x2 - pBox->x1;

+	

+	while(1) {

+	    w = width; skipleft = phaseX; x = pBox->x1;

+	    blit_h = pCache->h - phaseY;

+	    if(blit_h > height) blit_h = height;

+	

+	    while(1) {

+		blit_w = cacheWidth - skipleft;

+		if(blit_w > w) blit_w = w;

+		(*infoRec->SubsequentScreenToScreenColorExpandFill)(

+			pScrn, x, y, blit_w, blit_h,

+			pCache->x, pCache->y + phaseY, skipleft);

+		w -= blit_w;

+		if(!w) break;

+		x += blit_w;

+		skipleft = (skipleft + blit_w) % pCache->orig_w;

+	    }

+	    height -= blit_h;

+	    if(!height) break;

+	    y += blit_h;

+	    phaseY = (phaseY + blit_h) % pCache->orig_h;

+	}

+	pBox++;

+    }

+    

+    SET_SYNC_FLAG(infoRec);

+}

+

+

+	/******************\

+	|   Image Writes   |

+	\******************/

+

+

+

+/*  This requires all LEFT_EDGE clipping.  You get too many problems

+    with reading past the edge of the pattern otherwise */

+

+static void

+WriteColumn(

+    ScrnInfoPtr pScrn,

+    unsigned char *pSrc,

+    int x, int y, int w, int h,

+    int xoff, int yoff,

+    int pHeight,

+    int srcwidth,

+    int Bpp

+) {

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    unsigned char *src;

+    Bool PlusOne = FALSE;

+    int skipleft, dwords;

+

+    pSrc += (Bpp * xoff);

+   

+    if((skipleft = (long)pSrc & 0x03L)) {

+        if(Bpp == 3)

+           skipleft = 4 - skipleft;

+        else

+           skipleft /= Bpp;

+

+        x -= skipleft;       

+        w += skipleft;

+        

+        if(Bpp == 3)

+           pSrc -= 3 * skipleft;  

+        else   /* is this Alpha friendly ? */

+           pSrc = (unsigned char*)((long)pSrc & ~0x03L);     

+    }

+

+    src = pSrc + (yoff * srcwidth);

+

+    dwords = bytes_to_int32(w * Bpp);

+

+    if((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) && 

+                                                ((dwords * h) & 0x01)) {

+        PlusOne = TRUE;

+    } 

+

+    (*infoRec->SubsequentImageWriteRect)(pScrn, x, y, w, h, skipleft);

+

+    if(dwords > infoRec->ImageWriteRange) {

+        while(h--) {

+            XAAMoveDWORDS_FixedBase((CARD32*)infoRec->ImageWriteBase,

+                (CARD32*)src, dwords);

+            src += srcwidth;

+	    yoff++;

+	    if(yoff >= pHeight) {

+		yoff = 0;

+		src = pSrc;

+	    }

+        }

+    } else {

+        if(srcwidth == (dwords << 2)) {

+           int maxLines = infoRec->ImageWriteRange/dwords;

+	   int step;

+

+	   while(h) {

+		step = pHeight - yoff;

+		if(step > maxLines) step = maxLines;

+		if(step > h) step = h;

+

+                XAAMoveDWORDS((CARD32*)infoRec->ImageWriteBase,

+                        (CARD32*)src, dwords * step);

+

+                src += (srcwidth * step);

+		yoff += step;

+		if(yoff >= pHeight) {

+		    yoff = 0;

+		    src = pSrc;

+		}

+                h -= step;		

+	   }

+        } else {

+            while(h--) {

+                XAAMoveDWORDS((CARD32*)infoRec->ImageWriteBase,

+                        (CARD32*)src, dwords);

+                src += srcwidth;

+		yoff++;

+		if(yoff >= pHeight) {

+		    yoff = 0;

+		    src = pSrc;

+		}

+            }

+        }

+    }

+

+    if(PlusOne) {

+        CARD32* base = (CARD32*)infoRec->ImageWriteBase;

+        *base = 0x00000000;

+    }

+}

+

+void

+XAAFillImageWriteRects(

+    ScrnInfoPtr pScrn,

+    int rop,

+    unsigned int planemask,

+    int nBox,

+    BoxPtr pBox,

+    int xorg, int yorg,

+    PixmapPtr pPix

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int x, phaseY, phaseX, height, width, blit_w;

+    int pHeight = pPix->drawable.height;

+    int pWidth = pPix->drawable.width;

+    int Bpp = pPix->drawable.bitsPerPixel >> 3;

+    int srcwidth = pPix->devKind;

+

+    (*infoRec->SetupForImageWrite)(pScrn, rop, planemask, -1,

+		pPix->drawable.bitsPerPixel, pPix->drawable.depth);

+

+    while(nBox--) {

+	x = pBox->x1;

+	phaseY = (pBox->y1 - yorg) % pHeight;

+	if(phaseY < 0) phaseY += pHeight;

+	phaseX = (x - xorg) % pWidth;

+	if(phaseX < 0) phaseX += pWidth;

+	height = pBox->y2 - pBox->y1;

+	width = pBox->x2 - x;

+	

+	while(1) {

+	    blit_w = pWidth - phaseX;

+	    if(blit_w > width) blit_w = width;

+

+	    WriteColumn(pScrn, pPix->devPrivate.ptr, x, pBox->y1, 

+		blit_w, height, phaseX, phaseY, pHeight, srcwidth, Bpp);

+

+	    width -= blit_w;

+	    if(!width) break;

+	    x += blit_w;

+	    phaseX = (phaseX + blit_w) % pWidth;

+	}

+	pBox++;

+    }

+

+    if(infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)

+        (*infoRec->Sync)(pScrn);

+    else SET_SYNC_FLAG(infoRec);

+}

+

+

+	/*************\

+	|  Utilities  |

+	\*************/

+

+

+void

+XAAClipAndRenderRects(

+   GCPtr pGC, 

+   ClipAndRenderRectsFunc BoxFunc, 

+   int nrectFill, 

+   xRectangle *prect, 

+   int xorg, int yorg

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    int 	Right, Bottom, MaxBoxes;

+    BoxPtr 	pextent, pboxClipped, pboxClippedBase;

+

+    MaxBoxes = infoRec->PreAllocSize/sizeof(BoxRec);  

+    pboxClippedBase = (BoxPtr)infoRec->PreAllocMem;

+    pboxClipped = pboxClippedBase;

+

+    if (RegionNumRects(pGC->pCompositeClip) == 1) {

+	pextent = RegionRects(pGC->pCompositeClip);

+    	while (nrectFill--) {

+	    pboxClipped->x1 = max(pextent->x1, prect->x);

+	    pboxClipped->y1 = max(pextent->y1, prect->y);

+

+	    Right = (int)prect->x + (int)prect->width;

+	    pboxClipped->x2 = min(pextent->x2, Right);

+    

+	    Bottom = (int)prect->y + (int)prect->height;

+	    pboxClipped->y2 = min(pextent->y2, Bottom);

+

+	    prect++;

+	    if ((pboxClipped->x1 < pboxClipped->x2) &&

+		(pboxClipped->y1 < pboxClipped->y2)) {

+		pboxClipped++;

+		if(pboxClipped >= (pboxClippedBase + MaxBoxes)) {

+		    (*BoxFunc)(pGC, MaxBoxes, pboxClippedBase, xorg, yorg); 

+		    pboxClipped = pboxClippedBase;

+		}

+	    }

+    	}

+    } else {

+	pextent = RegionExtents(pGC->pCompositeClip);

+    	while (nrectFill--) {

+	    int n;

+	    BoxRec box, *pbox;

+   

+	    box.x1 = max(pextent->x1, prect->x);

+   	    box.y1 = max(pextent->y1, prect->y);

+     

+	    Right = (int)prect->x + (int)prect->width;

+	    box.x2 = min(pextent->x2, Right);

+  

+	    Bottom = (int)prect->y + (int)prect->height;

+	    box.y2 = min(pextent->y2, Bottom);

+    

+	    prect++;

+    

+	    if ((box.x1 >= box.x2) || (box.y1 >= box.y2))

+	    	continue;

+    

+	    n = RegionNumRects (pGC->pCompositeClip);

+	    pbox = RegionRects(pGC->pCompositeClip);

+    

+	    /* clip the rectangle to each box in the clip region

+	       this is logically equivalent to calling Intersect()

+	    */

+	    while(n--) {

+		pboxClipped->x1 = max(box.x1, pbox->x1);

+		pboxClipped->y1 = max(box.y1, pbox->y1);

+		pboxClipped->x2 = min(box.x2, pbox->x2);

+		pboxClipped->y2 = min(box.y2, pbox->y2);

+		pbox++;

+

+		/* see if clipping left anything */

+		if(pboxClipped->x1 < pboxClipped->x2 && 

+		   pboxClipped->y1 < pboxClipped->y2) {

+		    pboxClipped++;

+		    if(pboxClipped >= (pboxClippedBase + MaxBoxes)) {

+			(*BoxFunc)(pGC, MaxBoxes, pboxClippedBase, xorg, yorg); 

+			pboxClipped = pboxClippedBase;

+		    }

+		}

+	    }

+    	}

+    }

+

+    if(pboxClipped != pboxClippedBase)

+	(*BoxFunc)(pGC, pboxClipped - pboxClippedBase, pboxClippedBase, 

+					xorg, yorg); 

+}

+

+

+int

+XAAGetRectClipBoxes(

+    GCPtr pGC,

+    BoxPtr pboxClippedBase,

+    int nrectFill,

+    xRectangle *prectInit

+){

+    int 	Right, Bottom;

+    BoxPtr 	pextent, pboxClipped = pboxClippedBase;

+    xRectangle	*prect = prectInit;

+    RegionPtr   prgnClip = pGC->pCompositeClip;

+

+    if (RegionNumRects(prgnClip) == 1) {

+	pextent = RegionRects(prgnClip);

+    	while (nrectFill--) {

+	    pboxClipped->x1 = max(pextent->x1, prect->x);

+	    pboxClipped->y1 = max(pextent->y1, prect->y);

+

+	    Right = (int)prect->x + (int)prect->width;

+	    pboxClipped->x2 = min(pextent->x2, Right);

+    

+	    Bottom = (int)prect->y + (int)prect->height;

+	    pboxClipped->y2 = min(pextent->y2, Bottom);

+

+	    prect++;

+	    if ((pboxClipped->x1 < pboxClipped->x2) &&

+		(pboxClipped->y1 < pboxClipped->y2)) {

+		pboxClipped++;

+	    }

+    	}

+    } else {

+	pextent = RegionExtents(prgnClip);

+    	while (nrectFill--) {

+	    int n;

+	    BoxRec box, *pbox;

+   

+	    box.x1 = max(pextent->x1, prect->x);

+   	    box.y1 = max(pextent->y1, prect->y);

+     

+	    Right = (int)prect->x + (int)prect->width;

+	    box.x2 = min(pextent->x2, Right);

+  

+	    Bottom = (int)prect->y + (int)prect->height;

+	    box.y2 = min(pextent->y2, Bottom);

+    

+	    prect++;

+    

+	    if ((box.x1 >= box.x2) || (box.y1 >= box.y2))

+	    	continue;

+    

+	    n = RegionNumRects (prgnClip);

+	    pbox = RegionRects(prgnClip);

+    

+	    /* clip the rectangle to each box in the clip region

+	       this is logically equivalent to calling Intersect()

+	    */

+	    while(n--) {

+		pboxClipped->x1 = max(box.x1, pbox->x1);

+		pboxClipped->y1 = max(box.y1, pbox->y1);

+		pboxClipped->x2 = min(box.x2, pbox->x2);

+		pboxClipped->y2 = min(box.y2, pbox->y2);

+		pbox++;

+

+		/* see if clipping left anything */

+		if(pboxClipped->x1 < pboxClipped->x2 && 

+		   pboxClipped->y1 < pboxClipped->y2) {

+		    pboxClipped++;

+		}

+	    }

+    	}

+    }

+

+    return pboxClipped - pboxClippedBase;

+}

+

diff --git a/xorg-server/hw/xfree86/xaa/xaaGC.c b/xorg-server/hw/xfree86/xaa/xaaGC.c
index d029d982b..4bd3750cb 100644
--- a/xorg-server/hw/xfree86/xaa/xaaGC.c
+++ b/xorg-server/hw/xfree86/xaa/xaaGC.c
@@ -243,8 +243,7 @@ XAADestroyGC(GCPtr pGC)
     if(pGCPriv->XAAOps != &XAAFallbackOps)

 	free(pGCPriv->XAAOps);

 

-    if(pGCPriv->DashPattern)

-	free(pGCPriv->DashPattern);

+    free(pGCPriv->DashPattern);

 

     (*pGC->funcs->DestroyGC)(pGC);

     XAA_GC_FUNC_EPILOGUE (pGC);

diff --git a/xorg-server/hw/xfree86/xaa/xaaImage.c b/xorg-server/hw/xfree86/xaa/xaaImage.c
index c8d98c7d0..1967c5e0e 100644
--- a/xorg-server/hw/xfree86/xaa/xaaImage.c
+++ b/xorg-server/hw/xfree86/xaa/xaaImage.c
@@ -406,7 +406,7 @@ XAAPutImage(
     Bool depthBug = FALSE;

     if(!w || !h) return;

 

-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+    if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

     depthBug = XAA_DEPTH_BUG(pGC);

@@ -431,7 +431,7 @@ XAAPutImage(
 	     !(infoRec->WriteBitmapFlags & NO_PLANEMASK) &&

 	     !(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY))){

 

-	int MaxBoxes = REGION_NUM_RECTS(pGC->pCompositeClip);

+	int MaxBoxes = RegionNumRects(pGC->pCompositeClip);

 	BoxPtr pbox, pClipBoxes;

 	int nboxes, srcx, srcy, srcwidth;

 	xRectangle TheRect;

diff --git a/xorg-server/hw/xfree86/xaa/xaaInit.c b/xorg-server/hw/xfree86/xaa/xaaInit.c
index 58efb6a82..a4b235acf 100644
--- a/xorg-server/hw/xfree86/xaa/xaaInit.c
+++ b/xorg-server/hw/xfree86/xaa/xaaInit.c
@@ -42,12 +42,12 @@ static int  XAASetDGAMode(int index, int num, DGADevicePtr devRet);
 static void XAAEnableDisableFBAccess (int index, Bool enable);

 static Bool XAAChangeWindowAttributes (WindowPtr pWin, unsigned long mask);

 

-static int XAAScreenKeyIndex;

-static DevPrivateKey XAAScreenKey = &XAAScreenKeyIndex;

-static int XAAGCKeyIndex;

-static DevPrivateKey XAAGCKey = &XAAGCKeyIndex;

-static int XAAPixmapKeyIndex;

-static DevPrivateKey XAAPixmapKey = &XAAPixmapKeyIndex;

+static DevPrivateKeyRec XAAScreenKeyRec;

+#define XAAScreenKey (&XAAScreenKeyRec)

+static DevPrivateKeyRec XAAGCKeyRec;

+#define XAAGCKey (&XAAGCKeyRec)

+static DevPrivateKeyRec XAAPixmapKeyRec;

+#define XAAPixmapKey (&XAAPixmapKeyRec)

 

 DevPrivateKey XAAGetScreenKey(void) {

     return XAAScreenKey;

@@ -84,11 +84,9 @@ XAADestroyInfoRec(XAAInfoRecPtr infoRec)
     if(infoRec->ClosePixmapCache)

 	(*infoRec->ClosePixmapCache)(infoRec->pScrn->pScreen);

    

-    if(infoRec->PreAllocMem)

-	free(infoRec->PreAllocMem);

+    free(infoRec->PreAllocMem);

 

-    if(infoRec->PixmapCachePrivate)

-	free(infoRec->PixmapCachePrivate);

+    free(infoRec->PixmapCachePrivate);

 

     free(infoRec);

 }

@@ -106,10 +104,13 @@ XAAInit(ScreenPtr pScreen, XAAInfoRecPtr infoRec)
     if (!infoRec)

 	return TRUE;

     

-    if (!dixRequestPrivate(XAAGCKey, sizeof(XAAGCRec)))

+    if (!dixRegisterPrivateKey(&XAAGCKeyRec, PRIVATE_GC, sizeof(XAAGCRec)))

+	return FALSE;

+

+    if (!dixRegisterPrivateKey(&XAAPixmapKeyRec, PRIVATE_PIXMAP, sizeof(XAAPixmapRec)))

 	return FALSE;

 

-    if (!dixRequestPrivate(XAAPixmapKey, sizeof(XAAPixmapRec)))

+    if (!dixRegisterPrivateKey(&XAAScreenKeyRec, PRIVATE_SCREEN, 0))

 	return FALSE;

 

     if (!(pScreenPriv = malloc(sizeof(XAAScreenRec))))

diff --git a/xorg-server/hw/xfree86/xaa/xaaLine.c b/xorg-server/hw/xfree86/xaa/xaaLine.c
index 7469de179..d94f1f4e0 100644
--- a/xorg-server/hw/xfree86/xaa/xaaLine.c
+++ b/xorg-server/hw/xfree86/xaa/xaaLine.c
@@ -1,394 +1,394 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <stdlib.h>
-
-#include <X11/X.h>
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "miline.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-
-void
-#ifdef POLYSEGMENT
-XAAPolySegment(
-    DrawablePtr	pDrawable,
-    GCPtr	pGC,
-    int		nseg,
-    xSegment	*pSeg
-#else
-XAAPolyLines(
-    DrawablePtr pDrawable,
-    GCPtr	pGC,
-    int		mode,		/* Origin or Previous */
-    int		npt,		/* number of points */
-    DDXPointPtr pptInit
-#endif
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    BoxPtr pboxInit = REGION_RECTS(pGC->pCompositeClip);
-    int nboxInit = REGION_NUM_RECTS(pGC->pCompositeClip);
-    unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
-    int xorg = pDrawable->x;
-    int yorg = pDrawable->y;
-    int nbox;
-    BoxPtr pbox;
-#ifndef POLYSEGMENT
-    DDXPointPtr ppt;
-#endif
-    int x1, x2, y1, y2, tmp, len;
-
-    if(!nboxInit)
-	return;
-
-    if (infoRec->SolidLineFlags & LINE_LIMIT_COORDS) {
-	int minValX = infoRec->SolidLineLimits.x1;
-	int maxValX = infoRec->SolidLineLimits.x2;
-	int minValY = infoRec->SolidLineLimits.y1;
-	int maxValY = infoRec->SolidLineLimits.y2;
-#ifdef POLYSEGMENT
-	int n = nseg;
-	xSegment *s = pSeg;
-
-	while (n--)
-#else
-	int n = npt;
-	int xorgtmp = xorg;
-	int yorgtmp = yorg;
-
-	ppt = pptInit;
-	x2 = ppt->x + xorgtmp;
-	y2 = ppt->y + yorgtmp;
-	while (--n)
-#endif
-	{
-#ifdef POLYSEGMENT
-	    x1 = s->x1 + xorg;
-	    y1 = s->y1 + yorg;
-	    x2 = s->x2 + xorg;
-	    y2 = s->y2 + yorg;
-	    s++;
-#else
-	    x1 = x2;
-	    y1 = y2;
-	    ++ppt;
-	    if (mode == CoordModePrevious) {
-		xorgtmp = x1;
-		yorgtmp = y1;
-	    }
-	    x2 = ppt->x + xorgtmp;
-	    y2 = ppt->y + yorgtmp;
-#endif
-	    if (x1 > maxValX || x1 < minValX ||
-		x2 > maxValX || x2 < minValX ||
-		y1 > maxValY || y1 < minValY ||
-		y2 > maxValY || y2 < minValY) {
-#ifdef POLYSEGMENT
-		XAAFallbackOps.PolySegment(pDrawable, pGC, nseg, pSeg);
-#else
-		XAAFallbackOps.Polylines(pDrawable, pGC, mode, npt, pptInit);
-#endif
-		return;
-	    }
-	}
-    }
-
-    (*infoRec->SetupForSolidLine)(infoRec->pScrn, pGC->fgPixel,
-					pGC->alu, pGC->planemask);
-
-#ifdef POLYSEGMENT
-    while (nseg--)
-#else
-    ppt = pptInit;
-    x2 = ppt->x + xorg;
-    y2 = ppt->y + yorg;
-    while(--npt)
-#endif
-    {
-	nbox = nboxInit;
-	pbox = pboxInit;
-
-#ifdef POLYSEGMENT
-	x1 = pSeg->x1 + xorg;	
-	y1 = pSeg->y1 + yorg;
-	x2 = pSeg->x2 + xorg;	
-	y2 = pSeg->y2 + yorg;
-	pSeg++;
-#else
-	x1 = x2; 
-	y1 = y2;
-	++ppt;
-	if (mode == CoordModePrevious) {
-	    xorg = x1; 
-	    yorg = y1;
-	}
-	x2 = ppt->x + xorg; 
-	y2 = ppt->y + yorg;
-#endif
-
-	if (x1 == x2) { /* vertical line */
-	    /* make the line go top to bottom of screen, keeping
-	       endpoint semantics
-	    */
-	    if (y1 > y2) {
-		tmp = y2; 
-		y2 = y1 + 1; 
-		y1 = tmp + 1;
-#ifdef POLYSEGMENT
-		if (pGC->capStyle != CapNotLast) y1--;
-#endif
-	    }
-#ifdef POLYSEGMENT
-	    else if (pGC->capStyle != CapNotLast) y2++;
-#endif
-	    /* get to first band that might contain part of line */
-	    while(nbox && (pbox->y2 <= y1)) {
-		pbox++;
-		nbox--;
-	    }
-
-	   /* stop when lower edge of box is beyond end of line */
-	    while(nbox && (y2 >= pbox->y1)) {
-		if ((x1 >= pbox->x1) && (x1 < pbox->x2)) {
-		    tmp = max(y1, pbox->y1);
-		    len = min(y2, pbox->y2) - tmp;
-		    if (len) (*infoRec->SubsequentSolidHorVertLine)(
-				infoRec->pScrn, x1, tmp, len, DEGREES_270);
-		}
-		nbox--;
-		pbox++;
-	    }
-#ifndef POLYSEGMENT
-	    y2 = ppt->y + yorg;
-#endif
-	} else if (y1 == y2) { /* horizontal line */
-	/* force line from left to right, keeping endpoint semantics */
-	    if (x1 > x2) {
-		tmp = x2; 
-		x2 = x1 + 1; 
-		x1 = tmp + 1;
-#ifdef POLYSEGMENT
-		if (pGC->capStyle != CapNotLast)  x1--;
-#endif
-	    }
-#ifdef POLYSEGMENT
-	    else if (pGC->capStyle != CapNotLast) x2++;
-#endif
-
-	    /* find the correct band */
-	    while(nbox && (pbox->y2 <= y1)) {
-		pbox++;
-		nbox--;
-	    }
-
-	    /* try to draw the line, if we haven't gone beyond it */
-	    if (nbox && (pbox->y1 <= y1)) {
-		int orig_y = pbox->y1;
-		/* when we leave this band, we're done */
-		while(nbox && (orig_y == pbox->y1)) {
-		    if (pbox->x2 <= x1) {
-			/* skip boxes until one might contain start point */
-			nbox--;
-			pbox++;
-			continue;
-		    }
-
-		    /* stop if left of box is beyond right of line */
-		    if (pbox->x1 >= x2) {
-			nbox = 0;
-			break;
-		    }
-
-		    tmp = max(x1, pbox->x1);
-		    len = min(x2, pbox->x2) - tmp;
-		    if (len) (*infoRec->SubsequentSolidHorVertLine)(
-				infoRec->pScrn, tmp, y1, len, DEGREES_0);
-		    nbox--;
-		    pbox++;
-		}
-	    }
-#ifndef POLYSEGMENT
-	    x2 = ppt->x + xorg;
-#endif
-	} else{ /* sloped line */
-	    unsigned int oc1, oc2;
-	    int dmin, dmaj, e, octant;
-
-	    if (infoRec->SubsequentSolidBresenhamLine) {
-	        if((dmaj = x2 - x1) < 0) {
-		   dmaj = -dmaj;
-		   octant = XDECREASING;
-		} else octant = 0;		   
-
-	        if((dmin = y2 - y1) < 0) {
-		   dmin = -dmin;
-		   octant |= YDECREASING;
-		}	
-	
-		if(dmin >= dmaj){
-		    tmp = dmin; dmin = dmaj; dmaj = tmp;
-		    octant |= YMAJOR;
-		}
-
-		e = -dmaj - ((bias >> octant) & 1);
-		len = dmaj;
-		dmin <<= 1;
-		dmaj <<= 1;
-	    } else {	/* Muffle compiler */
-		dmin = dmaj = e = octant = len = 0;
-	    }
-
-	    while(nbox--) {
-		oc1 = oc2 = 0;
-		OUTCODES(oc1, x1, y1, pbox);
-		OUTCODES(oc2, x2, y2, pbox);
-		if (!(oc1 | oc2)) {   /* unclipped */
-		    if(infoRec->SubsequentSolidTwoPointLine) {
-			(*infoRec->SubsequentSolidTwoPointLine)(
-				infoRec->pScrn, x1, y1, x2, y2, 
-#ifdef POLYSEGMENT
-			    	(pGC->capStyle != CapNotLast) ? 0 :
-#endif
-				OMIT_LAST
-			);
-		    } else {
-			(*infoRec->SubsequentSolidBresenhamLine)(
-				infoRec->pScrn, x1, y1, dmaj, dmin, e, 
-#ifdef POLYSEGMENT
-			    	(pGC->capStyle != CapNotLast) ? (len+1) :
-#endif
-			    	len, octant);
-		    }
-		    break;
-		} else if (oc1 & oc2) { /* completely clipped */
-		    pbox++;
-		} else if (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_LINE) {
-		    (*infoRec->SetClippingRectangle)(infoRec->pScrn,
-			pbox->x1, pbox->y1, pbox->x2 - 1, pbox->y2 - 1);
-
-		    if(infoRec->SubsequentSolidBresenhamLine) {
-			(*infoRec->SubsequentSolidBresenhamLine)(
-				infoRec->pScrn, x1, y1, dmaj, dmin, e, 
-#ifdef POLYSEGMENT
-			    	(pGC->capStyle != CapNotLast) ? (len+1) :
-#endif
-			    	len, octant);
-		    } else {
-			(*infoRec->SubsequentSolidTwoPointLine)(
-				infoRec->pScrn, x1, y1, x2, y2, 
-#ifdef POLYSEGMENT
-			    	(pGC->capStyle != CapNotLast) ? 0 :
-#endif
-				OMIT_LAST
-			);
-		    }
-		    (*infoRec->DisableClipping)(infoRec->pScrn);
-		    pbox++;
-		} else {
-		    int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
-		    int clip1 = 0, clip2 = 0;
-		    int err, adx, ady;
-		    
-		    if(octant & YMAJOR) {
-			ady = dmaj >> 1;
-			adx = dmin >> 1;
-		    } else {
-			ady = dmin >> 1;
-			adx = dmaj >> 1;
-		    }
-
-		    if (miZeroClipLine(pbox->x1, pbox->y1, 
-				       pbox->x2 - 1, pbox->y2 - 1,
-				       &new_x1, &new_y1, &new_x2, &new_y2,
-				       adx, ady, &clip1, &clip2,
-				       octant, bias, oc1, oc2) == -1)
-		    {
-			pbox++;
-			continue;
-		    }
-
-		    if (octant & YMAJOR)
-			len = abs(new_y2 - new_y1);
-		    else
-			len = abs(new_x2 - new_x1);
-#ifdef POLYSEGMENT
-		    if (clip2 != 0 || pGC->capStyle != CapNotLast)
-			len++;
-#else
-		    len += (clip2 != 0);
-#endif
-		    if (len) {
-		    	int abserr, clipdx, clipdy;
-			/* unwind bresenham error term to first point */
-			if (clip1) {
-			    clipdx = abs(new_x1 - x1);
-			    clipdy = abs(new_y1 - y1);
-
-			    if (octant & YMAJOR)
-				err = e + clipdy*dmin - clipdx*dmaj;
-			    else
-				err = e + clipdx*dmin - clipdy*dmaj;
-			} else
-			    err = e;
-
-#define range infoRec->SolidBresenhamLineErrorTermBits
-			abserr = abs(err);			    
-			while((abserr & range) || 
-			      (dmaj & range) ||
-			      (dmin & range)) {
-				dmin >>= 1;
-				dmaj >>= 1;
-				abserr >>= 1;
-				err /= 2;
-			}
-
-			(*infoRec->SubsequentSolidBresenhamLine)(
-				infoRec->pScrn, new_x1, new_y1,
-				dmaj, dmin, err, len, octant);
-		    }
-		    pbox++;
-		}
-	    } /* while (nbox--) */
-	} /* sloped line */
-    } /* while (nline--) */
-
-#ifndef POLYSEGMENT
-    /* paint the last point if the end style isn't CapNotLast.
-       (Assume that a projecting, butt, or round cap that is one
-        pixel wide is the same as the single pixel of the endpoint.)
-    */
-
-    if ((pGC->capStyle != CapNotLast) &&
-	((ppt->x + xorg != pptInit->x + pDrawable->x) ||
-	 (ppt->y + yorg != pptInit->y + pDrawable->y) ||
-	 (ppt == pptInit + 1)))
-    {
-	nbox = nboxInit;
-	pbox = pboxInit;
-	while (nbox--)
-	{
-	    if ((x2 >= pbox->x1) && (y2 >= pbox->y1) &&
-		(x2 <  pbox->x2) && (y2 <  pbox->y2))
-	    {
-		(*infoRec->SubsequentSolidHorVertLine)(
-			infoRec->pScrn, x2, y2, 1, DEGREES_0);
-		break;
-	    }
-	    else
-		pbox++;
-	}
-    }
-#endif
-
-    SET_SYNC_FLAG(infoRec);
-}
-
+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <stdlib.h>

+

+#include <X11/X.h>

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "miline.h"

+#include "xf86str.h"

+#include "xaa.h"

+#include "xaalocal.h"

+

+

+void

+#ifdef POLYSEGMENT

+XAAPolySegment(

+    DrawablePtr	pDrawable,

+    GCPtr	pGC,

+    int		nseg,

+    xSegment	*pSeg

+#else

+XAAPolyLines(

+    DrawablePtr pDrawable,

+    GCPtr	pGC,

+    int		mode,		/* Origin or Previous */

+    int		npt,		/* number of points */

+    DDXPointPtr pptInit

+#endif

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    BoxPtr pboxInit = RegionRects(pGC->pCompositeClip);

+    int nboxInit = RegionNumRects(pGC->pCompositeClip);

+    unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);

+    int xorg = pDrawable->x;

+    int yorg = pDrawable->y;

+    int nbox;

+    BoxPtr pbox;

+#ifndef POLYSEGMENT

+    DDXPointPtr ppt;

+#endif

+    int x1, x2, y1, y2, tmp, len;

+

+    if(!nboxInit)

+	return;

+

+    if (infoRec->SolidLineFlags & LINE_LIMIT_COORDS) {

+	int minValX = infoRec->SolidLineLimits.x1;

+	int maxValX = infoRec->SolidLineLimits.x2;

+	int minValY = infoRec->SolidLineLimits.y1;

+	int maxValY = infoRec->SolidLineLimits.y2;

+#ifdef POLYSEGMENT

+	int n = nseg;

+	xSegment *s = pSeg;

+

+	while (n--)

+#else

+	int n = npt;

+	int xorgtmp = xorg;

+	int yorgtmp = yorg;

+

+	ppt = pptInit;

+	x2 = ppt->x + xorgtmp;

+	y2 = ppt->y + yorgtmp;

+	while (--n)

+#endif

+	{

+#ifdef POLYSEGMENT

+	    x1 = s->x1 + xorg;

+	    y1 = s->y1 + yorg;

+	    x2 = s->x2 + xorg;

+	    y2 = s->y2 + yorg;

+	    s++;

+#else

+	    x1 = x2;

+	    y1 = y2;

+	    ++ppt;

+	    if (mode == CoordModePrevious) {

+		xorgtmp = x1;

+		yorgtmp = y1;

+	    }

+	    x2 = ppt->x + xorgtmp;

+	    y2 = ppt->y + yorgtmp;

+#endif

+	    if (x1 > maxValX || x1 < minValX ||

+		x2 > maxValX || x2 < minValX ||

+		y1 > maxValY || y1 < minValY ||

+		y2 > maxValY || y2 < minValY) {

+#ifdef POLYSEGMENT

+		XAAFallbackOps.PolySegment(pDrawable, pGC, nseg, pSeg);

+#else

+		XAAFallbackOps.Polylines(pDrawable, pGC, mode, npt, pptInit);

+#endif

+		return;

+	    }

+	}

+    }

+

+    (*infoRec->SetupForSolidLine)(infoRec->pScrn, pGC->fgPixel,

+					pGC->alu, pGC->planemask);

+

+#ifdef POLYSEGMENT

+    while (nseg--)

+#else

+    ppt = pptInit;

+    x2 = ppt->x + xorg;

+    y2 = ppt->y + yorg;

+    while(--npt)

+#endif

+    {

+	nbox = nboxInit;

+	pbox = pboxInit;

+

+#ifdef POLYSEGMENT

+	x1 = pSeg->x1 + xorg;	

+	y1 = pSeg->y1 + yorg;

+	x2 = pSeg->x2 + xorg;	

+	y2 = pSeg->y2 + yorg;

+	pSeg++;

+#else

+	x1 = x2; 

+	y1 = y2;

+	++ppt;

+	if (mode == CoordModePrevious) {

+	    xorg = x1; 

+	    yorg = y1;

+	}

+	x2 = ppt->x + xorg; 

+	y2 = ppt->y + yorg;

+#endif

+

+	if (x1 == x2) { /* vertical line */

+	    /* make the line go top to bottom of screen, keeping

+	       endpoint semantics

+	    */

+	    if (y1 > y2) {

+		tmp = y2; 

+		y2 = y1 + 1; 

+		y1 = tmp + 1;

+#ifdef POLYSEGMENT

+		if (pGC->capStyle != CapNotLast) y1--;

+#endif

+	    }

+#ifdef POLYSEGMENT

+	    else if (pGC->capStyle != CapNotLast) y2++;

+#endif

+	    /* get to first band that might contain part of line */

+	    while(nbox && (pbox->y2 <= y1)) {

+		pbox++;

+		nbox--;

+	    }

+

+	   /* stop when lower edge of box is beyond end of line */

+	    while(nbox && (y2 >= pbox->y1)) {

+		if ((x1 >= pbox->x1) && (x1 < pbox->x2)) {

+		    tmp = max(y1, pbox->y1);

+		    len = min(y2, pbox->y2) - tmp;

+		    if (len) (*infoRec->SubsequentSolidHorVertLine)(

+				infoRec->pScrn, x1, tmp, len, DEGREES_270);

+		}

+		nbox--;

+		pbox++;

+	    }

+#ifndef POLYSEGMENT

+	    y2 = ppt->y + yorg;

+#endif

+	} else if (y1 == y2) { /* horizontal line */

+	/* force line from left to right, keeping endpoint semantics */

+	    if (x1 > x2) {

+		tmp = x2; 

+		x2 = x1 + 1; 

+		x1 = tmp + 1;

+#ifdef POLYSEGMENT

+		if (pGC->capStyle != CapNotLast)  x1--;

+#endif

+	    }

+#ifdef POLYSEGMENT

+	    else if (pGC->capStyle != CapNotLast) x2++;

+#endif

+

+	    /* find the correct band */

+	    while(nbox && (pbox->y2 <= y1)) {

+		pbox++;

+		nbox--;

+	    }

+

+	    /* try to draw the line, if we haven't gone beyond it */

+	    if (nbox && (pbox->y1 <= y1)) {

+		int orig_y = pbox->y1;

+		/* when we leave this band, we're done */

+		while(nbox && (orig_y == pbox->y1)) {

+		    if (pbox->x2 <= x1) {

+			/* skip boxes until one might contain start point */

+			nbox--;

+			pbox++;

+			continue;

+		    }

+

+		    /* stop if left of box is beyond right of line */

+		    if (pbox->x1 >= x2) {

+			nbox = 0;

+			break;

+		    }

+

+		    tmp = max(x1, pbox->x1);

+		    len = min(x2, pbox->x2) - tmp;

+		    if (len) (*infoRec->SubsequentSolidHorVertLine)(

+				infoRec->pScrn, tmp, y1, len, DEGREES_0);

+		    nbox--;

+		    pbox++;

+		}

+	    }

+#ifndef POLYSEGMENT

+	    x2 = ppt->x + xorg;

+#endif

+	} else{ /* sloped line */

+	    unsigned int oc1, oc2;

+	    int dmin, dmaj, e, octant;

+

+	    if (infoRec->SubsequentSolidBresenhamLine) {

+	        if((dmaj = x2 - x1) < 0) {

+		   dmaj = -dmaj;

+		   octant = XDECREASING;

+		} else octant = 0;		   

+

+	        if((dmin = y2 - y1) < 0) {

+		   dmin = -dmin;

+		   octant |= YDECREASING;

+		}	

+	

+		if(dmin >= dmaj){

+		    tmp = dmin; dmin = dmaj; dmaj = tmp;

+		    octant |= YMAJOR;

+		}

+

+		e = -dmaj - ((bias >> octant) & 1);

+		len = dmaj;

+		dmin <<= 1;

+		dmaj <<= 1;

+	    } else {	/* Muffle compiler */

+		dmin = dmaj = e = octant = len = 0;

+	    }

+

+	    while(nbox--) {

+		oc1 = oc2 = 0;

+		OUTCODES(oc1, x1, y1, pbox);

+		OUTCODES(oc2, x2, y2, pbox);

+		if (!(oc1 | oc2)) {   /* unclipped */

+		    if(infoRec->SubsequentSolidTwoPointLine) {

+			(*infoRec->SubsequentSolidTwoPointLine)(

+				infoRec->pScrn, x1, y1, x2, y2, 

+#ifdef POLYSEGMENT

+			    	(pGC->capStyle != CapNotLast) ? 0 :

+#endif

+				OMIT_LAST

+			);

+		    } else {

+			(*infoRec->SubsequentSolidBresenhamLine)(

+				infoRec->pScrn, x1, y1, dmaj, dmin, e, 

+#ifdef POLYSEGMENT

+			    	(pGC->capStyle != CapNotLast) ? (len+1) :

+#endif

+			    	len, octant);

+		    }

+		    break;

+		} else if (oc1 & oc2) { /* completely clipped */

+		    pbox++;

+		} else if (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_LINE) {

+		    (*infoRec->SetClippingRectangle)(infoRec->pScrn,

+			pbox->x1, pbox->y1, pbox->x2 - 1, pbox->y2 - 1);

+

+		    if(infoRec->SubsequentSolidBresenhamLine) {

+			(*infoRec->SubsequentSolidBresenhamLine)(

+				infoRec->pScrn, x1, y1, dmaj, dmin, e, 

+#ifdef POLYSEGMENT

+			    	(pGC->capStyle != CapNotLast) ? (len+1) :

+#endif

+			    	len, octant);

+		    } else {

+			(*infoRec->SubsequentSolidTwoPointLine)(

+				infoRec->pScrn, x1, y1, x2, y2, 

+#ifdef POLYSEGMENT

+			    	(pGC->capStyle != CapNotLast) ? 0 :

+#endif

+				OMIT_LAST

+			);

+		    }

+		    (*infoRec->DisableClipping)(infoRec->pScrn);

+		    pbox++;

+		} else {

+		    int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;

+		    int clip1 = 0, clip2 = 0;

+		    int err, adx, ady;

+		    

+		    if(octant & YMAJOR) {

+			ady = dmaj >> 1;

+			adx = dmin >> 1;

+		    } else {

+			ady = dmin >> 1;

+			adx = dmaj >> 1;

+		    }

+

+		    if (miZeroClipLine(pbox->x1, pbox->y1, 

+				       pbox->x2 - 1, pbox->y2 - 1,

+				       &new_x1, &new_y1, &new_x2, &new_y2,

+				       adx, ady, &clip1, &clip2,

+				       octant, bias, oc1, oc2) == -1)

+		    {

+			pbox++;

+			continue;

+		    }

+

+		    if (octant & YMAJOR)

+			len = abs(new_y2 - new_y1);

+		    else

+			len = abs(new_x2 - new_x1);

+#ifdef POLYSEGMENT

+		    if (clip2 != 0 || pGC->capStyle != CapNotLast)

+			len++;

+#else

+		    len += (clip2 != 0);

+#endif

+		    if (len) {

+		    	int abserr, clipdx, clipdy;

+			/* unwind bresenham error term to first point */

+			if (clip1) {

+			    clipdx = abs(new_x1 - x1);

+			    clipdy = abs(new_y1 - y1);

+

+			    if (octant & YMAJOR)

+				err = e + clipdy*dmin - clipdx*dmaj;

+			    else

+				err = e + clipdx*dmin - clipdy*dmaj;

+			} else

+			    err = e;

+

+#define range infoRec->SolidBresenhamLineErrorTermBits

+			abserr = abs(err);			    

+			while((abserr & range) || 

+			      (dmaj & range) ||

+			      (dmin & range)) {

+				dmin >>= 1;

+				dmaj >>= 1;

+				abserr >>= 1;

+				err /= 2;

+			}

+

+			(*infoRec->SubsequentSolidBresenhamLine)(

+				infoRec->pScrn, new_x1, new_y1,

+				dmaj, dmin, err, len, octant);

+		    }

+		    pbox++;

+		}

+	    } /* while (nbox--) */

+	} /* sloped line */

+    } /* while (nline--) */

+

+#ifndef POLYSEGMENT

+    /* paint the last point if the end style isn't CapNotLast.

+       (Assume that a projecting, butt, or round cap that is one

+        pixel wide is the same as the single pixel of the endpoint.)

+    */

+

+    if ((pGC->capStyle != CapNotLast) &&

+	((ppt->x + xorg != pptInit->x + pDrawable->x) ||

+	 (ppt->y + yorg != pptInit->y + pDrawable->y) ||

+	 (ppt == pptInit + 1)))

+    {

+	nbox = nboxInit;

+	pbox = pboxInit;

+	while (nbox--)

+	{

+	    if ((x2 >= pbox->x1) && (y2 >= pbox->y1) &&

+		(x2 <  pbox->x2) && (y2 <  pbox->y2))

+	    {

+		(*infoRec->SubsequentSolidHorVertLine)(

+			infoRec->pScrn, x2, y2, 1, DEGREES_0);

+		break;

+	    }

+	    else

+		pbox++;

+	}

+    }

+#endif

+

+    SET_SYNC_FLAG(infoRec);

+}

+

diff --git a/xorg-server/hw/xfree86/xaa/xaaLineMisc.c b/xorg-server/hw/xfree86/xaa/xaaLineMisc.c
index 3e5330fd3..44048674e 100644
--- a/xorg-server/hw/xfree86/xaa/xaaLineMisc.c
+++ b/xorg-server/hw/xfree86/xaa/xaaLineMisc.c
@@ -74,8 +74,7 @@ XAAComputeDash(GCPtr pGC)
     int shift, value, direction;

     Bool set;

 

-    if(pGCPriv->DashPattern)

-	free(pGCPriv->DashPattern);

+    free(pGCPriv->DashPattern);

 

     pGCPriv->DashPattern = NULL;

     pGCPriv->DashLength = 0; 

diff --git a/xorg-server/hw/xfree86/xaa/xaaNonTEText.c b/xorg-server/hw/xfree86/xaa/xaaNonTEText.c
index eb798a82b..519bda0e7 100644
--- a/xorg-server/hw/xfree86/xaa/xaaNonTEText.c
+++ b/xorg-server/hw/xfree86/xaa/xaaNonTEText.c
@@ -82,7 +82,7 @@ XAAPolyText8NonTEColorExpansion(
  		infoRec->CharInfo);

     }

 

-    return (x + width);

+    return x + width;

 }

 

 

@@ -112,7 +112,7 @@ XAAPolyText16NonTEColorExpansion(
 		infoRec->CharInfo);

     }

 

-    return (x + width);

+    return x + width;

 }

 

 

@@ -128,7 +128,7 @@ XAAImageText8NonTEColorExpansion(
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

     unsigned long n;

 

-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+    if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

     (*pGC->font->get_glyphs)(pGC->font, (unsigned long)count, 

@@ -153,7 +153,7 @@ XAAImageText16NonTEColorExpansion(
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

     unsigned long n;

 

-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+    if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

     (*pGC->font->get_glyphs)(

@@ -188,7 +188,7 @@ XAAImageGlyphBltNonTEColorExpansion(
 ){

     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

 

-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+    if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

     ImageGlyphBltNonTEColorExpansion(

@@ -208,7 +208,7 @@ XAAPolyGlyphBltNonTEColorExpansion(
 ){

     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

 

-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+    if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

     PolyGlyphBltNonTEColorExpansion(

@@ -368,8 +368,8 @@ ImageGlyphBltNonTEColorExpansion(
     int skippix, skipglyph, width, n, i;

     int Left, Right, Top, Bottom;

     int LeftEdge, RightEdge, ytop, ybot;

-    int nbox = REGION_NUM_RECTS(cclip);

-    BoxPtr pbox = REGION_RECTS(cclip);

+    int nbox = RegionNumRects(cclip);

+    BoxPtr pbox = RegionRects(cclip);

     Bool AlreadySetup = FALSE;

 

     width = CollectCharacterInfo(infoRec->GlyphInfo, nglyph, ppci, font);

@@ -405,8 +405,8 @@ ImageGlyphBltNonTEColorExpansion(
 	nbox--; pbox++;

     }

  

-    nbox = REGION_NUM_RECTS(cclip);

-    pbox = REGION_RECTS(cclip);

+    nbox = RegionNumRects(cclip);

+    pbox = RegionRects(cclip);

 

     if(infoRec->WriteBitmap && (nglyph > 1) && 

 			((FONTMAXBOUNDS(font, rightSideBearing) - 

@@ -477,8 +477,8 @@ PolyGlyphBltNonTEColorExpansion(
     int skippix, skipglyph, width, n, i;

     int Left, Right, Top, Bottom;

     int LeftEdge, RightEdge;

-    int nbox = REGION_NUM_RECTS(cclip);

-    BoxPtr pbox = REGION_RECTS(cclip);

+    int nbox = RegionNumRects(cclip);

+    BoxPtr pbox = RegionRects(cclip);

 

     width = CollectCharacterInfo(infoRec->GlyphInfo, nglyph, ppci, font);

 

diff --git a/xorg-server/hw/xfree86/xaa/xaaOverlay.c b/xorg-server/hw/xfree86/xaa/xaaOverlay.c
index b7122a58f..176a2d891 100644
--- a/xorg-server/hw/xfree86/xaa/xaaOverlay.c
+++ b/xorg-server/hw/xfree86/xaa/xaaOverlay.c
@@ -54,23 +54,23 @@ XAACopyWindow8_32(
     	return;

     }

 

-    pwinRoot = WindowTable[pScreen->myNum];

+    pwinRoot = pScreen->root;

 

     if(doUnderlay)

 	freeReg = miOverlayCollectUnderlayRegions(pWin, &borderClip);

 

-    REGION_NULL(pScreen, &rgnDst);

+    RegionNull(&rgnDst);

 

     dx = ptOldOrg.x - pWin->drawable.x;

     dy = ptOldOrg.y - pWin->drawable.y;

-    REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);

-    REGION_INTERSECT(pScreen, &rgnDst, borderClip, prgnSrc);

+    RegionTranslate(prgnSrc, -dx, -dy);

+    RegionIntersect(&rgnDst, borderClip, prgnSrc);

 

-    pbox = REGION_RECTS(&rgnDst);

-    nbox = REGION_NUM_RECTS(&rgnDst);

+    pbox = RegionRects(&rgnDst);

+    nbox = RegionNumRects(&rgnDst);

     if(!nbox || 

       !(pptSrc = (DDXPointPtr )malloc(nbox * sizeof(DDXPointRec)))) {

-	REGION_UNINIT(pScreen, &rgnDst);

+	RegionUninit(&rgnDst);

 	return;

     }

     ppt = pptSrc;

@@ -88,9 +88,9 @@ XAACopyWindow8_32(
         		&(infoRec->ScratchGC), &rgnDst, pptSrc);

 

     free(pptSrc);

-    REGION_UNINIT(pScreen, &rgnDst);

+    RegionUninit(&rgnDst);

     if(freeReg) 

-	REGION_DESTROY(pScreen, borderClip);

+	RegionDestroy(borderClip);

 }

 

 static void

diff --git a/xorg-server/hw/xfree86/xaa/xaaOverlayDF.c b/xorg-server/hw/xfree86/xaa/xaaOverlayDF.c
index 4548935fd..309ec9fa4 100644
--- a/xorg-server/hw/xfree86/xaa/xaaOverlayDF.c
+++ b/xorg-server/hw/xfree86/xaa/xaaOverlayDF.c
@@ -151,8 +151,8 @@ typedef struct {
    int (*TiledFillChooser)(GCPtr);

 } XAAOverlayRec, *XAAOverlayPtr;

 

-static int XAAOverlayKeyIndex;

-static DevPrivateKey XAAOverlayKey = &XAAOverlayKeyIndex;

+static DevPrivateKeyRec XAAOverlayKeyRec;

+#define XAAOverlayKey (&XAAOverlayKeyRec)

 

 #define GET_OVERLAY_PRIV(pScreen) \

     (XAAOverlayPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAOverlayKey)

@@ -173,6 +173,9 @@ XAAInitDualFramebufferOverlay(
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

     XAAOverlayPtr pOverPriv;

 

+    if (!dixRegisterPrivateKey(&XAAOverlayKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+

     if(!(pOverPriv = malloc(sizeof(XAAOverlayRec))))

 	return FALSE;

 

@@ -324,7 +327,7 @@ XAAOverCopyWindow(
     RegionRec rgnDst;

     BoxPtr pbox;

     int i, nbox, dx, dy;

-    WindowPtr pRoot = WindowTable[pScreen->myNum];

+    WindowPtr pRoot = pScreen->root;

 

 

     if (!pScrn->vtSema || !infoRec->ScreenToScreenBitBlt) { 

@@ -341,18 +344,18 @@ XAAOverCopyWindow(
     infoRec->ScratchGC.alu = GXcopy;

     infoRec->ScratchGC.planemask = ~0;

 

-    REGION_NULL(pScreen, &rgnDst);

+    RegionNull(&rgnDst);

 

     dx = ptOldOrg.x - pWin->drawable.x;

     dy = ptOldOrg.y - pWin->drawable.y;

-    REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);

-    REGION_INTERSECT(pScreen, &rgnDst, &pWin->borderClip, prgnSrc);

+    RegionTranslate(prgnSrc, -dx, -dy);

+    RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);

 

-    nbox = REGION_NUM_RECTS(&rgnDst);

+    nbox = RegionNumRects(&rgnDst);

     if(nbox &&

 	(pptSrc = (DDXPointPtr )malloc(nbox * sizeof(DDXPointRec)))) {

 

-	pbox = REGION_RECTS(&rgnDst);

+	pbox = RegionRects(&rgnDst);

 	for (i = nbox, ppt = pptSrc; i--; ppt++, pbox++) {

 	    ppt->x = pbox->x1 + dx;

 	    ppt->y = pbox->y1 + dy;

@@ -371,18 +374,18 @@ XAAOverCopyWindow(
 	free(pptSrc);

     }

 

-    REGION_UNINIT(pScreen, &rgnDst);

+    RegionUninit(&rgnDst);

 

     if(pWin->drawable.depth == 8) {

-      REGION_NULL(pScreen, &rgnDst);

+      RegionNull(&rgnDst);

       miSegregateChildren(pWin, &rgnDst, pScrn->depth);

-      if(REGION_NOTEMPTY(pScreen, &rgnDst)) {

-	REGION_INTERSECT(pScreen, &rgnDst, &rgnDst, prgnSrc);

-	nbox = REGION_NUM_RECTS(&rgnDst);

+      if(RegionNotEmpty(&rgnDst)) {

+	RegionIntersect(&rgnDst, &rgnDst, prgnSrc);

+	nbox = RegionNumRects(&rgnDst);

 	if(nbox &&

 	  (pptSrc = (DDXPointPtr )malloc(nbox * sizeof(DDXPointRec)))){

 

-	    pbox = REGION_RECTS(&rgnDst);

+	    pbox = RegionRects(&rgnDst);

 	    for (i = nbox, ppt = pptSrc; i--; ppt++, pbox++) {

 		ppt->x = pbox->x1 + dx;

 		ppt->y = pbox->y1 + dy;

@@ -394,7 +397,7 @@ XAAOverCopyWindow(
 	    free(pptSrc);

 	}

       }

-      REGION_UNINIT(pScreen, &rgnDst);

+      RegionUninit(&rgnDst);

     }

 }

 

@@ -409,13 +412,13 @@ XAAOverWindowExposures(
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

 

     if((pWin->drawable.bitsPerPixel != 8) && infoRec->pScrn->vtSema) {

-	if(REGION_NUM_RECTS(pReg) && infoRec->FillSolidRects) {

+	if(RegionNumRects(pReg) && infoRec->FillSolidRects) {

 	    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pScreen);

 

 	    SWITCH_DEPTH(8);

 	    (*infoRec->FillSolidRects)(infoRec->pScrn, 

 		infoRec->pScrn->colorKey, GXcopy, ~0,

-			REGION_NUM_RECTS(pReg), REGION_RECTS(pReg));

+			RegionNumRects(pReg), RegionRects(pReg));

 	    miWindowExposures(pWin, pReg, pOtherReg);

 	    return;

 	} else if(infoRec->NeedToSync) {

diff --git a/xorg-server/hw/xfree86/xaa/xaaPCache.c b/xorg-server/hw/xfree86/xaa/xaaPCache.c
index 62726d539..ff3f9ef56 100644
--- a/xorg-server/hw/xfree86/xaa/xaaPCache.c
+++ b/xorg-server/hw/xfree86/xaa/xaaPCache.c
@@ -144,18 +144,12 @@ FreePixmapCachePrivate(XAAPixmapCachePrivatePtr pPriv)
 {

     if(!pPriv) return;

 

-    if(pPriv->Info512)

-	free(pPriv->Info512);

-    if(pPriv->Info256)

-	free(pPriv->Info256);

-    if(pPriv->Info128)

-	free(pPriv->Info128);

-    if(pPriv->InfoColor)

-	free(pPriv->InfoColor);

-    if(pPriv->InfoMono)

-	free(pPriv->InfoMono);

-    if(pPriv->InfoPartial)

-	free(pPriv->InfoPartial);

+    free(pPriv->Info512);

+    free(pPriv->Info256);

+    free(pPriv->Info128);

+    free(pPriv->InfoColor);

+    free(pPriv->InfoMono);

+    free(pPriv->InfoPartial);

      

     free(pPriv);

 }

@@ -639,8 +633,8 @@ XAAInitPixmapCache(
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];

    XAAInfoRecPtr infoRec = (XAAInfoRecPtr)data;

    XAAPixmapCachePrivatePtr pCachePriv;

-   BoxPtr pBox = REGION_RECTS(areas);

-   int nBox = REGION_NUM_RECTS(areas);

+   BoxPtr pBox = RegionRects(areas);

+   int nBox = RegionNumRects(areas);

    int Num512, Num256, Num128, NumPartial, NumColor, NumMono;

    int Target512, Target256;

    CacheLinkPtr List512, List256, List128, ListPartial, ListColor, ListMono;

diff --git a/xorg-server/hw/xfree86/xaa/xaaPict.c b/xorg-server/hw/xfree86/xaa/xaaPict.c
index b66291458..1ad75835b 100644
--- a/xorg-server/hw/xfree86/xaa/xaaPict.c
+++ b/xorg-server/hw/xfree86/xaa/xaaPict.c
@@ -215,7 +215,7 @@ XAADoComposite (
     BoxPtr pbox;

     int nbox, w, h;

 

-    if(!REGION_NUM_RECTS(pDst->pCompositeClip))

+    if(!RegionNumRects(pDst->pCompositeClip))

         return TRUE;

 

     if(!infoRec->pScrn->vtSema || !DRAWABLE_IS_ON_CARD(pDst->pDrawable))

@@ -273,8 +273,8 @@ XAADoComposite (
                                    width, height))

 		      return TRUE;

 		      

-	  	nbox = REGION_NUM_RECTS(&region);

-	  	pbox = REGION_RECTS(&region);   

+		nbox = RegionNumRects(&region);

+		pbox = RegionRects(&region);

 		

 	        if(!nbox)

 		    return TRUE;	

@@ -298,7 +298,7 @@ XAADoComposite (
 	   	}

 				  

 		/* WriteBitmap sets the Sync flag */		  

-	        REGION_UNINIT(pScreen, &region);

+	        RegionUninit(&region);

 		return TRUE;

 	  }

 

@@ -340,11 +340,11 @@ XAADoComposite (
                                    width, height))

 		return TRUE;

 

-	  nbox = REGION_NUM_RECTS(&region);

-	  pbox = REGION_RECTS(&region);   

+	  nbox = RegionNumRects(&region);

+	  pbox = RegionRects(&region);

 	     

 	  if(!nbox) {

-                REGION_UNINIT(pScreen, &region);

+                RegionUninit(&region);

 		return TRUE;

 	  }

 

@@ -355,7 +355,7 @@ XAADoComposite (
 			((PixmapPtr)(pMask->pDrawable))->devKind, 

 			w, h, flags))

 	  {

-                REGION_UNINIT(pScreen, &region);

+                RegionUninit(&region);

 		return FALSE;

 	  }

 

@@ -371,7 +371,7 @@ XAADoComposite (
 	   }

 

 	   SET_SYNC_FLAG(infoRec);

-	   REGION_UNINIT(pScreen, &region);

+	   RegionUninit(&region);

 	   return TRUE;

 	}

     } else {

@@ -409,11 +409,11 @@ XAADoComposite (
                                    width, height))

 		return TRUE;

 

-	nbox = REGION_NUM_RECTS(&region);

-	pbox = REGION_RECTS(&region);   

+	nbox = RegionNumRects(&region);

+	pbox = RegionRects(&region);

 	     

         if(!nbox) {

-             REGION_UNINIT(pScreen, &region);

+             RegionUninit(&region);

              return TRUE;

         }

 

@@ -423,7 +423,7 @@ XAADoComposite (
 			((PixmapPtr)(pSrc->pDrawable))->devKind, 

 			w, h, flags))

         {

-              REGION_UNINIT(pScreen, &region);

+              RegionUninit(&region);

               return FALSE;

         }

 

@@ -440,7 +440,7 @@ XAADoComposite (
 	 }

 

 	SET_SYNC_FLAG(infoRec);

-	REGION_UNINIT(pScreen, &region);

+	RegionUninit(&region);

 	return TRUE;

     }

 

@@ -476,16 +476,16 @@ XAACompositeSrcCopy (PicturePtr pSrc,
 				   width, height))

 	return;

 

-    nbox = REGION_NUM_RECTS(&region);

-    pbox = REGION_RECTS(&region);   

+    nbox = RegionNumRects(&region);

+    pbox = RegionRects(&region);

 

     if(!nbox) {

-	REGION_UNINIT(pScreen, &region);

+	RegionUninit(&region);

 	return;

     }

     pptSrc = malloc(sizeof(DDXPointRec) * nbox);

     if (!pptSrc) {

-	REGION_UNINIT(pScreen, &region);

+	RegionUninit(&region);

 	return;

     }

     xoff = xSrc - xDst;

@@ -502,7 +502,7 @@ XAACompositeSrcCopy (PicturePtr pSrc,
 		pptSrc);

 

     free(pptSrc);

-    REGION_UNINIT(pScreen, &region);

+    RegionUninit(&region);

     return;

 }

 

@@ -588,7 +588,7 @@ XAADoGlyphs (CARD8         op,
     ScreenPtr	pScreen = pDst->pDrawable->pScreen;

     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

 

-    if(!REGION_NUM_RECTS(pDst->pCompositeClip))

+    if(!RegionNumRects(pDst->pCompositeClip))

 	return TRUE;

 

     if(!infoRec->pScrn->vtSema || 

diff --git a/xorg-server/hw/xfree86/xaa/xaaRect.c b/xorg-server/hw/xfree86/xaa/xaaRect.c
index 0a7e174b7..988dbf608 100644
--- a/xorg-server/hw/xfree86/xaa/xaaRect.c
+++ b/xorg-server/hw/xfree86/xaa/xaaRect.c
@@ -1,136 +1,136 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-/*
-   Much of this file based on code by 
-	Harm Hanemaayer (H.Hanemaayer@inter.nl.net).
-*/
-
-
-void
-XAAPolyRectangleThinSolid(
-    DrawablePtr  pDrawable,
-    GCPtr        pGC,    
-    int	         nRectsInit,
-    xRectangle  *pRectsInit )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int         nClipRects;     /* number of clip rectangles */
-    BoxPtr      pClipRects;     /* points to the list of clip rects */
-    int         xOrigin;        /* Drawables x origin */
-    int         yOrigin;        /* Drawables x origin */
-    xRectangle *pRect;          /* list of rects */
-    int         nRects;         /* running count of number of rects */
-    int         origX1, origY1; /* original rectangle's U/L corner */
-    int         origX2, origY2; /* original rectangle's L/R corner */
-    int         clippedX1;      /* clipped rectangle's left x */
-    int         clippedY1;      /* clipped rectangle's top y */
-    int         clippedX2;      /* clipped rectangle's right x */
-    int         clippedY2;      /* clipped rectangle's bottom y */
-    int         clipXMin;       /* upper left corner of clip rect */
-    int         clipYMin;       /* upper left corner of clip rect */
-    int         clipXMax;       /* lower right corner of clip rect */
-    int         clipYMax;       /* lower right corner of clip rect */
-    int         width, height;  /* width and height of rect */
-
-    nClipRects = REGION_NUM_RECTS(pGC->pCompositeClip);
-    pClipRects = REGION_RECTS(pGC->pCompositeClip);
-
-    if(!nClipRects) return;
-
-    xOrigin = pDrawable->x;
-    yOrigin = pDrawable->y;
-
-
-    (*infoRec->SetupForSolidLine)(infoRec->pScrn, 
-			pGC->fgPixel, pGC->alu, pGC->planemask);
-
-
-    for ( ; nClipRects > 0; 
-	  nClipRects--, pClipRects++ )
-    {
-        clipYMin = pClipRects->y1;
-        clipYMax = pClipRects->y2 - 1;
-        clipXMin = pClipRects->x1;
-        clipXMax = pClipRects->x2 - 1;
-
-	for (pRect = pRectsInit, nRects = nRectsInit; 
-	     nRects > 0; 
-	     nRects--, pRect++ )
-        {
-	    /* translate rectangle data over to the drawable */
-            origX1 = pRect->x + xOrigin; 
-	    origY1 = pRect->y + yOrigin;
-            origX2 = origX1 + pRect->width; 
-	    origY2 = origY1 + pRect->height; 
-
-	    /* reject entire rectangle if completely outside clip rect */
-	    if ((origX1 > clipXMax) || (origX2 < clipXMin) ||
-		(origY1 > clipYMax) || (origY2 < clipYMin))
-	        continue;
-
-	    /* clip the rectangle */
-	    clippedX1 = max (origX1, clipXMin);
-	    clippedX2 = min (origX2, clipXMax);
-	    clippedY1 = max (origY1, clipYMin);
-	    clippedY2 = min (origY2, clipYMax);
-
-	    width = clippedX2 - clippedX1 + 1;
-
-	    if (origY1 >= clipYMin) {
-		(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,
-			clippedX1, clippedY1, width, DEGREES_0);
-
-		/* don't overwrite corner */
-		clippedY1++;
-	    }
-
-	    if ((origY2 <= clipYMax) && (origY1 != origY2)) {
-		(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,
-			clippedX1, clippedY2, width, DEGREES_0);
-
-		/* don't overwrite corner */
-		clippedY2--; 
-	    }
-
-	    if (clippedY2 < clippedY1) continue;
-
-	    height = clippedY2 - clippedY1 + 1;
-
-	    /* draw vertical edges using lines if not clipped out */
-            if (origX1 >= clipXMin) 
-		(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,
-			clippedX1, clippedY1, height, DEGREES_270);
-
-            if ((origX2 <= clipXMax) && (origX2 != origX1))
-		(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,
-			clippedX2, clippedY1, height, DEGREES_270);
-	}
-    }
-
-    SET_SYNC_FLAG(infoRec);
-} 
-
-
-
-
-
-
-
-
-
-
-
+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include <X11/X.h>

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "xf86str.h"

+#include "xaa.h"

+#include "xaalocal.h"

+

+/*

+   Much of this file based on code by 

+	Harm Hanemaayer (H.Hanemaayer@inter.nl.net).

+*/

+

+

+void

+XAAPolyRectangleThinSolid(

+    DrawablePtr  pDrawable,

+    GCPtr        pGC,    

+    int	         nRectsInit,

+    xRectangle  *pRectsInit )

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    int         nClipRects;     /* number of clip rectangles */

+    BoxPtr      pClipRects;     /* points to the list of clip rects */

+    int         xOrigin;        /* Drawables x origin */

+    int         yOrigin;        /* Drawables x origin */

+    xRectangle *pRect;          /* list of rects */

+    int         nRects;         /* running count of number of rects */

+    int         origX1, origY1; /* original rectangle's U/L corner */

+    int         origX2, origY2; /* original rectangle's L/R corner */

+    int         clippedX1;      /* clipped rectangle's left x */

+    int         clippedY1;      /* clipped rectangle's top y */

+    int         clippedX2;      /* clipped rectangle's right x */

+    int         clippedY2;      /* clipped rectangle's bottom y */

+    int         clipXMin;       /* upper left corner of clip rect */

+    int         clipYMin;       /* upper left corner of clip rect */

+    int         clipXMax;       /* lower right corner of clip rect */

+    int         clipYMax;       /* lower right corner of clip rect */

+    int         width, height;  /* width and height of rect */

+

+    nClipRects = RegionNumRects(pGC->pCompositeClip);

+    pClipRects = RegionRects(pGC->pCompositeClip);

+

+    if(!nClipRects) return;

+

+    xOrigin = pDrawable->x;

+    yOrigin = pDrawable->y;

+

+

+    (*infoRec->SetupForSolidLine)(infoRec->pScrn, 

+			pGC->fgPixel, pGC->alu, pGC->planemask);

+

+

+    for ( ; nClipRects > 0; 

+	  nClipRects--, pClipRects++ )

+    {

+        clipYMin = pClipRects->y1;

+        clipYMax = pClipRects->y2 - 1;

+        clipXMin = pClipRects->x1;

+        clipXMax = pClipRects->x2 - 1;

+

+	for (pRect = pRectsInit, nRects = nRectsInit; 

+	     nRects > 0; 

+	     nRects--, pRect++ )

+        {

+	    /* translate rectangle data over to the drawable */

+            origX1 = pRect->x + xOrigin; 

+	    origY1 = pRect->y + yOrigin;

+            origX2 = origX1 + pRect->width; 

+	    origY2 = origY1 + pRect->height; 

+

+	    /* reject entire rectangle if completely outside clip rect */

+	    if ((origX1 > clipXMax) || (origX2 < clipXMin) ||

+		(origY1 > clipYMax) || (origY2 < clipYMin))

+	        continue;

+

+	    /* clip the rectangle */

+	    clippedX1 = max (origX1, clipXMin);

+	    clippedX2 = min (origX2, clipXMax);

+	    clippedY1 = max (origY1, clipYMin);

+	    clippedY2 = min (origY2, clipYMax);

+

+	    width = clippedX2 - clippedX1 + 1;

+

+	    if (origY1 >= clipYMin) {

+		(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,

+			clippedX1, clippedY1, width, DEGREES_0);

+

+		/* don't overwrite corner */

+		clippedY1++;

+	    }

+

+	    if ((origY2 <= clipYMax) && (origY1 != origY2)) {

+		(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,

+			clippedX1, clippedY2, width, DEGREES_0);

+

+		/* don't overwrite corner */

+		clippedY2--; 

+	    }

+

+	    if (clippedY2 < clippedY1) continue;

+

+	    height = clippedY2 - clippedY1 + 1;

+

+	    /* draw vertical edges using lines if not clipped out */

+            if (origX1 >= clipXMin) 

+		(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,

+			clippedX1, clippedY1, height, DEGREES_270);

+

+            if ((origX2 <= clipXMax) && (origX2 != origX1))

+		(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,

+			clippedX2, clippedY1, height, DEGREES_270);

+	}

+    }

+

+    SET_SYNC_FLAG(infoRec);

+} 

+

+

+

+

+

+

+

+

+

+

+

diff --git a/xorg-server/hw/xfree86/xaa/xaaSpans.c b/xorg-server/hw/xfree86/xaa/xaaSpans.c
index 46d6d0740..1e6ef3a18 100644
--- a/xorg-server/hw/xfree86/xaa/xaaSpans.c
+++ b/xorg-server/hw/xfree86/xaa/xaaSpans.c
@@ -1,882 +1,882 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "mispans.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-
-static void XAARenderSolidSpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderColor8x8Spans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderMono8x8Spans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderCacheBltSpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderColorExpandSpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderCacheExpandSpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderPixmapCopySpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-
-void
-XAAFillSpans(
-    DrawablePtr pDraw,
-    GC		*pGC,
-    int		nInit,		/* number of spans to fill */
-    DDXPointPtr pptInit,	/* pointer to list of start points */
-    int *pwidthInit,		/* pointer to list of n widths */
-    int fSorted 
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int type = 0;
-    ClipAndRenderSpansFunc function;
-    Bool fastClip = FALSE;
-
-    if((nInit <= 0) || !pGC->planemask)
-        return;
-
-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))
-	return;
-
-    switch(pGC->fillStyle) {
-    case FillSolid:
-	type = DO_SOLID;
-	break;
-    case FillStippled:
-	type = (*infoRec->StippledFillChooser)(pGC);
-	break;
-    case FillOpaqueStippled:
-	if((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSpansSolid &&
-                CHECK_PLANEMASK(pGC,infoRec->FillSpansSolidFlags) &&
-                CHECK_ROP(pGC,infoRec->FillSpansSolidFlags) &&
-                CHECK_ROPSRC(pGC,infoRec->FillSpansSolidFlags) &&
-                CHECK_FG(pGC,infoRec->FillSpansSolidFlags))
-	    type = DO_SOLID;
-	else
-	    type = (*infoRec->OpaqueStippledFillChooser)(pGC);
-	break;
-    case FillTiled:
-	type = (*infoRec->TiledFillChooser)(pGC);
-	break;
-    }
-
-    switch(type) {
-    case DO_SOLID:
-	function = XAARenderSolidSpans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL) 
-		fastClip = TRUE; 
-	break;	
-    case DO_COLOR_8x8:
-	function = XAARenderColor8x8Spans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_COLOR_8x8_FILL) 
-		fastClip = TRUE; 
-	break;	
-    case DO_MONO_8x8:
-	function = XAARenderMono8x8Spans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_MONO_8x8_FILL) 
-		fastClip = TRUE; 
-	break;	
-    case DO_CACHE_BLT:
-	function = XAARenderCacheBltSpans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
-		fastClip = TRUE; 
-	break;	
-    case DO_COLOR_EXPAND:
-	function = XAARenderColorExpandSpans;	
-	break;	
-    case DO_CACHE_EXPAND:
-	function = XAARenderCacheExpandSpans;	
-	if(infoRec->ClippingFlags & 
-			HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND) 
-		fastClip = TRUE; 
-	break;	
-    case DO_PIXMAP_COPY:
-	function = XAARenderPixmapCopySpans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
-		fastClip = TRUE; 
-	break;	
-    case DO_IMAGE_WRITE:
-    default:
-	(*XAAFallbackOps.FillSpans)(pDraw, pGC, nInit, pptInit,
-				pwidthInit, fSorted);
-	return;
-    }
-
-
-    if((nInit < 10) || (REGION_NUM_RECTS(pGC->pCompositeClip) != 1))
-	fastClip = FALSE;
-
-    if(fastClip) {
-	infoRec->ClipBox = &pGC->pCompositeClip->extents;
-	(*function)(pGC, nInit, pptInit, pwidthInit, fSorted, 
-					pDraw->x, pDraw->y);
-	infoRec->ClipBox = NULL;
-    } else
-	XAAClipAndRenderSpans(pGC, pptInit, pwidthInit, nInit, fSorted,
-					function, pDraw->x, pDraw->y);
-}
-
-
-	/*********************\
-	|     Solid Spans     |
-	\*********************/
-
-
-static void
-XAARenderSolidSpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    (*infoRec->FillSolidSpans) (infoRec->pScrn, pGC->fgPixel, 
-		pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted);    
-}
-
-
-	/************************\
-	|     Mono 8x8 Spans     |
-	\************************/
-
-
-static void
-XAARenderMono8x8Spans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAAPixmapPtr pPriv;
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   case FillTiled:
-      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-      fg = pPriv->fg;  bg = pPriv->bg;
-      break;
-   default:	/* Muffle compiler */
-      pPriv = NULL;	/* Kaboom */
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   (*infoRec->FillMono8x8PatternSpans) (infoRec->pScrn, 
-                fg, bg, pGC->alu, pGC->planemask, 
-                n, ppt, pwidth, fSorted, pPriv->pattern0, pPriv->pattern1, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));	  
-}
-
-
-	/*************************\
-	|     Color 8x8 Spans     |
-	\*************************/
-
-
-static void
-XAARenderColor8x8Spans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAACacheInfoPtr pCache;
-   PixmapPtr pPix;
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      pPix = pGC->stipple;
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      pPix = pGC->stipple;
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   case FillTiled:
-      pPix = pGC->tile.pixmap;
-      fg = -1;  bg = -1;
-      break;
-   default:	/* Muffle compiler */
-      pPix = NULL;
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   pCache = (*infoRec->CacheColor8x8Pattern)(infoRec->pScrn, pPix, fg, bg);
-
-   (*infoRec->FillColor8x8PatternSpans) (infoRec->pScrn, 
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted, pCache,
-                (yorg + pGC->patOrg.x), (xorg + pGC->patOrg.y));
-}
-
-
-	/****************************\
-	|     Color Expand Spans     |
-	\****************************/
-
-
-static void
-XAARenderColorExpandSpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   default:	/* Muffle compiler */
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   (*infoRec->FillColorExpandSpans) (infoRec->pScrn, fg, bg,
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted,
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),
-                pGC->stipple); 
-
-}
-
-
-	/*************************\
-	|     Cache Blt Spans     |
-	\*************************/
-
-
-static void
-XAARenderCacheBltSpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAACacheInfoPtr pCache;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 
-					pGC->fgPixel, -1);
-      break;
-   case FillOpaqueStippled:
-      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 
-					pGC->fgPixel, pGC->bgPixel);
-      break;
-   case FillTiled:
-      pCache = (*infoRec->CacheTile)(infoRec->pScrn, pGC->tile.pixmap);
-      break;
-   default:	/* Muffle compiler */
-      pCache = NULL;
-      break;
-   }
-
-   (*infoRec->FillCacheBltSpans) (infoRec->pScrn, 
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted, pCache, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));
-
-}
-
-
-	/****************************\
-	|     Cache Expand Spans     |
-	\****************************/
-
-
-static void
-XAARenderCacheExpandSpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   default:	/* Muffle compiler */
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   (*infoRec->FillCacheExpandSpans) (infoRec->pScrn, fg, bg,
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted,
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),
-                pGC->stipple); 
-}
-
-
-	/***************************\
-	|     Pixmap Copy Spans     |
-	\***************************/
-
-
-static void
-XAARenderPixmapCopySpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);
-   XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-
-   pCache->x = pPriv->offscreenArea->box.x1;
-   pCache->y = pPriv->offscreenArea->box.y1;
-   pCache->w = pCache->orig_w = 
-		pPriv->offscreenArea->box.x2 - pCache->x;
-   pCache->h = pCache->orig_h = 
-		pPriv->offscreenArea->box.y2 - pCache->y;
-   pCache->trans_color = -1;
-
-   (*infoRec->FillCacheBltSpans) (infoRec->pScrn, 
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted, pCache, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));
-}
-
-
-
-
-
-	/****************\
-	|     Solid      |
-	\****************/
-
-
-void
-XAAFillSolidSpans(
-   ScrnInfoPtr pScrn,
-   int fg, int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted 
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SetupForSolidFill)(pScrn, fg, rop, planemask);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-    while(n--) {
-	if (*pwidth > 0)
-            (*infoRec->SubsequentSolidFillRect)(pScrn, ppt->x, ppt->y, 
-								*pwidth, 1);
-	ppt++; pwidth++;
-    }
-
-    if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-	/***************\
-	|   Mono 8x8    |
-	\***************/
-
-
-void
-XAAFillMono8x8PatternSpansScreenOrigin(
-   ScrnInfoPtr pScrn,
-   int fg, int bg, int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted,
-   int pattern0, int pattern1,
-   int xorigin, int yorigin 
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-
-    if(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {
-   	if(!(infoRec->Mono8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-				(infoRec->Mono8x8PatternFillFlags & 		
-				BIT_ORDER_IN_BYTE_MSBFIRST));
-	    xorg = patx; yorg = paty;
-        }
-    } else {
-	XAACacheInfoPtr pCache =
-		(*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);
-	patx = pCache->x;  paty = pCache->y;
-   	if(!(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    int slot = (yorg << 3) + xorg;
-	    patx += pCache->offsets[slot].x;
-	    paty += pCache->offsets[slot].y;
-	    xorg = patx;  yorg = paty;
-	}	
-    }
-
-    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,
-	fg, bg, rop, planemask);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 
-			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
-	ppt++; pwidth++;
-     }
-
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-     SET_SYNC_FLAG(infoRec);
-}
-
-
-void
-XAAFillMono8x8PatternSpans(
-   ScrnInfoPtr pScrn,
-   int fg, int bg, int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted,
-   int pattern0, int pattern1,
-   int xorigin, int yorigin 
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg, yorg, slot;
-    XAACacheInfoPtr pCache = NULL;
-
-
-    if(!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)){
-	pCache = (*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);
-	patx = pCache->x;  paty = pCache->y;
-    }
-
-    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,
-					fg, bg, rop, planemask);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-	xorg = (ppt->x - xorigin) & 0x07;
-	yorg = (ppt->y - yorigin) & 0x07;
-
-   	if(!(infoRec->Mono8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    if(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_BITS) {
-		patx = pattern0; paty = pattern1;
-		XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-				(infoRec->Mono8x8PatternFillFlags & 		
-				BIT_ORDER_IN_BYTE_MSBFIRST));
-		xorg = patx; yorg = paty;
-	    } else {
-		slot = (yorg << 3) + xorg;
-	    	xorg = patx + pCache->offsets[slot].x;
-	    	yorg = paty + pCache->offsets[slot].y;
-	    }
-        }
-
-        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 
-			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
-	ppt++; pwidth++;
-     }
-
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-     SET_SYNC_FLAG(infoRec);
-}
-
-
-
-	/****************\
-	|   Color 8x8    |
-	\****************/
-
-
-void
-XAAFillColor8x8PatternSpansScreenOrigin(
-   ScrnInfoPtr pScrn,
-   int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted,
-   XAACacheInfoPtr pCache,
-   int xorigin, int yorigin 
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pCache->x, paty = pCache->y;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-
-    if(!(infoRec->Color8x8PatternFillFlags & 
-					HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	int slot = (yorg << 3) + xorg;
-	paty += pCache->offsets[slot].y;
-	patx += pCache->offsets[slot].x;
-	xorg = patx;  yorg = paty;
-    }	
-
-    (*infoRec->SetupForColor8x8PatternFill)(pScrn, patx, paty,
-			 rop, planemask, pCache->trans_color);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 
-			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
-	ppt++; pwidth++;
-     }
- 
-    if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-     SET_SYNC_FLAG(infoRec);
-}
-
-
-void
-XAAFillColor8x8PatternSpans(
-   ScrnInfoPtr pScrn,
-   int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted,
-   XAACacheInfoPtr pCache,
-   int xorigin, int yorigin 
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int xorg, yorg, slot;
-
-    (*infoRec->SetupForColor8x8PatternFill)(pScrn, pCache->x, pCache->y,
-			 rop, planemask, pCache->trans_color);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-	xorg = (ppt->x - xorigin) & 0x07;
-	yorg = (ppt->y - yorigin) & 0x07;
-
-   	if(!(infoRec->Color8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    slot = (yorg << 3) + xorg;
-	    yorg = pCache->y + pCache->offsets[slot].y;
-	    xorg = pCache->x + pCache->offsets[slot].x;
-        }
-
-        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 
-			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
-	ppt++; pwidth++;
-     }
-
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-     SET_SYNC_FLAG(infoRec);
-}
-
-	/*****************\
-	|   Cache Blit    |
-	\*****************/
-
-
-void
-XAAFillCacheBltSpans(
-   ScrnInfoPtr pScrn,
-   int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth,
-   int fSorted,
-   XAACacheInfoPtr pCache,
-   int xorg, int yorg
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, w, phaseX, phaseY, blit_w;  
-
-    (*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, rop, planemask,
-		pCache->trans_color);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-	x = ppt->x;
-	w = *pwidth; 
-	phaseX = (x - xorg) % pCache->orig_w;
-	if(phaseX < 0) phaseX += pCache->orig_w;
-	phaseY = (ppt->y - yorg) % pCache->orig_h;
-	if(phaseY < 0) phaseY += pCache->orig_h;
-
-	while(1) {
-	    blit_w = pCache->w - phaseX;
-	    if(blit_w > w) blit_w = w;
-
-            (*infoRec->SubsequentScreenToScreenCopy)(pScrn, 
-		pCache->x + phaseX, pCache->y + phaseY,
-		x, ppt->y, blit_w, 1);
-
-	    w -= blit_w;
-	    if(!w) break;
-	    x += blit_w;
-	    phaseX = (phaseX + blit_w) % pCache->orig_w;
-	}
-	ppt++; pwidth++;
-     }
-
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-     SET_SYNC_FLAG(infoRec);
-}
-
-
-	/****************\
-	|  Cache Expand  |
-	\****************/
-
-
-void
-XAAFillCacheExpandSpans(
-   ScrnInfoPtr pScrn,
-   int fg, int bg, int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth,
-   int fSorted,
-   int xorg, int yorg,
-   PixmapPtr pPix
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, w, phaseX, phaseY, blit_w, cacheWidth;  
-    XAACacheInfoPtr pCache;
-
-    pCache = (*infoRec->CacheMonoStipple)(pScrn, pPix);
-
-    cacheWidth = (pCache->w * pScrn->bitsPerPixel) / 
-	infoRec->CacheColorExpandDensity;
-
-    (*infoRec->SetupForScreenToScreenColorExpandFill)(pScrn, fg, bg, rop, 
-							planemask);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-	x = ppt->x;
-	w = *pwidth; 
-	phaseX = (x - xorg) % pCache->orig_w;
-	if(phaseX < 0) phaseX += pCache->orig_w;
-	phaseY = (ppt->y - yorg) % pCache->orig_h;
-	if(phaseY < 0) phaseY += pCache->orig_h;
-
-	while(1) {
-	    blit_w = cacheWidth - phaseX;
-	    if(blit_w > w) blit_w = w;
-
-	    (*infoRec->SubsequentScreenToScreenColorExpandFill)(
-			pScrn, x, ppt->y, blit_w, 1,
-			pCache->x, pCache->y + phaseY, phaseX);
-
-	    w -= blit_w;
-	    if(!w) break;
-	    x += blit_w;
-	    phaseX = (phaseX + blit_w) % pCache->orig_w;
-	}
-	ppt++; pwidth++;
-     }
-
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-     SET_SYNC_FLAG(infoRec);
-}
-
-
-
-void
-XAAClipAndRenderSpans(
-    GCPtr pGC, 
-    DDXPointPtr	ppt,
-    int		*pwidth,
-    int		nspans,
-    int		fSorted,
-    ClipAndRenderSpansFunc func,
-    int 	xorg,
-    int		yorg
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    DDXPointPtr pptNew, pptBase;
-    int	*pwidthBase, *pwidthNew;
-    int	Right, numRects, MaxBoxes;
-
-    MaxBoxes = infoRec->PreAllocSize/(sizeof(DDXPointRec) + sizeof(int));
-    pptBase = (DDXPointRec*)infoRec->PreAllocMem;
-    pwidthBase = (int*)(&pptBase[MaxBoxes]);
-
-    pptNew = pptBase;
-    pwidthNew = pwidthBase;
-
-    numRects = REGION_NUM_RECTS(pGC->pCompositeClip);
-
-    if(numRects == 1) {
-        BoxPtr pextent = REGION_RECTS(pGC->pCompositeClip);
-	    
-	while(nspans--) {
-	    if ((pextent->y1 <= ppt->y) && (ppt->y < pextent->y2)) {
-		pptNew->x = max(pextent->x1, ppt->x);
-		Right = ppt->x + *pwidth; 
-		*pwidthNew = min(pextent->x2, Right) - pptNew->x;
-
-		if (*pwidthNew > 0) {
-		    pptNew->y = ppt->y;
-		    pptNew++;
-		    pwidthNew++;
-
-		    if(pptNew >= (pptBase + MaxBoxes)) {
-			(*func)(pGC, MaxBoxes, pptBase, pwidthBase, fSorted, 	
-								xorg, yorg);
-			pptNew = pptBase;
-			pwidthNew = pwidthBase;
-		    }
-		}
-	    }
-	    ppt++;
-	    pwidth++;
-	}
-    } else if (numRects) {
-	BoxPtr	pbox;
-	int nbox;
-
-	while(nspans--) {
-	    nbox = numRects;
-	    pbox = REGION_RECTS(pGC->pCompositeClip);
-
-	    /* find the first band */
-	    while(nbox && (pbox->y2 <= ppt->y)) {
-		pbox++;
-		nbox--;
-	    }
-
-	    if(nbox && (pbox->y1 <= ppt->y)) {
-		int orig_y = pbox->y1;
-		Right = ppt->x + *pwidth;
-		while(nbox && (orig_y == pbox->y1)) {
-		    if(pbox->x2 <= ppt->x) {
-			nbox--;
-			pbox++;
-			continue;
-		    }
-
-		    if(pbox->x1 >= Right) {
-			nbox = 0;
-			break;
-		    }
-
-		    pptNew->x = max(pbox->x1, ppt->x);
-		    *pwidthNew = min(pbox->x2, Right) - pptNew->x;
-		    if(*pwidthNew > 0) {
-			pptNew->y = ppt->y;
-			pptNew++;
-			pwidthNew++;
-
-			if(pptNew >= (pptBase + MaxBoxes)) {
-			    (*func)(pGC, MaxBoxes, pptBase, pwidthBase, 
-							fSorted, xorg, yorg);
-			    pptNew = pptBase;
-			    pwidthNew = pwidthBase;
-			}
-		    }
-		    pbox++;
-		    nbox--;
-		}
-	    }
-	    ppt++;
-	    pwidth++;
-	}
-    }
-
-    if(pptNew != pptBase)
-	(*func)(pGC, pptNew - pptBase, pptBase, pwidthBase, fSorted, 
-						xorg, yorg);
-}
+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include <X11/X.h>

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "xf86str.h"

+#include "mi.h"

+#include "mispans.h"

+#include "xaa.h"

+#include "xaalocal.h"

+

+

+static void XAARenderSolidSpans(

+	GCPtr, int, DDXPointPtr, int*, int, int, int);

+static void XAARenderColor8x8Spans(

+	GCPtr, int, DDXPointPtr, int*, int, int, int);

+static void XAARenderMono8x8Spans(

+	GCPtr, int, DDXPointPtr, int*, int, int, int);

+static void XAARenderCacheBltSpans(

+	GCPtr, int, DDXPointPtr, int*, int, int, int);

+static void XAARenderColorExpandSpans(

+	GCPtr, int, DDXPointPtr, int*, int, int, int);

+static void XAARenderCacheExpandSpans(

+	GCPtr, int, DDXPointPtr, int*, int, int, int);

+static void XAARenderPixmapCopySpans(

+	GCPtr, int, DDXPointPtr, int*, int, int, int);

+

+void

+XAAFillSpans(

+    DrawablePtr pDraw,

+    GC		*pGC,

+    int		nInit,		/* number of spans to fill */

+    DDXPointPtr pptInit,	/* pointer to list of start points */

+    int *pwidthInit,		/* pointer to list of n widths */

+    int fSorted 

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    int type = 0;

+    ClipAndRenderSpansFunc function;

+    Bool fastClip = FALSE;

+

+    if((nInit <= 0) || !pGC->planemask)

+        return;

+

+    if(!RegionNumRects(pGC->pCompositeClip))

+	return;

+

+    switch(pGC->fillStyle) {

+    case FillSolid:

+	type = DO_SOLID;

+	break;

+    case FillStippled:

+	type = (*infoRec->StippledFillChooser)(pGC);

+	break;

+    case FillOpaqueStippled:

+	if((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSpansSolid &&

+                CHECK_PLANEMASK(pGC,infoRec->FillSpansSolidFlags) &&

+                CHECK_ROP(pGC,infoRec->FillSpansSolidFlags) &&

+                CHECK_ROPSRC(pGC,infoRec->FillSpansSolidFlags) &&

+                CHECK_FG(pGC,infoRec->FillSpansSolidFlags))

+	    type = DO_SOLID;

+	else

+	    type = (*infoRec->OpaqueStippledFillChooser)(pGC);

+	break;

+    case FillTiled:

+	type = (*infoRec->TiledFillChooser)(pGC);

+	break;

+    }

+

+    switch(type) {

+    case DO_SOLID:

+	function = XAARenderSolidSpans;	

+	if(infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL) 

+		fastClip = TRUE; 

+	break;	

+    case DO_COLOR_8x8:

+	function = XAARenderColor8x8Spans;	

+	if(infoRec->ClippingFlags & HARDWARE_CLIP_COLOR_8x8_FILL) 

+		fastClip = TRUE; 

+	break;	

+    case DO_MONO_8x8:

+	function = XAARenderMono8x8Spans;	

+	if(infoRec->ClippingFlags & HARDWARE_CLIP_MONO_8x8_FILL) 

+		fastClip = TRUE; 

+	break;	

+    case DO_CACHE_BLT:

+	function = XAARenderCacheBltSpans;	

+	if(infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)

+		fastClip = TRUE; 

+	break;	

+    case DO_COLOR_EXPAND:

+	function = XAARenderColorExpandSpans;	

+	break;	

+    case DO_CACHE_EXPAND:

+	function = XAARenderCacheExpandSpans;	

+	if(infoRec->ClippingFlags & 

+			HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND) 

+		fastClip = TRUE; 

+	break;	

+    case DO_PIXMAP_COPY:

+	function = XAARenderPixmapCopySpans;	

+	if(infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)

+		fastClip = TRUE; 

+	break;	

+    case DO_IMAGE_WRITE:

+    default:

+	(*XAAFallbackOps.FillSpans)(pDraw, pGC, nInit, pptInit,

+				pwidthInit, fSorted);

+	return;

+    }

+

+

+    if((nInit < 10) || (RegionNumRects(pGC->pCompositeClip) != 1))

+	fastClip = FALSE;

+

+    if(fastClip) {

+	infoRec->ClipBox = &pGC->pCompositeClip->extents;

+	(*function)(pGC, nInit, pptInit, pwidthInit, fSorted, 

+					pDraw->x, pDraw->y);

+	infoRec->ClipBox = NULL;

+    } else

+	XAAClipAndRenderSpans(pGC, pptInit, pwidthInit, nInit, fSorted,

+					function, pDraw->x, pDraw->y);

+}

+

+

+	/*********************\

+	|     Solid Spans     |

+	\*********************/

+

+

+static void

+XAARenderSolidSpans(

+    GCPtr pGC,

+    int	n,

+    DDXPointPtr ppt,

+    int *pwidth,

+    int fSorted,

+    int xorg, int yorg 

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+

+    (*infoRec->FillSolidSpans) (infoRec->pScrn, pGC->fgPixel, 

+		pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted);    

+}

+

+

+	/************************\

+	|     Mono 8x8 Spans     |

+	\************************/

+

+

+static void

+XAARenderMono8x8Spans(

+    GCPtr pGC,

+    int	n,

+    DDXPointPtr ppt,

+    int *pwidth,

+    int fSorted,

+    int xorg, int yorg 

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   XAAPixmapPtr pPriv;

+   int fg, bg;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);

+      fg = pGC->fgPixel;  bg = -1;

+      break;

+   case FillOpaqueStippled:

+      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);

+      fg = pGC->fgPixel;  bg = pGC->bgPixel;

+      break;

+   case FillTiled:

+      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);

+      fg = pPriv->fg;  bg = pPriv->bg;

+      break;

+   default:	/* Muffle compiler */

+      pPriv = NULL;	/* Kaboom */

+      fg = -1;  bg = -1;

+      break;

+   }

+

+   (*infoRec->FillMono8x8PatternSpans) (infoRec->pScrn, 

+                fg, bg, pGC->alu, pGC->planemask, 

+                n, ppt, pwidth, fSorted, pPriv->pattern0, pPriv->pattern1, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));	  

+}

+

+

+	/*************************\

+	|     Color 8x8 Spans     |

+	\*************************/

+

+

+static void

+XAARenderColor8x8Spans(

+    GCPtr pGC,

+    int	n,

+    DDXPointPtr ppt,

+    int *pwidth,

+    int fSorted,

+    int xorg, int yorg 

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   XAACacheInfoPtr pCache;

+   PixmapPtr pPix;

+   int fg, bg;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      pPix = pGC->stipple;

+      fg = pGC->fgPixel;  bg = -1;

+      break;

+   case FillOpaqueStippled:

+      pPix = pGC->stipple;

+      fg = pGC->fgPixel;  bg = pGC->bgPixel;

+      break;

+   case FillTiled:

+      pPix = pGC->tile.pixmap;

+      fg = -1;  bg = -1;

+      break;

+   default:	/* Muffle compiler */

+      pPix = NULL;

+      fg = -1;  bg = -1;

+      break;

+   }

+

+   pCache = (*infoRec->CacheColor8x8Pattern)(infoRec->pScrn, pPix, fg, bg);

+

+   (*infoRec->FillColor8x8PatternSpans) (infoRec->pScrn, 

+                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted, pCache,

+                (yorg + pGC->patOrg.x), (xorg + pGC->patOrg.y));

+}

+

+

+	/****************************\

+	|     Color Expand Spans     |

+	\****************************/

+

+

+static void

+XAARenderColorExpandSpans(

+    GCPtr pGC,

+    int	n,

+    DDXPointPtr ppt,

+    int *pwidth,

+    int fSorted,

+    int xorg, int yorg 

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   int fg, bg;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      fg = pGC->fgPixel;  bg = -1;

+      break;

+   case FillOpaqueStippled:

+      fg = pGC->fgPixel;  bg = pGC->bgPixel;

+      break;

+   default:	/* Muffle compiler */

+      fg = -1;  bg = -1;

+      break;

+   }

+

+   (*infoRec->FillColorExpandSpans) (infoRec->pScrn, fg, bg,

+                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted,

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),

+                pGC->stipple); 

+

+}

+

+

+	/*************************\

+	|     Cache Blt Spans     |

+	\*************************/

+

+

+static void

+XAARenderCacheBltSpans(

+    GCPtr pGC,

+    int	n,

+    DDXPointPtr ppt,

+    int *pwidth,

+    int fSorted,

+    int xorg, int yorg 

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   XAACacheInfoPtr pCache;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 

+					pGC->fgPixel, -1);

+      break;

+   case FillOpaqueStippled:

+      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 

+					pGC->fgPixel, pGC->bgPixel);

+      break;

+   case FillTiled:

+      pCache = (*infoRec->CacheTile)(infoRec->pScrn, pGC->tile.pixmap);

+      break;

+   default:	/* Muffle compiler */

+      pCache = NULL;

+      break;

+   }

+

+   (*infoRec->FillCacheBltSpans) (infoRec->pScrn, 

+                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted, pCache, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));

+

+}

+

+

+	/****************************\

+	|     Cache Expand Spans     |

+	\****************************/

+

+

+static void

+XAARenderCacheExpandSpans(

+    GCPtr pGC,

+    int	n,

+    DDXPointPtr ppt,

+    int *pwidth,

+    int fSorted,

+    int xorg, int yorg 

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   int fg, bg;

+

+   switch(pGC->fillStyle) {

+   case FillStippled:

+      fg = pGC->fgPixel;  bg = -1;

+      break;

+   case FillOpaqueStippled:

+      fg = pGC->fgPixel;  bg = pGC->bgPixel;

+      break;

+   default:	/* Muffle compiler */

+      fg = -1;  bg = -1;

+      break;

+   }

+

+   (*infoRec->FillCacheExpandSpans) (infoRec->pScrn, fg, bg,

+                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted,

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),

+                pGC->stipple); 

+}

+

+

+	/***************************\

+	|     Pixmap Copy Spans     |

+	\***************************/

+

+

+static void

+XAARenderPixmapCopySpans(

+    GCPtr pGC,

+    int	n,

+    DDXPointPtr ppt,

+    int *pwidth,

+    int fSorted,

+    int xorg, int yorg 

+){

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+   XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);

+   XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);

+

+   pCache->x = pPriv->offscreenArea->box.x1;

+   pCache->y = pPriv->offscreenArea->box.y1;

+   pCache->w = pCache->orig_w = 

+		pPriv->offscreenArea->box.x2 - pCache->x;

+   pCache->h = pCache->orig_h = 

+		pPriv->offscreenArea->box.y2 - pCache->y;

+   pCache->trans_color = -1;

+

+   (*infoRec->FillCacheBltSpans) (infoRec->pScrn, 

+                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted, pCache, 

+                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));

+}

+

+

+

+

+

+	/****************\

+	|     Solid      |

+	\****************/

+

+

+void

+XAAFillSolidSpans(

+   ScrnInfoPtr pScrn,

+   int fg, int rop,

+   unsigned int planemask,

+   int n,

+   DDXPointPtr ppt,

+   int *pwidth, int fSorted 

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+

+    (*infoRec->SetupForSolidFill)(pScrn, fg, rop, planemask);

+

+    if(infoRec->ClipBox)

+	(*infoRec->SetClippingRectangle)(infoRec->pScrn,

+		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 

+		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);

+

+    while(n--) {

+	if (*pwidth > 0)

+            (*infoRec->SubsequentSolidFillRect)(pScrn, ppt->x, ppt->y, 

+								*pwidth, 1);

+	ppt++; pwidth++;

+    }

+

+    if(infoRec->ClipBox)

+	(*infoRec->DisableClipping)(infoRec->pScrn);

+

+    SET_SYNC_FLAG(infoRec);

+}

+

+	/***************\

+	|   Mono 8x8    |

+	\***************/

+

+

+void

+XAAFillMono8x8PatternSpansScreenOrigin(

+   ScrnInfoPtr pScrn,

+   int fg, int bg, int rop,

+   unsigned int planemask,

+   int n,

+   DDXPointPtr ppt,

+   int *pwidth, int fSorted,

+   int pattern0, int pattern1,

+   int xorigin, int yorigin 

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int patx = pattern0, paty = pattern1;

+    int xorg = (-xorigin) & 0x07;

+    int yorg = (-yorigin) & 0x07;

+

+

+    if(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {

+   	if(!(infoRec->Mono8x8PatternFillFlags & 		

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	    XAARotateMonoPattern(&patx, &paty, xorg, yorg,

+				(infoRec->Mono8x8PatternFillFlags & 		

+				BIT_ORDER_IN_BYTE_MSBFIRST));

+	    xorg = patx; yorg = paty;

+        }

+    } else {

+	XAACacheInfoPtr pCache =

+		(*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);

+	patx = pCache->x;  paty = pCache->y;

+   	if(!(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	    int slot = (yorg << 3) + xorg;

+	    patx += pCache->offsets[slot].x;

+	    paty += pCache->offsets[slot].y;

+	    xorg = patx;  yorg = paty;

+	}	

+    }

+

+    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,

+	fg, bg, rop, planemask);

+

+    if(infoRec->ClipBox)

+	(*infoRec->SetClippingRectangle)(infoRec->pScrn,

+		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 

+		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);

+

+     while(n--) {

+        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 

+			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);

+	ppt++; pwidth++;

+     }

+

+     if(infoRec->ClipBox)

+	(*infoRec->DisableClipping)(infoRec->pScrn);

+

+     SET_SYNC_FLAG(infoRec);

+}

+

+

+void

+XAAFillMono8x8PatternSpans(

+   ScrnInfoPtr pScrn,

+   int fg, int bg, int rop,

+   unsigned int planemask,

+   int n,

+   DDXPointPtr ppt,

+   int *pwidth, int fSorted,

+   int pattern0, int pattern1,

+   int xorigin, int yorigin 

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int patx = pattern0, paty = pattern1;

+    int xorg, yorg, slot;

+    XAACacheInfoPtr pCache = NULL;

+

+

+    if(!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)){

+	pCache = (*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);

+	patx = pCache->x;  paty = pCache->y;

+    }

+

+    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,

+					fg, bg, rop, planemask);

+

+    if(infoRec->ClipBox)

+	(*infoRec->SetClippingRectangle)(infoRec->pScrn,

+		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 

+		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);

+

+     while(n--) {

+	xorg = (ppt->x - xorigin) & 0x07;

+	yorg = (ppt->y - yorigin) & 0x07;

+

+   	if(!(infoRec->Mono8x8PatternFillFlags & 		

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	    if(infoRec->Mono8x8PatternFillFlags & 

+				HARDWARE_PATTERN_PROGRAMMED_BITS) {

+		patx = pattern0; paty = pattern1;

+		XAARotateMonoPattern(&patx, &paty, xorg, yorg,

+				(infoRec->Mono8x8PatternFillFlags & 		

+				BIT_ORDER_IN_BYTE_MSBFIRST));

+		xorg = patx; yorg = paty;

+	    } else {

+		slot = (yorg << 3) + xorg;

+	    	xorg = patx + pCache->offsets[slot].x;

+	    	yorg = paty + pCache->offsets[slot].y;

+	    }

+        }

+

+        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 

+			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);

+	ppt++; pwidth++;

+     }

+

+     if(infoRec->ClipBox)

+	(*infoRec->DisableClipping)(infoRec->pScrn);

+

+     SET_SYNC_FLAG(infoRec);

+}

+

+

+

+	/****************\

+	|   Color 8x8    |

+	\****************/

+

+

+void

+XAAFillColor8x8PatternSpansScreenOrigin(

+   ScrnInfoPtr pScrn,

+   int rop,

+   unsigned int planemask,

+   int n,

+   DDXPointPtr ppt,

+   int *pwidth, int fSorted,

+   XAACacheInfoPtr pCache,

+   int xorigin, int yorigin 

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int patx = pCache->x, paty = pCache->y;

+    int xorg = (-xorigin) & 0x07;

+    int yorg = (-yorigin) & 0x07;

+

+

+    if(!(infoRec->Color8x8PatternFillFlags & 

+					HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	int slot = (yorg << 3) + xorg;

+	paty += pCache->offsets[slot].y;

+	patx += pCache->offsets[slot].x;

+	xorg = patx;  yorg = paty;

+    }	

+

+    (*infoRec->SetupForColor8x8PatternFill)(pScrn, patx, paty,

+			 rop, planemask, pCache->trans_color);

+

+    if(infoRec->ClipBox)

+	(*infoRec->SetClippingRectangle)(infoRec->pScrn,

+		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 

+		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);

+

+     while(n--) {

+        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 

+			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);

+	ppt++; pwidth++;

+     }

+ 

+    if(infoRec->ClipBox)

+	(*infoRec->DisableClipping)(infoRec->pScrn);

+

+     SET_SYNC_FLAG(infoRec);

+}

+

+

+void

+XAAFillColor8x8PatternSpans(

+   ScrnInfoPtr pScrn,

+   int rop,

+   unsigned int planemask,

+   int n,

+   DDXPointPtr ppt,

+   int *pwidth, int fSorted,

+   XAACacheInfoPtr pCache,

+   int xorigin, int yorigin 

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int xorg, yorg, slot;

+

+    (*infoRec->SetupForColor8x8PatternFill)(pScrn, pCache->x, pCache->y,

+			 rop, planemask, pCache->trans_color);

+

+    if(infoRec->ClipBox)

+	(*infoRec->SetClippingRectangle)(infoRec->pScrn,

+		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 

+		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);

+

+     while(n--) {

+	xorg = (ppt->x - xorigin) & 0x07;

+	yorg = (ppt->y - yorigin) & 0x07;

+

+   	if(!(infoRec->Color8x8PatternFillFlags & 		

+				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

+	    slot = (yorg << 3) + xorg;

+	    yorg = pCache->y + pCache->offsets[slot].y;

+	    xorg = pCache->x + pCache->offsets[slot].x;

+        }

+

+        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 

+			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);

+	ppt++; pwidth++;

+     }

+

+     if(infoRec->ClipBox)

+	(*infoRec->DisableClipping)(infoRec->pScrn);

+

+     SET_SYNC_FLAG(infoRec);

+}

+

+	/*****************\

+	|   Cache Blit    |

+	\*****************/

+

+

+void

+XAAFillCacheBltSpans(

+   ScrnInfoPtr pScrn,

+   int rop,

+   unsigned int planemask,

+   int n,

+   DDXPointPtr ppt,

+   int *pwidth,

+   int fSorted,

+   XAACacheInfoPtr pCache,

+   int xorg, int yorg

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int x, w, phaseX, phaseY, blit_w;  

+

+    (*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, rop, planemask,

+		pCache->trans_color);

+

+    if(infoRec->ClipBox)

+	(*infoRec->SetClippingRectangle)(infoRec->pScrn,

+		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 

+		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);

+

+     while(n--) {

+	x = ppt->x;

+	w = *pwidth; 

+	phaseX = (x - xorg) % pCache->orig_w;

+	if(phaseX < 0) phaseX += pCache->orig_w;

+	phaseY = (ppt->y - yorg) % pCache->orig_h;

+	if(phaseY < 0) phaseY += pCache->orig_h;

+

+	while(1) {

+	    blit_w = pCache->w - phaseX;

+	    if(blit_w > w) blit_w = w;

+

+            (*infoRec->SubsequentScreenToScreenCopy)(pScrn, 

+		pCache->x + phaseX, pCache->y + phaseY,

+		x, ppt->y, blit_w, 1);

+

+	    w -= blit_w;

+	    if(!w) break;

+	    x += blit_w;

+	    phaseX = (phaseX + blit_w) % pCache->orig_w;

+	}

+	ppt++; pwidth++;

+     }

+

+     if(infoRec->ClipBox)

+	(*infoRec->DisableClipping)(infoRec->pScrn);

+

+     SET_SYNC_FLAG(infoRec);

+}

+

+

+	/****************\

+	|  Cache Expand  |

+	\****************/

+

+

+void

+XAAFillCacheExpandSpans(

+   ScrnInfoPtr pScrn,

+   int fg, int bg, int rop,

+   unsigned int planemask,

+   int n,

+   DDXPointPtr ppt,

+   int *pwidth,

+   int fSorted,

+   int xorg, int yorg,

+   PixmapPtr pPix

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+    int x, w, phaseX, phaseY, blit_w, cacheWidth;  

+    XAACacheInfoPtr pCache;

+

+    pCache = (*infoRec->CacheMonoStipple)(pScrn, pPix);

+

+    cacheWidth = (pCache->w * pScrn->bitsPerPixel) / 

+	infoRec->CacheColorExpandDensity;

+

+    (*infoRec->SetupForScreenToScreenColorExpandFill)(pScrn, fg, bg, rop, 

+							planemask);

+

+    if(infoRec->ClipBox)

+	(*infoRec->SetClippingRectangle)(infoRec->pScrn,

+		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 

+		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);

+

+     while(n--) {

+	x = ppt->x;

+	w = *pwidth; 

+	phaseX = (x - xorg) % pCache->orig_w;

+	if(phaseX < 0) phaseX += pCache->orig_w;

+	phaseY = (ppt->y - yorg) % pCache->orig_h;

+	if(phaseY < 0) phaseY += pCache->orig_h;

+

+	while(1) {

+	    blit_w = cacheWidth - phaseX;

+	    if(blit_w > w) blit_w = w;

+

+	    (*infoRec->SubsequentScreenToScreenColorExpandFill)(

+			pScrn, x, ppt->y, blit_w, 1,

+			pCache->x, pCache->y + phaseY, phaseX);

+

+	    w -= blit_w;

+	    if(!w) break;

+	    x += blit_w;

+	    phaseX = (phaseX + blit_w) % pCache->orig_w;

+	}

+	ppt++; pwidth++;

+     }

+

+     if(infoRec->ClipBox)

+	(*infoRec->DisableClipping)(infoRec->pScrn);

+

+     SET_SYNC_FLAG(infoRec);

+}

+

+

+

+void

+XAAClipAndRenderSpans(

+    GCPtr pGC, 

+    DDXPointPtr	ppt,

+    int		*pwidth,

+    int		nspans,

+    int		fSorted,

+    ClipAndRenderSpansFunc func,

+    int 	xorg,

+    int		yorg

+){

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    DDXPointPtr pptNew, pptBase;

+    int	*pwidthBase, *pwidthNew;

+    int	Right, numRects, MaxBoxes;

+

+    MaxBoxes = infoRec->PreAllocSize/(sizeof(DDXPointRec) + sizeof(int));

+    pptBase = (DDXPointRec*)infoRec->PreAllocMem;

+    pwidthBase = (int*)(&pptBase[MaxBoxes]);

+

+    pptNew = pptBase;

+    pwidthNew = pwidthBase;

+

+    numRects = RegionNumRects(pGC->pCompositeClip);

+

+    if(numRects == 1) {

+        BoxPtr pextent = RegionRects(pGC->pCompositeClip);

+	    

+	while(nspans--) {

+	    if ((pextent->y1 <= ppt->y) && (ppt->y < pextent->y2)) {

+		pptNew->x = max(pextent->x1, ppt->x);

+		Right = ppt->x + *pwidth; 

+		*pwidthNew = min(pextent->x2, Right) - pptNew->x;

+

+		if (*pwidthNew > 0) {

+		    pptNew->y = ppt->y;

+		    pptNew++;

+		    pwidthNew++;

+

+		    if(pptNew >= (pptBase + MaxBoxes)) {

+			(*func)(pGC, MaxBoxes, pptBase, pwidthBase, fSorted, 	

+								xorg, yorg);

+			pptNew = pptBase;

+			pwidthNew = pwidthBase;

+		    }

+		}

+	    }

+	    ppt++;

+	    pwidth++;

+	}

+    } else if (numRects) {

+	BoxPtr	pbox;

+	int nbox;

+

+	while(nspans--) {

+	    nbox = numRects;

+	    pbox = RegionRects(pGC->pCompositeClip);

+

+	    /* find the first band */

+	    while(nbox && (pbox->y2 <= ppt->y)) {

+		pbox++;

+		nbox--;

+	    }

+

+	    if(nbox && (pbox->y1 <= ppt->y)) {

+		int orig_y = pbox->y1;

+		Right = ppt->x + *pwidth;

+		while(nbox && (orig_y == pbox->y1)) {

+		    if(pbox->x2 <= ppt->x) {

+			nbox--;

+			pbox++;

+			continue;

+		    }

+

+		    if(pbox->x1 >= Right) {

+			nbox = 0;

+			break;

+		    }

+

+		    pptNew->x = max(pbox->x1, ppt->x);

+		    *pwidthNew = min(pbox->x2, Right) - pptNew->x;

+		    if(*pwidthNew > 0) {

+			pptNew->y = ppt->y;

+			pptNew++;

+			pwidthNew++;

+

+			if(pptNew >= (pptBase + MaxBoxes)) {

+			    (*func)(pGC, MaxBoxes, pptBase, pwidthBase, 

+							fSorted, xorg, yorg);

+			    pptNew = pptBase;

+			    pwidthNew = pwidthBase;

+			}

+		    }

+		    pbox++;

+		    nbox--;

+		}

+	    }

+	    ppt++;

+	    pwidth++;

+	}

+    }

+

+    if(pptNew != pptBase)

+	(*func)(pGC, pptNew - pptBase, pptBase, pwidthBase, fSorted, 

+						xorg, yorg);

+}

diff --git a/xorg-server/hw/xfree86/xaa/xaaStateChange.c b/xorg-server/hw/xfree86/xaa/xaaStateChange.c
index 9c98a32f2..4eb15125b 100644
--- a/xorg-server/hw/xfree86/xaa/xaaStateChange.c
+++ b/xorg-server/hw/xfree86/xaa/xaaStateChange.c
@@ -272,8 +272,8 @@ typedef struct _XAAStateWrapRec {
                                       int width, int height, int flags);

 } XAAStateWrapRec, *XAAStateWrapPtr;

 

-static int XAAStateKeyIndex;

-static DevPrivateKey XAAStateKey = &XAAStateKeyIndex;

+static DevPrivateKeyRec XAAStateKeyRec;

+#define XAAStateKey (&XAAStateKeyRec)

 

 /* Wrap functions start here */

 #define GET_STATEPRIV_GC(pGC)   XAAStateWrapPtr pStatePriv =\

@@ -1500,6 +1500,7 @@ XAAInitStateWrap(ScreenPtr pScreen, XAAInfoRecPtr infoRec)
    XAAStateWrapPtr pStatePriv;

    int i = 0;

    

+   if (!dixRegisterPrivateKey(&XAAStateKeyRec, PRIVATE_SCREEN, 0)) return FALSE;

    if(!(pStatePriv = malloc(sizeof(XAAStateWrapRec)))) return FALSE;

    dixSetPrivate(&pScreen->devPrivates, XAAStateKey, pStatePriv);

    pStatePriv->RestoreAccelState = infoRec->RestoreAccelState;

diff --git a/xorg-server/hw/xfree86/xaa/xaaTEText.c b/xorg-server/hw/xfree86/xaa/xaaTEText.c
index 1e28d3103..2cc5fc1e6 100644
--- a/xorg-server/hw/xfree86/xaa/xaaTEText.c
+++ b/xorg-server/hw/xfree86/xaa/xaaTEText.c
@@ -110,7 +110,7 @@ XAAImageText8TEColorExpansion(
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

     unsigned long n;

 

-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+    if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

     (*pGC->font->get_glyphs)(pGC->font, (unsigned long)count, 

@@ -134,7 +134,7 @@ XAAImageText16TEColorExpansion(
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

     unsigned long n;

 

-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+    if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

     (*pGC->font->get_glyphs)(

@@ -169,7 +169,7 @@ XAAImageGlyphBltTEColorExpansion(
 {

     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

 

-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+    if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

     XAAGlyphBltTEColorExpansion(

@@ -189,7 +189,7 @@ XAAPolyGlyphBltTEColorExpansion(
 {

     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

 

-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))

+    if(!RegionNumRects(pGC->pCompositeClip))

 	return;

 

     XAAGlyphBltTEColorExpansion(

@@ -229,8 +229,8 @@ XAAGlyphBltTEColorExpansion(
     int skippix, skipglyphs;

     int Left, Right, Top, Bottom;

     int LeftEdge, RightEdge, ytop, ybot;

-    int nbox = REGION_NUM_RECTS(cclip);

-    BoxPtr pbox = REGION_RECTS(cclip);

+    int nbox = RegionNumRects(cclip);

+    BoxPtr pbox = RegionRects(cclip);

     unsigned int **glyphs = NULL; 

     int glyphWidth = FONTMAXBOUNDS(font, characterWidth);

 

@@ -299,8 +299,7 @@ XAAGlyphBltTEColorExpansion(
 		skippix, ytop - Top, glyphs + skipglyphs, glyphWidth, 

 		fg, bg, rop, planemask);

 

-	    if (fallbackBits)

-		free(fallbackBits);

+	    free(fallbackBits);

 	}

 

 	nbox--; pbox++;

diff --git a/xorg-server/hw/xfree86/xaa/xaaWideLine.c b/xorg-server/hw/xfree86/xaa/xaaWideLine.c
index a684d6676..f73e04f17 100644
--- a/xorg-server/hw/xfree86/xaa/xaaWideLine.c
+++ b/xorg-server/hw/xfree86/xaa/xaaWideLine.c
@@ -1,921 +1,921 @@
-/*
-
-XAAPolylinesWideSolid does not maintain a span list and subsequently does
-not follow the "touch-each-pixel-once" rules for wide lines and arcs.
-This means it can only be used in the case where we have
-miSpansEasyRop(pGC->alu).  Since we clip spans on the fly, we
-limited usage of this function to one rect situations. This
-function is used only for solid lines. 
-
-  Adapted from miWideLine by Mark Vojkovich (mvojkovi@ucsd.edu)
-Original mi code written by Keith Packard.
-
-*/
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <math.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "windowstr.h"
-#include "gcstruct.h"
-#include "regionstr.h"
-#include "miwideline.h"
-#include "mi.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-#define DRAW_POINT(pScrn, x, y) \
-  if(hardClip) (*infoRec->SubsequentSolidFillRect)(pScrn, x, y, 1, 1); \
-  else XAAPointHelper(pScrn, x, y)
-
-#define FILL_RECT(pScrn, x, y, w, h) \
-  if(hardClip) (*infoRec->SubsequentSolidFillRect)(pScrn, x, y, w, h); \
-  else XAAFillRectHelper(pScrn, x, y, w, h)
-
-#define FILL_SPAN(pScrn, x, y, w) \
-  if(hardClip) (*infoRec->SubsequentSolidFillRect)(pScrn, x, y, w, 1); \
-  else XAASpanHelper(pScrn, x, y, w)
-
-
-#define CLIPSTEPEDGE(edgey,edge,edgeleft) \
-    if (ybase == edgey) { \
-	if (edgeleft) { \
-	    if (edge->x > xcl) \
-		xcl = edge->x; \
-	} else { \
-	    if (edge->x < xcr) \
-		xcr = edge->x; \
-	} \
-	edgey++; \
-	edge->x += edge->stepx; \
-	edge->e += edge->dx; \
-	if (edge->e > 0) { \
-	    edge->x += edge->signdx; \
-	    edge->e -= edge->dy; \
-	} \
-    }
-
-static void 
-XAAPointHelper(ScrnInfoPtr pScrn, int x, int y)
-{
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-   BoxPtr extents = infoRec->ClipBox;
-
-   if((x >= extents->x1) && (x < extents->x2) &&
-	(y >= extents->y1) && (y < extents->y2))
-	(*infoRec->SubsequentSolidFillRect)(pScrn, x, y, 1, 1);
-}
-
-static void 
-XAAFillRectHelper(ScrnInfoPtr pScrn, int x1, int y1, int dx, int dy)
-{
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-   BoxPtr extents = infoRec->ClipBox;
-   int x2 = x1 + dx;
-   int y2 = y1 + dy;
-	
-   if(x1 < extents->x1) x1 = extents->x1;
-   if(x2 >= extents->x2) x2 = extents->x2;
-   if((dx = x2 - x1)<1) return;
-   if(y1 < extents->y1) y1 = extents->y1;
-   if(y2 >= extents->y2) y2 = extents->y2;
-   if((dy = y2 - y1)<1) return;
-
-   (*infoRec->SubsequentSolidFillRect)(pScrn, x1, y1, dx, dy);
-}
-
-
-static void 
-XAASpanHelper(ScrnInfoPtr pScrn, int x1, int y, int width)
-{
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-   BoxPtr extents = infoRec->ClipBox;
-    int x2;
-
-    if((y < extents->y1) || (y >= extents->y2)) return;
-
-    x2 = x1 + width;
-    if(x1 < extents->x1) x1 = extents->x1;
-    if(x2 > extents->x2) x2 = extents->x2;
-    width = x2 - x1;	
-
-    if(width > 0)	
- 	(*infoRec->SubsequentSolidFillRect)(pScrn, x1, y, width, 1);
-
-}
-
-#define FixError(x, dx, dy, e, sign, step, h)	{	\
-	   e += (h) * dx;				\
-	   x += (h) * step;				\
-	   if(e > 0) {					\
-		x += e * sign/dy;			\
-		e %= dy;				\
-	   	if(e) {					\
-		   x += sign;				\
-		   e -= dy;				\
-		}					\
-	   } 	 					\
-}
-
-
-static void
-XAAFillPolyHelper (
-    GCPtr	pGC,
-    int		y,			/* start y coordinate */
-    int		overall_height,		/* height of entire segment */
-    PolyEdgePtr	left, PolyEdgePtr right,
-    int	left_count, int right_count )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    BoxPtr extents = infoRec->ClipBox;
-    int left_x, left_e, left_stepx, left_signdx, left_dy, left_dx;
-    int right_x, right_e, right_stepx, right_signdx, right_dy, right_dx;
-    int	height, left_height, right_height;
-    int	xorg;
-    Bool hardClip;
-
-    if((y >= extents->y2) || ((y + overall_height) <= extents->y1))
-	return;
-
-    /* Muffle compiler */
-    left_x = left_e = left_stepx = left_signdx = left_dy = left_dx = 0;
-    right_x = right_e = right_stepx = right_signdx = right_dy = right_dx = 0;
-
-    left_height = right_height = 0;
-    xorg = 0;
-
-    hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-    
-    while ((left_count || left_height) && (right_count || right_height)) {
-  	if (!left_height && left_count) { 
-	    left_height = left->height; 
-	    left_x = left->x + xorg; 
-	    left_stepx = left->stepx; 
-	    left_signdx = left->signdx; 
-	    left_e = left->e; 
-	    left_dy = left->dy; 
-	    left_dx = left->dx; 
-	    left_count--; 
-	    left++;
-	}
-	if (!right_height && right_count) { 
-	    right_height = right->height; 
-	    right_x = right->x + xorg + 1; 
-	    right_stepx = right->stepx; 
-	    right_signdx = right->signdx; 
-	    right_e = right->e; 
-	    right_dy = right->dy; 
-	    right_dx = right->dx; 
-	    right_count--; 
-	    right++; 
-	}
-
-	height = (left_height > right_height) ? right_height : left_height;
-
-	left_height -= height;
-	right_height -= height;
-
-	if(hardClip && infoRec->SubsequentSolidFillTrap && (height > 6)) {
-	    int right_DX, left_DX;
-
-    	    right_DX = (right_dx * right_signdx) + (right_stepx * right_dy);
-	    left_DX = (left_dx * left_signdx) + (left_stepx * left_dy);
-
-	    (*infoRec->SubsequentSolidFillTrap)(infoRec->pScrn, y, height, 
-			left_x, left_DX, left_dy, left_e, 
-			right_x - 1, right_DX, right_dy, right_e);
-
-	    FixError(left_x, left_dx, left_dy, left_e, left_signdx, 
-			left_stepx, height);
-	    FixError(right_x, right_dx, right_dy, right_e, right_signdx,
-			right_stepx, height);
-	    y += height;
-	    continue;
-	}
-
-	while (height--) {
-	    if(right_x > left_x) {
-		FILL_SPAN(infoRec->pScrn, left_x, y, right_x - left_x);
-	    }
-    	    y++;
-    	
- 	    left_x += left_stepx; 
-	    left_e += left_dx; 
-	    if (left_e > 0) { 
-		left_x += left_signdx; 
-		left_e -= left_dy; 
-	    }
-	    right_x += right_stepx; 
-	    right_e += right_dx; 
-	    if (right_e > 0) { 
-		right_x += right_signdx; 
-		right_e -= right_dy; 
-	    }
-
-	}
-    }
-}
-
-
-
-static void
-XAAWideSegment (
-    GCPtr pGC,
-    int  x1, int y1, int x2, int y2,
-    Bool projectLeft, Bool projectRight,
-    LineFacePtr leftFace, LineFacePtr rightFace )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    double	l, L, r;
-    double	xa, ya;
-    double	projectXoff, projectYoff;
-    double	k;
-    double	maxy;
-    int		x, y;
-    int		dx, dy;
-    int		finaly;
-    PolyEdgePtr left, right;
-    PolyEdgePtr	top, bottom;
-    int		lefty, righty, topy, bottomy;
-    int		signdx;
-    PolyEdgeRec	lefts[2], rights[2];
-    LineFacePtr	tface;
-    int		lw = pGC->lineWidth;
-    Bool	hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-
-    /* draw top-to-bottom always */
-    if ((y2 < y1) || ((y2 == y1) && (x2 < x1))) {
-	x = x1;
-	x1 = x2;
-	x2 = x;
-
-	y = y1;
-	y1 = y2;
-	y2 = y;
-
-	x = projectLeft;
-	projectLeft = projectRight;
-	projectRight = x;
-
-	tface = leftFace;
-	leftFace = rightFace;
-	rightFace = tface;
-    }
-
-    dy = y2 - y1;
-    signdx = 1;
-    dx = x2 - x1;
-    if (dx < 0)
-	signdx = -1;
-
-    leftFace->x = x1;
-    leftFace->y = y1;
-    leftFace->dx = dx;
-    leftFace->dy = dy;
-
-    rightFace->x = x2;
-    rightFace->y = y2;
-    rightFace->dx = -dx;
-    rightFace->dy = -dy;
-
-    if (!dy) {
-	rightFace->xa = 0;
-	rightFace->ya = (double) lw / 2.0;
-	rightFace->k = -(double) (lw * dx) / 2.0;
-	leftFace->xa = 0;
-	leftFace->ya = -rightFace->ya;
-	leftFace->k = rightFace->k;
-	x = x1;
-	if (projectLeft)
-	    x -= (lw >> 1);
-	y = y1 - (lw >> 1);
-	dx = x2 - x;
-	if (projectRight)
-	    dx += ((lw + 1) >> 1);
-	dy = lw;
-	FILL_RECT(infoRec->pScrn, x, y, dx, dy);	
-    } else if (!dx) {
-	leftFace->xa =  (double) lw / 2.0;
-	leftFace->ya = 0;
-	leftFace->k = (double) (lw * dy) / 2.0;
-	rightFace->xa = -leftFace->xa;
-	rightFace->ya = 0;
-	rightFace->k = leftFace->k;
-	y = y1;
-	if (projectLeft)
-	    y -= lw >> 1;
-	x = x1 - (lw >> 1);
-	dy = y2 - y;
-	if (projectRight)
-	    dy += ((lw + 1) >> 1);
-	dx = lw;
- 	FILL_RECT(infoRec->pScrn, x, y, dx, dy);
-    } else {
-    	l = ((double) lw) / 2.0;
-    	L = sqrt((double)(dx*dx + dy*dy));
-
-	if (dx < 0) {
-	    right = &rights[1];
-	    left = &lefts[0];
-	    top = &rights[0];
-	    bottom = &lefts[1];
-	} else {
-	    right = &rights[0];
-	    left = &lefts[1];
-	    top = &lefts[0];
-	    bottom = &rights[1];
-	}
-	r = l / L;
-
-	/* coord of upper bound at integral y */
-	ya = -r * dx;
-	xa = r * dy;
-
-	projectXoff = -ya;
-	projectYoff = xa;
-
-    	/* xa * dy - ya * dx */
-	k = l * L;
-
-	leftFace->xa = xa;
-	leftFace->ya = ya;
-	leftFace->k = k;
-	rightFace->xa = -xa;
-	rightFace->ya = -ya;
-	rightFace->k = k;
-
-	if (projectLeft)
-	    righty = miPolyBuildEdge (xa - projectXoff, ya - projectYoff,
-				      k, dx, dy, x1, y1, 0, right);
-	else
-	    righty = miPolyBuildEdge (xa, ya,
-				      k, dx, dy, x1, y1, 0, right);
-
-	/* coord of lower bound at integral y */
-	ya = -ya;
-	xa = -xa;
-
-	/* xa * dy - ya * dx */
-	k = - k;
-
-	if (projectLeft)
-	    lefty = miPolyBuildEdge (xa - projectXoff, ya - projectYoff,
-				     k, dx, dy, x1, y1, 1, left);
-	else
-	    lefty = miPolyBuildEdge (xa, ya,
-				     k, dx, dy, x1, y1, 1, left);
-
-	/* coord of top face at integral y */
-
-	if (signdx > 0) {
-	    ya = -ya;
-	    xa = -xa;
-	}
-
-	if (projectLeft) {
-	    double xap = xa - projectXoff;
-	    double yap = ya - projectYoff;
-	    topy = miPolyBuildEdge (xap, yap, xap * dx + yap * dy,
-				    -dy, dx, x1, y1, dx > 0, top);
-	}
-	else
-	    topy = miPolyBuildEdge(xa, ya, 0.0, 
-					-dy, dx, x1, y1, dx > 0, top);
-
-		/* coord of bottom face at integral y */
-
-	if (projectRight) {
-	    double xap = xa + projectXoff;
-	    double yap = ya + projectYoff;
-	    bottomy = miPolyBuildEdge (xap, yap, xap * dx + yap * dy,
-				       -dy, dx, x2, y2, dx < 0, bottom);
-	    maxy = -ya + projectYoff;
-	} else {
-	    bottomy = miPolyBuildEdge (xa, ya, 0.0,
-					-dy, dx, x2, y2, dx < 0, bottom);
-	    maxy = -ya;
-	}
-
-	finaly = ICEIL (maxy) + y2;
-
-	if (dx < 0) {
-	    left->height = bottomy - lefty;
-	    right->height = finaly - righty;
-	    top->height = righty - topy;
-	} else {
-	    right->height =  bottomy - righty;
-	    left->height = finaly - lefty;
-	    top->height = lefty - topy;
-	}
-	bottom->height = finaly - bottomy;
-	XAAFillPolyHelper (pGC, topy, 
-		bottom->height + bottomy - topy, lefts, rights, 2, 2);
-    }
-}
-
-
-static void
-XAALineArcI (GCPtr pGC, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int x, y, e, ex;
-    int slw = pGC->lineWidth;
-    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-
-    y = (slw >> 1) + 1;
-    if (slw & 1)
-	e = - ((y << 2) + 3);
-    else
-	e = - (y << 3);
-    ex = -4;
-    x = 0;
-    while (y) {
-	e += (y << 3) - 4;
-	while (e >= 0) {
-	    x++;
-	    e += (ex = -((x << 3) + 4));
-	}
-	y--;
-	slw = (x << 1) + 1;
-	if ((e == ex) && (slw > 1))
-	    slw--;
-	    
-	FILL_SPAN(infoRec->pScrn, xorg - x, yorg - y, slw);
-
-	if ((y != 0) && ((slw > 1) || (e != ex))) {	
-	    FILL_SPAN(infoRec->pScrn, xorg - x, yorg + y, slw);
-	}
-    }
-}
-
-
-static void
-XAALineArcD (
-    GCPtr	    pGC,
-    double	    xorg,
-    double	    yorg,
-    PolyEdgePtr	    edge1, 
-    int		    edgey1,
-    Bool	    edgeleft1,
-    PolyEdgePtr	    edge2,
-    int		    edgey2,
-    Bool	    edgeleft2 )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    double radius, x0, y0, el, er, yk, xlk, xrk, k;
-    int xbase, ybase, y, boty, xl, xr, xcl, xcr;
-    int ymin, ymax;
-    Bool edge1IsMin, edge2IsMin;
-    int ymin1, ymin2;
-    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-
-
-    xbase = floor(xorg);
-    x0 = xorg - xbase;
-    ybase = ICEIL (yorg);
-    y0 = yorg - ybase;
-
-    xlk = x0 + x0 + 1.0;
-    xrk = x0 + x0 - 1.0;
-    yk = y0 + y0 - 1.0;
-    radius = ((double)pGC->lineWidth) / 2.0;
-    y = floor(radius - y0 + 1.0);
-    ybase -= y;
-    ymin = ybase;
-    ymax = 65536;
-    edge1IsMin = FALSE;
-    ymin1 = edgey1;
-    if (edge1->dy >= 0) {
-    	if (!edge1->dy) {
-	    if (edgeleft1)
-	    	edge1IsMin = TRUE;
-	    else
-	    	ymax = edgey1;
-	    edgey1 = 65536;
-    	} else if ((edge1->signdx < 0) == edgeleft1)
-	    	edge1IsMin = TRUE;
-    }
-    edge2IsMin = FALSE;
-    ymin2 = edgey2;
-    if (edge2->dy >= 0) {
-    	if (!edge2->dy) {
-	    if (edgeleft2)
-	    	edge2IsMin = TRUE;
-	    else
-	    	ymax = edgey2;
-	    edgey2 = 65536;
-    	} else if ((edge2->signdx < 0) == edgeleft2)
-	    	edge2IsMin = TRUE;
-    }
-    if (edge1IsMin) {
-	ymin = ymin1;
-	if (edge2IsMin && (ymin1 > ymin2))
-	    ymin = ymin2;
-    } else if (edge2IsMin)
-	ymin = ymin2;
-    el = radius * radius - ((y + y0) * (y + y0)) - (x0 * x0);
-    er = el + xrk;
-    xl = 1;
-    xr = 0;
-    if (x0 < 0.5) {
-	xl = 0;
-	el -= xlk;
-    }
-    boty = (y0 < -0.5) ? 1 : 0;
-    if (ybase + y - boty > ymax)
-	boty = ymax - ybase - y;
-    while (y > boty) {
-	k = (y << 1) + yk;
-	er += k;
-	while (er > 0.0) {
-	    xr++;
-	    er += xrk - (xr << 1);
-	}
-	el += k;
-	while (el >= 0.0) {
-	    xl--;
-	    el += (xl << 1) - xlk;
-	}
-	y--;
-	ybase++;
-	if (ybase < ymin)
-	    continue;
-	xcl = xl + xbase;
-	xcr = xr + xbase;
-	CLIPSTEPEDGE(edgey1, edge1, edgeleft1);
-	CLIPSTEPEDGE(edgey2, edge2, edgeleft2);
-	if(xcr >= xcl) {
-	    FILL_SPAN(infoRec->pScrn, xcl, ybase, xcr - xcl + 1);
-	}
-    }
-    er = xrk - (xr << 1) - er;
-    el = (xl << 1) - xlk - el;
-    boty = floor(-y0 - radius + 1.0);
-    if (ybase + y - boty > ymax)
-	boty = ymax - ybase - y;
-    while (y > boty) {
-	k = (y << 1) + yk;
-	er -= k;
-	while ((er >= 0.0) && (xr >= 0)) {
-	    xr--;
-	    er += xrk - (xr << 1);
-	}
-	el -= k;
-	while ((el > 0.0) && (xl <= 0)) {
-	    xl++;
-	    el += (xl << 1) - xlk;
-	}
-	y--;
-	ybase++;
-	if (ybase < ymin)
-	    continue;
-	xcl = xl + xbase;
-	xcr = xr + xbase;
-	CLIPSTEPEDGE(edgey1, edge1, edgeleft1);
-	CLIPSTEPEDGE(edgey2, edge2, edgeleft2);
-	if(xcr >= xcl) {
-	    FILL_SPAN(infoRec->pScrn, xcl, ybase, xcr - xcl + 1);
-	}
-    }
-}
-
-
-static void
-XAALineArc (
-    GCPtr  pGC,
-    LineFacePtr leftFace,
-    LineFacePtr rightFace,
-    double	xorg,
-    double	yorg,
-    Bool	isInt )
-{
-    int xorgi, yorgi;
-    PolyEdgeRec	edge1, edge2;
-    int		edgey1, edgey2;
-    Bool	edgeleft1, edgeleft2;
-
-    if (isInt) {
-	xorgi = leftFace ? leftFace->x : rightFace->x;
-	yorgi = leftFace ? leftFace->y : rightFace->y;
-    } else {	/* Muffle compiler */
-        xorgi = yorgi = 0;
-    }
-    edgey1 = 65536;
-    edgey2 = 65536;
-    edge1.x = 0; /* not used, keep memory checkers happy */
-    edge1.dy = -1;
-    edge2.x = 0; /* not used, keep memory checkers happy */
-    edge2.dy = -1;
-    edgeleft1 = FALSE;
-    edgeleft2 = FALSE;
-
-    if ((pGC->lineWidth > 2) &&
-	((pGC->capStyle == CapRound && pGC->joinStyle != JoinRound) ||
-	 (pGC->joinStyle == JoinRound && pGC->capStyle == CapButt))) {
-	if (isInt) {
-	    xorg = (double) xorgi;
-	    yorg = (double) yorgi;
-	}
-
-	if (leftFace && rightFace) 
-	    miRoundJoinClip (leftFace, rightFace, &edge1, &edge2,
-			     &edgey1, &edgey2, &edgeleft1, &edgeleft2);
-	else if (leftFace)
-	    edgey1 = miRoundCapClip (leftFace, isInt, &edge1, &edgeleft1);
-	else if (rightFace)
-	    edgey2 = miRoundCapClip (rightFace, isInt, &edge2, &edgeleft2);
-
-	isInt = FALSE;
-    }
-
-    if (isInt) {
-	if(pGC->lineWidth == 1) {
-	    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-	    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-	    DRAW_POINT(infoRec->pScrn, xorgi, yorgi);
-	} else
-	    XAALineArcI(pGC, xorgi, yorgi);
-    } else
-	XAALineArcD(pGC, xorg, yorg, &edge1, edgey1, edgeleft1,
-		       &edge2, edgey2, edgeleft2);
-
-}
-
-
-static void
-XAALineJoin (
-    GCPtr	    pGC,
-    LineFacePtr     pLeft,
-    LineFacePtr     pRight )
-{
-    double	    mx = 0, my = 0;
-    double	    denom = 0;
-    PolyVertexRec   vertices[4];
-    PolySlopeRec    slopes[4];
-    int		    edgecount;
-    PolyEdgeRec	    left[4], right[4];
-    int		    nleft, nright;
-    int		    y, height;
-    int		    swapslopes;
-    int		    joinStyle = pGC->joinStyle;
-    int		    lw = pGC->lineWidth;
-
-    if (lw == 1) {
-	/* Lines going in the same direction have no join */
-	if ((pLeft->dx >= 0) == (pRight->dx <= 0))
-	    return;
-	if (joinStyle != JoinRound) {
-    	    denom = - pLeft->dx * (double)pRight->dy + pRight->dx *
- 					(double)pLeft->dy;
-    	    if (denom == 0.0)
-	    	return;	/* no join to draw */
-	}
-	if (joinStyle != JoinMiter) {
-	    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-	    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-	    DRAW_POINT(infoRec->pScrn, pLeft->x, pLeft->y);	
-	    return;
-	}
-    } else {
-    	if (joinStyle == JoinRound) {
-	    XAALineArc(pGC, pLeft, pRight,(double)0.0, (double)0.0, TRUE);
-	    return;
-    	}
-    	denom = - pLeft->dx * (double)pRight->dy + pRight->dx * 
-				(double)pLeft->dy;
-    	if (denom == 0.0)
-	    return;	/* no join to draw */
-    }
-
-    swapslopes = 0;
-    if (denom > 0) {
-	pLeft->xa = -pLeft->xa;
-	pLeft->ya = -pLeft->ya;
-	pLeft->dx = -pLeft->dx;
-	pLeft->dy = -pLeft->dy;
-    } else {
-	swapslopes = 1;
-	pRight->xa = -pRight->xa;
-	pRight->ya = -pRight->ya;
-	pRight->dx = -pRight->dx;
-	pRight->dy = -pRight->dy;
-    }
-
-    vertices[0].x = pRight->xa;
-    vertices[0].y = pRight->ya;
-    slopes[0].dx = -pRight->dy;
-    slopes[0].dy =  pRight->dx;
-    slopes[0].k = 0;
-
-    vertices[1].x = 0;
-    vertices[1].y = 0;
-    slopes[1].dx =  pLeft->dy;
-    slopes[1].dy = -pLeft->dx;
-    slopes[1].k = 0;
-
-    vertices[2].x = pLeft->xa;
-    vertices[2].y = pLeft->ya;
-
-    if (joinStyle == JoinMiter) {
-    	my = (pLeft->dy  * (pRight->xa * pRight->dy - pRight->ya * pRight->dx) -
-              pRight->dy * (pLeft->xa  * pLeft->dy  - pLeft->ya  * pLeft->dx ))/
-	      denom;
-    	if (pLeft->dy != 0) 
-	    mx = pLeft->xa + (my - pLeft->ya) *
-			    (double) pLeft->dx / (double) pLeft->dy;
-    	else
-	    mx = pRight->xa + (my - pRight->ya) *
-			    (double) pRight->dx / (double) pRight->dy;
-    	
-	/* check miter limit */
-	if ((mx * mx + my * my) * 4 > SQSECANT * lw * lw)
-	    joinStyle = JoinBevel;
-    }
-
-    if (joinStyle == JoinMiter) {
-	slopes[2].dx = pLeft->dx;
-	slopes[2].dy = pLeft->dy;
-	slopes[2].k =  pLeft->k;
-	if (swapslopes) {
-	    slopes[2].dx = -slopes[2].dx;
-	    slopes[2].dy = -slopes[2].dy;
-	    slopes[2].k  = -slopes[2].k;
-	}
-	vertices[3].x = mx;
-	vertices[3].y = my;
-	slopes[3].dx = pRight->dx;
-	slopes[3].dy = pRight->dy;
-	slopes[3].k  = pRight->k;
-	if (swapslopes) {
-	    slopes[3].dx = -slopes[3].dx;
-	    slopes[3].dy = -slopes[3].dy;
-	    slopes[3].k  = -slopes[3].k;
-	}
-	edgecount = 4;
-    } else {
-	double	scale, dx, dy, adx, ady;
-
-	adx = dx = pRight->xa - pLeft->xa;
-	ady = dy = pRight->ya - pLeft->ya;
-	if (adx < 0)
-	    adx = -adx;
-	if (ady < 0)
-	    ady = -ady;
-	scale = ady;
-	if (adx > ady)
-	    scale = adx;
-	slopes[2].dx = (dx * 65536) / scale;
-	slopes[2].dy = (dy * 65536) / scale;
-	slopes[2].k = ((pLeft->xa + pRight->xa) * slopes[2].dy -
-		       (pLeft->ya + pRight->ya) * slopes[2].dx) / 2.0;
-	edgecount = 3;
-    }
-
-    y = miPolyBuildPoly (vertices, slopes, edgecount, pLeft->x, pLeft->y,
-		   left, right, &nleft, &nright, &height);
-    XAAFillPolyHelper(pGC, y, height, left, right, nleft, nright);
-}
-
-
-void
-XAAPolylinesWideSolid (
-   DrawablePtr  pDrawable,
-   GCPtr        pGC,
-   int          mode,
-   int          npt,
-   DDXPointPtr  pPts )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int		    x1, y1, x2, y2;
-    Bool	    projectLeft, projectRight;
-    LineFaceRec	    leftFace, rightFace, prevRightFace, firstFace;
-    int    	    first = TRUE;
-    Bool	    somethingDrawn = FALSE;
-    Bool	    selfJoin = FALSE;
-    int		    xorg = pDrawable->x;
-    int		    yorg = pDrawable->y;
-    Bool	    hardClip = FALSE;
-
-    if(!REGION_NUM_RECTS(pGC->pCompositeClip))
-	return;
-
-    if(REGION_NUM_RECTS(pGC->pCompositeClip) != 1) {
-	miWideLine(pDrawable, pGC, mode, npt, pPts);
-	return;
-    }
-
-    x2 = pPts->x;
-    y2 = pPts->y;
-    if (npt > 1) {
-    	if (mode == CoordModePrevious) {
-	    int nptTmp;
-	    register DDXPointPtr pPtsTmp;
-    
-	    x1 = x2;
-	    y1 = y2;
-	    nptTmp = npt;
-	    pPtsTmp = pPts + 1;
-	    while (--nptTmp) {
-	    	x1 += pPtsTmp->x;
-	    	y1 += pPtsTmp->y;
-	    	++pPtsTmp;
-	    }
-	    if ((x2 == x1) && (y2 == y1))
-	    	selfJoin = TRUE;
-    	} else if ((x2 == pPts[npt-1].x) && (y2 == pPts[npt-1].y)) 
-	    selfJoin = TRUE;
-    }
-
-    projectLeft = ((pGC->capStyle == CapProjecting) && !selfJoin);
-    projectRight = FALSE;
-
-    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu, 
-						pGC->planemask);
-
-    infoRec->ClipBox = &pGC->pCompositeClip->extents;
-
-    if(infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL) {
-	hardClip = TRUE;
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-              infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-              infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);		
-    }
-
-    x2 += xorg;
-    y2 += yorg;
-    while (--npt) {
-	x1 = x2;
-	y1 = y2;
-	++pPts;
-	x2 = pPts->x;
-	y2 = pPts->y;
-	if (mode == CoordModePrevious) {
-	    x2 += x1;
-	    y2 += y1;
-	} else {
-	    x2 += xorg;
-	    y2 += yorg;
-	}
-	if ((x1 != x2) || (y1 != y2)) {
-	    somethingDrawn = TRUE;
-	    if ((npt == 1) && (pGC->capStyle == CapProjecting) && !selfJoin)
-	    	projectRight = TRUE;
-	    XAAWideSegment(pGC, x1, y1, x2, y2,
-		       	   projectLeft, projectRight, &leftFace, &rightFace);
-	    if (first) {
-	    	if (selfJoin)
-		    firstFace = leftFace;
-	    	else if (pGC->capStyle == CapRound) {
-		    if (pGC->lineWidth == 1) {
-			DRAW_POINT(infoRec->pScrn, x1, y1);
-		    } else
-		        XAALineArc(pGC,&leftFace, (LineFacePtr) NULL,
- 			       	   (double)0.0, (double)0.0,TRUE);
-		}
-	    } else 
-	    	XAALineJoin (pGC, &leftFace, &prevRightFace);
-
-	    prevRightFace = rightFace;
-	    first = FALSE;
-	    projectLeft = FALSE;
-	}
-	if (npt == 1 && somethingDrawn) {
-	    if (selfJoin)
-		XAALineJoin (pGC, &firstFace, &rightFace);
-	    else if (pGC->capStyle == CapRound) {
-		if (pGC->lineWidth == 1) {
-		    DRAW_POINT(infoRec->pScrn, x2, y2);
-		} else
-		    XAALineArc (pGC, (LineFacePtr) NULL, &rightFace,
-			       (double)0.0, (double)0.0,TRUE);
-	    }
-	}
-    }
-    /* handle crock where all points are coincedent */
-    if (!somethingDrawn) {
-	projectLeft = (pGC->capStyle == CapProjecting);
-	XAAWideSegment (pGC, x2, y2, x2, y2, projectLeft, projectLeft,
-		       &leftFace, &rightFace);
-	if (pGC->capStyle == CapRound) {
-	    XAALineArc (pGC, &leftFace, (LineFacePtr) NULL,
-		       (double)0.0, (double)0.0, TRUE);
-	    rightFace.dx = -1;	/* sleezy hack to make it work */
-	    XAALineArc (pGC, (LineFacePtr) NULL, &rightFace,
- 		       (double)0.0, (double)0.0, TRUE);
-	}
-   }
-
-   infoRec->ClipBox = NULL;
-   if(hardClip)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-   SET_SYNC_FLAG(infoRec);
-}
+/*

+

+XAAPolylinesWideSolid does not maintain a span list and subsequently does

+not follow the "touch-each-pixel-once" rules for wide lines and arcs.

+This means it can only be used in the case where we have

+miSpansEasyRop(pGC->alu).  Since we clip spans on the fly, we

+limited usage of this function to one rect situations. This

+function is used only for solid lines. 

+

+  Adapted from miWideLine by Mark Vojkovich (mvojkovi@ucsd.edu)

+Original mi code written by Keith Packard.

+

+*/

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <math.h>

+

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include <X11/X.h>

+#include "windowstr.h"

+#include "gcstruct.h"

+#include "regionstr.h"

+#include "miwideline.h"

+#include "mi.h"

+#include "xf86str.h"

+#include "xaa.h"

+#include "xaalocal.h"

+

+#define DRAW_POINT(pScrn, x, y) \

+  if(hardClip) (*infoRec->SubsequentSolidFillRect)(pScrn, x, y, 1, 1); \

+  else XAAPointHelper(pScrn, x, y)

+

+#define FILL_RECT(pScrn, x, y, w, h) \

+  if(hardClip) (*infoRec->SubsequentSolidFillRect)(pScrn, x, y, w, h); \

+  else XAAFillRectHelper(pScrn, x, y, w, h)

+

+#define FILL_SPAN(pScrn, x, y, w) \

+  if(hardClip) (*infoRec->SubsequentSolidFillRect)(pScrn, x, y, w, 1); \

+  else XAASpanHelper(pScrn, x, y, w)

+

+

+#define CLIPSTEPEDGE(edgey,edge,edgeleft) \

+    if (ybase == edgey) { \

+	if (edgeleft) { \

+	    if (edge->x > xcl) \

+		xcl = edge->x; \

+	} else { \

+	    if (edge->x < xcr) \

+		xcr = edge->x; \

+	} \

+	edgey++; \

+	edge->x += edge->stepx; \

+	edge->e += edge->dx; \

+	if (edge->e > 0) { \

+	    edge->x += edge->signdx; \

+	    edge->e -= edge->dy; \

+	} \

+    }

+

+static void 

+XAAPointHelper(ScrnInfoPtr pScrn, int x, int y)

+{

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+   BoxPtr extents = infoRec->ClipBox;

+

+   if((x >= extents->x1) && (x < extents->x2) &&

+	(y >= extents->y1) && (y < extents->y2))

+	(*infoRec->SubsequentSolidFillRect)(pScrn, x, y, 1, 1);

+}

+

+static void 

+XAAFillRectHelper(ScrnInfoPtr pScrn, int x1, int y1, int dx, int dy)

+{

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+   BoxPtr extents = infoRec->ClipBox;

+   int x2 = x1 + dx;

+   int y2 = y1 + dy;

+	

+   if(x1 < extents->x1) x1 = extents->x1;

+   if(x2 >= extents->x2) x2 = extents->x2;

+   if((dx = x2 - x1)<1) return;

+   if(y1 < extents->y1) y1 = extents->y1;

+   if(y2 >= extents->y2) y2 = extents->y2;

+   if((dy = y2 - y1)<1) return;

+

+   (*infoRec->SubsequentSolidFillRect)(pScrn, x1, y1, dx, dy);

+}

+

+

+static void 

+XAASpanHelper(ScrnInfoPtr pScrn, int x1, int y, int width)

+{

+   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

+   BoxPtr extents = infoRec->ClipBox;

+    int x2;

+

+    if((y < extents->y1) || (y >= extents->y2)) return;

+

+    x2 = x1 + width;

+    if(x1 < extents->x1) x1 = extents->x1;

+    if(x2 > extents->x2) x2 = extents->x2;

+    width = x2 - x1;	

+

+    if(width > 0)	

+ 	(*infoRec->SubsequentSolidFillRect)(pScrn, x1, y, width, 1);

+

+}

+

+#define FixError(x, dx, dy, e, sign, step, h)	{	\

+	   e += (h) * dx;				\

+	   x += (h) * step;				\

+	   if(e > 0) {					\

+		x += e * sign/dy;			\

+		e %= dy;				\

+	   	if(e) {					\

+		   x += sign;				\

+		   e -= dy;				\

+		}					\

+	   } 	 					\

+}

+

+

+static void

+XAAFillPolyHelper (

+    GCPtr	pGC,

+    int		y,			/* start y coordinate */

+    int		overall_height,		/* height of entire segment */

+    PolyEdgePtr	left, PolyEdgePtr right,

+    int	left_count, int right_count )

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    BoxPtr extents = infoRec->ClipBox;

+    int left_x, left_e, left_stepx, left_signdx, left_dy, left_dx;

+    int right_x, right_e, right_stepx, right_signdx, right_dy, right_dx;

+    int	height, left_height, right_height;

+    int	xorg;

+    Bool hardClip;

+

+    if((y >= extents->y2) || ((y + overall_height) <= extents->y1))

+	return;

+

+    /* Muffle compiler */

+    left_x = left_e = left_stepx = left_signdx = left_dy = left_dx = 0;

+    right_x = right_e = right_stepx = right_signdx = right_dy = right_dx = 0;

+

+    left_height = right_height = 0;

+    xorg = 0;

+

+    hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);

+    

+    while ((left_count || left_height) && (right_count || right_height)) {

+  	if (!left_height && left_count) { 

+	    left_height = left->height; 

+	    left_x = left->x + xorg; 

+	    left_stepx = left->stepx; 

+	    left_signdx = left->signdx; 

+	    left_e = left->e; 

+	    left_dy = left->dy; 

+	    left_dx = left->dx; 

+	    left_count--; 

+	    left++;

+	}

+	if (!right_height && right_count) { 

+	    right_height = right->height; 

+	    right_x = right->x + xorg + 1; 

+	    right_stepx = right->stepx; 

+	    right_signdx = right->signdx; 

+	    right_e = right->e; 

+	    right_dy = right->dy; 

+	    right_dx = right->dx; 

+	    right_count--; 

+	    right++; 

+	}

+

+	height = (left_height > right_height) ? right_height : left_height;

+

+	left_height -= height;

+	right_height -= height;

+

+	if(hardClip && infoRec->SubsequentSolidFillTrap && (height > 6)) {

+	    int right_DX, left_DX;

+

+    	    right_DX = (right_dx * right_signdx) + (right_stepx * right_dy);

+	    left_DX = (left_dx * left_signdx) + (left_stepx * left_dy);

+

+	    (*infoRec->SubsequentSolidFillTrap)(infoRec->pScrn, y, height, 

+			left_x, left_DX, left_dy, left_e, 

+			right_x - 1, right_DX, right_dy, right_e);

+

+	    FixError(left_x, left_dx, left_dy, left_e, left_signdx, 

+			left_stepx, height);

+	    FixError(right_x, right_dx, right_dy, right_e, right_signdx,

+			right_stepx, height);

+	    y += height;

+	    continue;

+	}

+

+	while (height--) {

+	    if(right_x > left_x) {

+		FILL_SPAN(infoRec->pScrn, left_x, y, right_x - left_x);

+	    }

+    	    y++;

+    	

+ 	    left_x += left_stepx; 

+	    left_e += left_dx; 

+	    if (left_e > 0) { 

+		left_x += left_signdx; 

+		left_e -= left_dy; 

+	    }

+	    right_x += right_stepx; 

+	    right_e += right_dx; 

+	    if (right_e > 0) { 

+		right_x += right_signdx; 

+		right_e -= right_dy; 

+	    }

+

+	}

+    }

+}

+

+

+

+static void

+XAAWideSegment (

+    GCPtr pGC,

+    int  x1, int y1, int x2, int y2,

+    Bool projectLeft, Bool projectRight,

+    LineFacePtr leftFace, LineFacePtr rightFace )

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    double	l, L, r;

+    double	xa, ya;

+    double	projectXoff, projectYoff;

+    double	k;

+    double	maxy;

+    int		x, y;

+    int		dx, dy;

+    int		finaly;

+    PolyEdgePtr left, right;

+    PolyEdgePtr	top, bottom;

+    int		lefty, righty, topy, bottomy;

+    int		signdx;

+    PolyEdgeRec	lefts[2], rights[2];

+    LineFacePtr	tface;

+    int		lw = pGC->lineWidth;

+    Bool	hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);

+

+    /* draw top-to-bottom always */

+    if ((y2 < y1) || ((y2 == y1) && (x2 < x1))) {

+	x = x1;

+	x1 = x2;

+	x2 = x;

+

+	y = y1;

+	y1 = y2;

+	y2 = y;

+

+	x = projectLeft;

+	projectLeft = projectRight;

+	projectRight = x;

+

+	tface = leftFace;

+	leftFace = rightFace;

+	rightFace = tface;

+    }

+

+    dy = y2 - y1;

+    signdx = 1;

+    dx = x2 - x1;

+    if (dx < 0)

+	signdx = -1;

+

+    leftFace->x = x1;

+    leftFace->y = y1;

+    leftFace->dx = dx;

+    leftFace->dy = dy;

+

+    rightFace->x = x2;

+    rightFace->y = y2;

+    rightFace->dx = -dx;

+    rightFace->dy = -dy;

+

+    if (!dy) {

+	rightFace->xa = 0;

+	rightFace->ya = (double) lw / 2.0;

+	rightFace->k = -(double) (lw * dx) / 2.0;

+	leftFace->xa = 0;

+	leftFace->ya = -rightFace->ya;

+	leftFace->k = rightFace->k;

+	x = x1;

+	if (projectLeft)

+	    x -= (lw >> 1);

+	y = y1 - (lw >> 1);

+	dx = x2 - x;

+	if (projectRight)

+	    dx += ((lw + 1) >> 1);

+	dy = lw;

+	FILL_RECT(infoRec->pScrn, x, y, dx, dy);	

+    } else if (!dx) {

+	leftFace->xa =  (double) lw / 2.0;

+	leftFace->ya = 0;

+	leftFace->k = (double) (lw * dy) / 2.0;

+	rightFace->xa = -leftFace->xa;

+	rightFace->ya = 0;

+	rightFace->k = leftFace->k;

+	y = y1;

+	if (projectLeft)

+	    y -= lw >> 1;

+	x = x1 - (lw >> 1);

+	dy = y2 - y;

+	if (projectRight)

+	    dy += ((lw + 1) >> 1);

+	dx = lw;

+ 	FILL_RECT(infoRec->pScrn, x, y, dx, dy);

+    } else {

+    	l = ((double) lw) / 2.0;

+    	L = sqrt((double)(dx*dx + dy*dy));

+

+	if (dx < 0) {

+	    right = &rights[1];

+	    left = &lefts[0];

+	    top = &rights[0];

+	    bottom = &lefts[1];

+	} else {

+	    right = &rights[0];

+	    left = &lefts[1];

+	    top = &lefts[0];

+	    bottom = &rights[1];

+	}

+	r = l / L;

+

+	/* coord of upper bound at integral y */

+	ya = -r * dx;

+	xa = r * dy;

+

+	projectXoff = -ya;

+	projectYoff = xa;

+

+    	/* xa * dy - ya * dx */

+	k = l * L;

+

+	leftFace->xa = xa;

+	leftFace->ya = ya;

+	leftFace->k = k;

+	rightFace->xa = -xa;

+	rightFace->ya = -ya;

+	rightFace->k = k;

+

+	if (projectLeft)

+	    righty = miPolyBuildEdge (xa - projectXoff, ya - projectYoff,

+				      k, dx, dy, x1, y1, 0, right);

+	else

+	    righty = miPolyBuildEdge (xa, ya,

+				      k, dx, dy, x1, y1, 0, right);

+

+	/* coord of lower bound at integral y */

+	ya = -ya;

+	xa = -xa;

+

+	/* xa * dy - ya * dx */

+	k = - k;

+

+	if (projectLeft)

+	    lefty = miPolyBuildEdge (xa - projectXoff, ya - projectYoff,

+				     k, dx, dy, x1, y1, 1, left);

+	else

+	    lefty = miPolyBuildEdge (xa, ya,

+				     k, dx, dy, x1, y1, 1, left);

+

+	/* coord of top face at integral y */

+

+	if (signdx > 0) {

+	    ya = -ya;

+	    xa = -xa;

+	}

+

+	if (projectLeft) {

+	    double xap = xa - projectXoff;

+	    double yap = ya - projectYoff;

+	    topy = miPolyBuildEdge (xap, yap, xap * dx + yap * dy,

+				    -dy, dx, x1, y1, dx > 0, top);

+	}

+	else

+	    topy = miPolyBuildEdge(xa, ya, 0.0, 

+					-dy, dx, x1, y1, dx > 0, top);

+

+		/* coord of bottom face at integral y */

+

+	if (projectRight) {

+	    double xap = xa + projectXoff;

+	    double yap = ya + projectYoff;

+	    bottomy = miPolyBuildEdge (xap, yap, xap * dx + yap * dy,

+				       -dy, dx, x2, y2, dx < 0, bottom);

+	    maxy = -ya + projectYoff;

+	} else {

+	    bottomy = miPolyBuildEdge (xa, ya, 0.0,

+					-dy, dx, x2, y2, dx < 0, bottom);

+	    maxy = -ya;

+	}

+

+	finaly = ICEIL (maxy) + y2;

+

+	if (dx < 0) {

+	    left->height = bottomy - lefty;

+	    right->height = finaly - righty;

+	    top->height = righty - topy;

+	} else {

+	    right->height =  bottomy - righty;

+	    left->height = finaly - lefty;

+	    top->height = lefty - topy;

+	}

+	bottom->height = finaly - bottomy;

+	XAAFillPolyHelper (pGC, topy, 

+		bottom->height + bottomy - topy, lefts, rights, 2, 2);

+    }

+}

+

+

+static void

+XAALineArcI (GCPtr pGC, int xorg, int yorg)

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    int x, y, e, ex;

+    int slw = pGC->lineWidth;

+    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);

+

+    y = (slw >> 1) + 1;

+    if (slw & 1)

+	e = - ((y << 2) + 3);

+    else

+	e = - (y << 3);

+    ex = -4;

+    x = 0;

+    while (y) {

+	e += (y << 3) - 4;

+	while (e >= 0) {

+	    x++;

+	    e += (ex = -((x << 3) + 4));

+	}

+	y--;

+	slw = (x << 1) + 1;

+	if ((e == ex) && (slw > 1))

+	    slw--;

+	    

+	FILL_SPAN(infoRec->pScrn, xorg - x, yorg - y, slw);

+

+	if ((y != 0) && ((slw > 1) || (e != ex))) {	

+	    FILL_SPAN(infoRec->pScrn, xorg - x, yorg + y, slw);

+	}

+    }

+}

+

+

+static void

+XAALineArcD (

+    GCPtr	    pGC,

+    double	    xorg,

+    double	    yorg,

+    PolyEdgePtr	    edge1, 

+    int		    edgey1,

+    Bool	    edgeleft1,

+    PolyEdgePtr	    edge2,

+    int		    edgey2,

+    Bool	    edgeleft2 )

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    double radius, x0, y0, el, er, yk, xlk, xrk, k;

+    int xbase, ybase, y, boty, xl, xr, xcl, xcr;

+    int ymin, ymax;

+    Bool edge1IsMin, edge2IsMin;

+    int ymin1, ymin2;

+    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);

+

+

+    xbase = floor(xorg);

+    x0 = xorg - xbase;

+    ybase = ICEIL (yorg);

+    y0 = yorg - ybase;

+

+    xlk = x0 + x0 + 1.0;

+    xrk = x0 + x0 - 1.0;

+    yk = y0 + y0 - 1.0;

+    radius = ((double)pGC->lineWidth) / 2.0;

+    y = floor(radius - y0 + 1.0);

+    ybase -= y;

+    ymin = ybase;

+    ymax = 65536;

+    edge1IsMin = FALSE;

+    ymin1 = edgey1;

+    if (edge1->dy >= 0) {

+    	if (!edge1->dy) {

+	    if (edgeleft1)

+	    	edge1IsMin = TRUE;

+	    else

+	    	ymax = edgey1;

+	    edgey1 = 65536;

+    	} else if ((edge1->signdx < 0) == edgeleft1)

+	    	edge1IsMin = TRUE;

+    }

+    edge2IsMin = FALSE;

+    ymin2 = edgey2;

+    if (edge2->dy >= 0) {

+    	if (!edge2->dy) {

+	    if (edgeleft2)

+	    	edge2IsMin = TRUE;

+	    else

+	    	ymax = edgey2;

+	    edgey2 = 65536;

+    	} else if ((edge2->signdx < 0) == edgeleft2)

+	    	edge2IsMin = TRUE;

+    }

+    if (edge1IsMin) {

+	ymin = ymin1;

+	if (edge2IsMin && (ymin1 > ymin2))

+	    ymin = ymin2;

+    } else if (edge2IsMin)

+	ymin = ymin2;

+    el = radius * radius - ((y + y0) * (y + y0)) - (x0 * x0);

+    er = el + xrk;

+    xl = 1;

+    xr = 0;

+    if (x0 < 0.5) {

+	xl = 0;

+	el -= xlk;

+    }

+    boty = (y0 < -0.5) ? 1 : 0;

+    if (ybase + y - boty > ymax)

+	boty = ymax - ybase - y;

+    while (y > boty) {

+	k = (y << 1) + yk;

+	er += k;

+	while (er > 0.0) {

+	    xr++;

+	    er += xrk - (xr << 1);

+	}

+	el += k;

+	while (el >= 0.0) {

+	    xl--;

+	    el += (xl << 1) - xlk;

+	}

+	y--;

+	ybase++;

+	if (ybase < ymin)

+	    continue;

+	xcl = xl + xbase;

+	xcr = xr + xbase;

+	CLIPSTEPEDGE(edgey1, edge1, edgeleft1);

+	CLIPSTEPEDGE(edgey2, edge2, edgeleft2);

+	if(xcr >= xcl) {

+	    FILL_SPAN(infoRec->pScrn, xcl, ybase, xcr - xcl + 1);

+	}

+    }

+    er = xrk - (xr << 1) - er;

+    el = (xl << 1) - xlk - el;

+    boty = floor(-y0 - radius + 1.0);

+    if (ybase + y - boty > ymax)

+	boty = ymax - ybase - y;

+    while (y > boty) {

+	k = (y << 1) + yk;

+	er -= k;

+	while ((er >= 0.0) && (xr >= 0)) {

+	    xr--;

+	    er += xrk - (xr << 1);

+	}

+	el -= k;

+	while ((el > 0.0) && (xl <= 0)) {

+	    xl++;

+	    el += (xl << 1) - xlk;

+	}

+	y--;

+	ybase++;

+	if (ybase < ymin)

+	    continue;

+	xcl = xl + xbase;

+	xcr = xr + xbase;

+	CLIPSTEPEDGE(edgey1, edge1, edgeleft1);

+	CLIPSTEPEDGE(edgey2, edge2, edgeleft2);

+	if(xcr >= xcl) {

+	    FILL_SPAN(infoRec->pScrn, xcl, ybase, xcr - xcl + 1);

+	}

+    }

+}

+

+

+static void

+XAALineArc (

+    GCPtr  pGC,

+    LineFacePtr leftFace,

+    LineFacePtr rightFace,

+    double	xorg,

+    double	yorg,

+    Bool	isInt )

+{

+    int xorgi, yorgi;

+    PolyEdgeRec	edge1, edge2;

+    int		edgey1, edgey2;

+    Bool	edgeleft1, edgeleft2;

+

+    if (isInt) {

+	xorgi = leftFace ? leftFace->x : rightFace->x;

+	yorgi = leftFace ? leftFace->y : rightFace->y;

+    } else {	/* Muffle compiler */

+        xorgi = yorgi = 0;

+    }

+    edgey1 = 65536;

+    edgey2 = 65536;

+    edge1.x = 0; /* not used, keep memory checkers happy */

+    edge1.dy = -1;

+    edge2.x = 0; /* not used, keep memory checkers happy */

+    edge2.dy = -1;

+    edgeleft1 = FALSE;

+    edgeleft2 = FALSE;

+

+    if ((pGC->lineWidth > 2) &&

+	((pGC->capStyle == CapRound && pGC->joinStyle != JoinRound) ||

+	 (pGC->joinStyle == JoinRound && pGC->capStyle == CapButt))) {

+	if (isInt) {

+	    xorg = (double) xorgi;

+	    yorg = (double) yorgi;

+	}

+

+	if (leftFace && rightFace) 

+	    miRoundJoinClip (leftFace, rightFace, &edge1, &edge2,

+			     &edgey1, &edgey2, &edgeleft1, &edgeleft2);

+	else if (leftFace)

+	    edgey1 = miRoundCapClip (leftFace, isInt, &edge1, &edgeleft1);

+	else if (rightFace)

+	    edgey2 = miRoundCapClip (rightFace, isInt, &edge2, &edgeleft2);

+

+	isInt = FALSE;

+    }

+

+    if (isInt) {

+	if(pGC->lineWidth == 1) {

+	    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+	    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);

+	    DRAW_POINT(infoRec->pScrn, xorgi, yorgi);

+	} else

+	    XAALineArcI(pGC, xorgi, yorgi);

+    } else

+	XAALineArcD(pGC, xorg, yorg, &edge1, edgey1, edgeleft1,

+		       &edge2, edgey2, edgeleft2);

+

+}

+

+

+static void

+XAALineJoin (

+    GCPtr	    pGC,

+    LineFacePtr     pLeft,

+    LineFacePtr     pRight )

+{

+    double	    mx = 0, my = 0;

+    double	    denom = 0;

+    PolyVertexRec   vertices[4];

+    PolySlopeRec    slopes[4];

+    int		    edgecount;

+    PolyEdgeRec	    left[4], right[4];

+    int		    nleft, nright;

+    int		    y, height;

+    int		    swapslopes;

+    int		    joinStyle = pGC->joinStyle;

+    int		    lw = pGC->lineWidth;

+

+    if (lw == 1) {

+	/* Lines going in the same direction have no join */

+	if ((pLeft->dx >= 0) == (pRight->dx <= 0))

+	    return;

+	if (joinStyle != JoinRound) {

+    	    denom = - pLeft->dx * (double)pRight->dy + pRight->dx *

+ 					(double)pLeft->dy;

+    	    if (denom == 0.0)

+	    	return;	/* no join to draw */

+	}

+	if (joinStyle != JoinMiter) {

+	    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+	    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);

+	    DRAW_POINT(infoRec->pScrn, pLeft->x, pLeft->y);	

+	    return;

+	}

+    } else {

+    	if (joinStyle == JoinRound) {

+	    XAALineArc(pGC, pLeft, pRight,(double)0.0, (double)0.0, TRUE);

+	    return;

+    	}

+    	denom = - pLeft->dx * (double)pRight->dy + pRight->dx * 

+				(double)pLeft->dy;

+    	if (denom == 0.0)

+	    return;	/* no join to draw */

+    }

+

+    swapslopes = 0;

+    if (denom > 0) {

+	pLeft->xa = -pLeft->xa;

+	pLeft->ya = -pLeft->ya;

+	pLeft->dx = -pLeft->dx;

+	pLeft->dy = -pLeft->dy;

+    } else {

+	swapslopes = 1;

+	pRight->xa = -pRight->xa;

+	pRight->ya = -pRight->ya;

+	pRight->dx = -pRight->dx;

+	pRight->dy = -pRight->dy;

+    }

+

+    vertices[0].x = pRight->xa;

+    vertices[0].y = pRight->ya;

+    slopes[0].dx = -pRight->dy;

+    slopes[0].dy =  pRight->dx;

+    slopes[0].k = 0;

+

+    vertices[1].x = 0;

+    vertices[1].y = 0;

+    slopes[1].dx =  pLeft->dy;

+    slopes[1].dy = -pLeft->dx;

+    slopes[1].k = 0;

+

+    vertices[2].x = pLeft->xa;

+    vertices[2].y = pLeft->ya;

+

+    if (joinStyle == JoinMiter) {

+    	my = (pLeft->dy  * (pRight->xa * pRight->dy - pRight->ya * pRight->dx) -

+              pRight->dy * (pLeft->xa  * pLeft->dy  - pLeft->ya  * pLeft->dx ))/

+	      denom;

+    	if (pLeft->dy != 0) 

+	    mx = pLeft->xa + (my - pLeft->ya) *

+			    (double) pLeft->dx / (double) pLeft->dy;

+    	else

+	    mx = pRight->xa + (my - pRight->ya) *

+			    (double) pRight->dx / (double) pRight->dy;

+    	

+	/* check miter limit */

+	if ((mx * mx + my * my) * 4 > SQSECANT * lw * lw)

+	    joinStyle = JoinBevel;

+    }

+

+    if (joinStyle == JoinMiter) {

+	slopes[2].dx = pLeft->dx;

+	slopes[2].dy = pLeft->dy;

+	slopes[2].k =  pLeft->k;

+	if (swapslopes) {

+	    slopes[2].dx = -slopes[2].dx;

+	    slopes[2].dy = -slopes[2].dy;

+	    slopes[2].k  = -slopes[2].k;

+	}

+	vertices[3].x = mx;

+	vertices[3].y = my;

+	slopes[3].dx = pRight->dx;

+	slopes[3].dy = pRight->dy;

+	slopes[3].k  = pRight->k;

+	if (swapslopes) {

+	    slopes[3].dx = -slopes[3].dx;

+	    slopes[3].dy = -slopes[3].dy;

+	    slopes[3].k  = -slopes[3].k;

+	}

+	edgecount = 4;

+    } else {

+	double	scale, dx, dy, adx, ady;

+

+	adx = dx = pRight->xa - pLeft->xa;

+	ady = dy = pRight->ya - pLeft->ya;

+	if (adx < 0)

+	    adx = -adx;

+	if (ady < 0)

+	    ady = -ady;

+	scale = ady;

+	if (adx > ady)

+	    scale = adx;

+	slopes[2].dx = (dx * 65536) / scale;

+	slopes[2].dy = (dy * 65536) / scale;

+	slopes[2].k = ((pLeft->xa + pRight->xa) * slopes[2].dy -

+		       (pLeft->ya + pRight->ya) * slopes[2].dx) / 2.0;

+	edgecount = 3;

+    }

+

+    y = miPolyBuildPoly (vertices, slopes, edgecount, pLeft->x, pLeft->y,

+		   left, right, &nleft, &nright, &height);

+    XAAFillPolyHelper(pGC, y, height, left, right, nleft, nright);

+}

+

+

+void

+XAAPolylinesWideSolid (

+   DrawablePtr  pDrawable,

+   GCPtr        pGC,

+   int          mode,

+   int          npt,

+   DDXPointPtr  pPts )

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    int		    x1, y1, x2, y2;

+    Bool	    projectLeft, projectRight;

+    LineFaceRec	    leftFace, rightFace, prevRightFace, firstFace;

+    int    	    first = TRUE;

+    Bool	    somethingDrawn = FALSE;

+    Bool	    selfJoin = FALSE;

+    int		    xorg = pDrawable->x;

+    int		    yorg = pDrawable->y;

+    Bool	    hardClip = FALSE;

+

+    if(!RegionNumRects(pGC->pCompositeClip))

+	return;

+

+    if(RegionNumRects(pGC->pCompositeClip) != 1) {

+	miWideLine(pDrawable, pGC, mode, npt, pPts);

+	return;

+    }

+

+    x2 = pPts->x;

+    y2 = pPts->y;

+    if (npt > 1) {

+    	if (mode == CoordModePrevious) {

+	    int nptTmp;

+	    register DDXPointPtr pPtsTmp;

+    

+	    x1 = x2;

+	    y1 = y2;

+	    nptTmp = npt;

+	    pPtsTmp = pPts + 1;

+	    while (--nptTmp) {

+	    	x1 += pPtsTmp->x;

+	    	y1 += pPtsTmp->y;

+	    	++pPtsTmp;

+	    }

+	    if ((x2 == x1) && (y2 == y1))

+	    	selfJoin = TRUE;

+    	} else if ((x2 == pPts[npt-1].x) && (y2 == pPts[npt-1].y)) 

+	    selfJoin = TRUE;

+    }

+

+    projectLeft = ((pGC->capStyle == CapProjecting) && !selfJoin);

+    projectRight = FALSE;

+

+    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu, 

+						pGC->planemask);

+

+    infoRec->ClipBox = &pGC->pCompositeClip->extents;

+

+    if(infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL) {

+	hardClip = TRUE;

+	(*infoRec->SetClippingRectangle)(infoRec->pScrn,

+              infoRec->ClipBox->x1, infoRec->ClipBox->y1, 

+              infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);		

+    }

+

+    x2 += xorg;

+    y2 += yorg;

+    while (--npt) {

+	x1 = x2;

+	y1 = y2;

+	++pPts;

+	x2 = pPts->x;

+	y2 = pPts->y;

+	if (mode == CoordModePrevious) {

+	    x2 += x1;

+	    y2 += y1;

+	} else {

+	    x2 += xorg;

+	    y2 += yorg;

+	}

+	if ((x1 != x2) || (y1 != y2)) {

+	    somethingDrawn = TRUE;

+	    if ((npt == 1) && (pGC->capStyle == CapProjecting) && !selfJoin)

+	    	projectRight = TRUE;

+	    XAAWideSegment(pGC, x1, y1, x2, y2,

+		       	   projectLeft, projectRight, &leftFace, &rightFace);

+	    if (first) {

+	    	if (selfJoin)

+		    firstFace = leftFace;

+	    	else if (pGC->capStyle == CapRound) {

+		    if (pGC->lineWidth == 1) {

+			DRAW_POINT(infoRec->pScrn, x1, y1);

+		    } else

+		        XAALineArc(pGC,&leftFace, (LineFacePtr) NULL,

+ 			       	   (double)0.0, (double)0.0,TRUE);

+		}

+	    } else 

+	    	XAALineJoin (pGC, &leftFace, &prevRightFace);

+

+	    prevRightFace = rightFace;

+	    first = FALSE;

+	    projectLeft = FALSE;

+	}

+	if (npt == 1 && somethingDrawn) {

+	    if (selfJoin)

+		XAALineJoin (pGC, &firstFace, &rightFace);

+	    else if (pGC->capStyle == CapRound) {

+		if (pGC->lineWidth == 1) {

+		    DRAW_POINT(infoRec->pScrn, x2, y2);

+		} else

+		    XAALineArc (pGC, (LineFacePtr) NULL, &rightFace,

+			       (double)0.0, (double)0.0,TRUE);

+	    }

+	}

+    }

+    /* handle crock where all points are coincedent */

+    if (!somethingDrawn) {

+	projectLeft = (pGC->capStyle == CapProjecting);

+	XAAWideSegment (pGC, x2, y2, x2, y2, projectLeft, projectLeft,

+		       &leftFace, &rightFace);

+	if (pGC->capStyle == CapRound) {

+	    XAALineArc (pGC, &leftFace, (LineFacePtr) NULL,

+		       (double)0.0, (double)0.0, TRUE);

+	    rightFace.dx = -1;	/* sleezy hack to make it work */

+	    XAALineArc (pGC, (LineFacePtr) NULL, &rightFace,

+ 		       (double)0.0, (double)0.0, TRUE);

+	}

+   }

+

+   infoRec->ClipBox = NULL;

+   if(hardClip)

+	(*infoRec->DisableClipping)(infoRec->pScrn);

+

+   SET_SYNC_FLAG(infoRec);

+}

diff --git a/xorg-server/hw/xfree86/xaa/xaaWrapper.c b/xorg-server/hw/xfree86/xaa/xaaWrapper.c
index f709d0b35..09644c9ac 100644
--- a/xorg-server/hw/xfree86/xaa/xaaWrapper.c
+++ b/xorg-server/hw/xfree86/xaa/xaaWrapper.c
@@ -125,10 +125,10 @@ typedef struct _xaaWrapperGCPriv {
 #define xaaWrapperGCPriv(pGC)   xaaWrapperGCPrivPtr  pGCPriv = xaaWrapperGetGCPriv(pGC)

 

 

-static int xaaWrapperScrPrivateKeyIndex;

-static DevPrivateKey xaaWrapperScrPrivateKey = &xaaWrapperScrPrivateKeyIndex;

-static int xaaWrapperGCPrivateKeyIndex;

-static DevPrivateKey xaaWrapperGCPrivateKey = &xaaWrapperGCPrivateKeyIndex;

+static DevPrivateKeyRec xaaWrapperScrPrivateKeyRec;

+#define xaaWrapperScrPrivateKey (&xaaWrapperScrPrivateKeyRec)

+static DevPrivateKeyRec xaaWrapperGCPrivateKeyRec;

+#define xaaWrapperGCPrivateKey (&xaaWrapperGCPrivateKeyRec)

 

 static Bool

 xaaWrapperCreateScreenResources(ScreenPtr pScreen)

@@ -268,7 +268,10 @@ xaaSetupWrapper(ScreenPtr pScreen, XAAInfoRecPtr infoPtr, int depth, SyncFunc *f
     xaaWrapperScrPrivPtr pScrPriv;

     PictureScreenPtr	ps = GetPictureScreenIfSet(pScreen);

 

-    if (!dixRequestPrivate(xaaWrapperGCPrivateKey, sizeof(xaaWrapperGCPrivRec)))

+    if (!dixRegisterPrivateKey(&xaaWrapperGCPrivateKeyRec, PRIVATE_GC, sizeof(xaaWrapperGCPrivRec)))

+	return FALSE;

+

+    if (!dixRegisterPrivateKey(&xaaWrapperScrPrivateKeyRec, PRIVATE_SCREEN, 0))

 	return FALSE;

 

     pScrPriv = (xaaWrapperScrPrivPtr) malloc(sizeof (xaaWrapperScrPrivRec));

diff --git a/xorg-server/hw/xfree86/xaa/xaawrap.h b/xorg-server/hw/xfree86/xaa/xaawrap.h
index 86ba003d6..1b7595e95 100644
--- a/xorg-server/hw/xfree86/xaa/xaawrap.h
+++ b/xorg-server/hw/xfree86/xaa/xaawrap.h
@@ -1,79 +1,79 @@
-
-#define XAA_SCREEN_PROLOGUE(pScreen, field)\
-  ((pScreen)->field = \
-   ((XAAScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAGetScreenKey()))->field)
-
-#define XAA_SCREEN_EPILOGUE(pScreen, field, wrapper)\
-    ((pScreen)->field = wrapper)
-
-
-#define XAA_GC_FUNC_PROLOGUE(pGC)\
-    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \
-    (pGC)->funcs = pGCPriv->wrapFuncs;\
-    if(pGCPriv->flags)\
-	(pGC)->ops = pGCPriv->wrapOps
-
-#define XAA_GC_FUNC_EPILOGUE(pGC)\
-    pGCPriv->wrapFuncs = (pGC)->funcs;\
-    (pGC)->funcs = &XAAGCFuncs;\
-    if(pGCPriv->flags) {\
-	pGCPriv->wrapOps = (pGC)->ops;\
-	(pGC)->ops = (pGCPriv->flags & OPS_ARE_ACCEL) ? pGCPriv->XAAOps :\
-				&XAAPixmapOps;\
-    }
-
-
-#define XAA_GC_OP_PROLOGUE(pGC)\
-    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \
-    GCFuncs *oldFuncs = pGC->funcs;\
-    pGC->funcs = pGCPriv->wrapFuncs;\
-    pGC->ops = pGCPriv->wrapOps
-
-#define XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC)\
-    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \
-    GCFuncs *oldFuncs = pGC->funcs;\
-    if(!REGION_NUM_RECTS(pGC->pCompositeClip)) return; \
-    pGC->funcs = pGCPriv->wrapFuncs;\
-    pGC->ops = pGCPriv->wrapOps
-
-    
-#define XAA_GC_OP_EPILOGUE(pGC)\
-    pGCPriv->wrapOps = pGC->ops;\
-    pGC->funcs = oldFuncs;\
-    pGC->ops   = pGCPriv->XAAOps
-
-
-#define XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw)\
-    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \
-    XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE((PixmapPtr)(pDraw));\
-    GCFuncs *oldFuncs = pGC->funcs;\
-    pGC->funcs = pGCPriv->wrapFuncs;\
-    pGC->ops = pGCPriv->wrapOps; \
-    SYNC_CHECK(pGC)
-    
-#define XAA_PIXMAP_OP_EPILOGUE(pGC)\
-    pGCPriv->wrapOps = pGC->ops;\
-    pGC->funcs = oldFuncs;\
-    pGC->ops   = &XAAPixmapOps;\
-    pixPriv->flags |= DIRTY
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#define XAA_RENDER_PROLOGUE(pScreen,field)\
-    (GetPictureScreen(pScreen)->field = \
-     ((XAAScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAGetScreenKey()))->field)
-
-#define XAA_RENDER_EPILOGUE(pScreen, field, wrapper)\
-    (GetPictureScreen(pScreen)->field = wrapper)
-
-/* This also works fine for drawables */
-
-#define SYNC_CHECK(pGC) {\
-     XAAInfoRecPtr infoRec =\
-((XAAScreenPtr)dixLookupPrivate(&(pGC)->pScreen->devPrivates, XAAGetScreenKey()))->AccelInfoRec;	\
-    if(infoRec->NeedToSync) {\
-	(*infoRec->Sync)(infoRec->pScrn);\
-	infoRec->NeedToSync = FALSE;\
-    }}
+

+#define XAA_SCREEN_PROLOGUE(pScreen, field)\

+  ((pScreen)->field = \

+   ((XAAScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAGetScreenKey()))->field)

+

+#define XAA_SCREEN_EPILOGUE(pScreen, field, wrapper)\

+    ((pScreen)->field = wrapper)

+

+

+#define XAA_GC_FUNC_PROLOGUE(pGC)\

+    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \

+    (pGC)->funcs = pGCPriv->wrapFuncs;\

+    if(pGCPriv->flags)\

+	(pGC)->ops = pGCPriv->wrapOps

+

+#define XAA_GC_FUNC_EPILOGUE(pGC)\

+    pGCPriv->wrapFuncs = (pGC)->funcs;\

+    (pGC)->funcs = &XAAGCFuncs;\

+    if(pGCPriv->flags) {\

+	pGCPriv->wrapOps = (pGC)->ops;\

+	(pGC)->ops = (pGCPriv->flags & OPS_ARE_ACCEL) ? pGCPriv->XAAOps :\

+				&XAAPixmapOps;\

+    }

+

+

+#define XAA_GC_OP_PROLOGUE(pGC)\

+    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \

+    GCFuncs *oldFuncs = pGC->funcs;\

+    pGC->funcs = pGCPriv->wrapFuncs;\

+    pGC->ops = pGCPriv->wrapOps

+

+#define XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC)\

+    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \

+    GCFuncs *oldFuncs = pGC->funcs;\

+    if(!RegionNumRects(pGC->pCompositeClip)) return; \

+    pGC->funcs = pGCPriv->wrapFuncs;\

+    pGC->ops = pGCPriv->wrapOps

+

+    

+#define XAA_GC_OP_EPILOGUE(pGC)\

+    pGCPriv->wrapOps = pGC->ops;\

+    pGC->funcs = oldFuncs;\

+    pGC->ops   = pGCPriv->XAAOps

+

+

+#define XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw)\

+    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \

+    XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE((PixmapPtr)(pDraw));\

+    GCFuncs *oldFuncs = pGC->funcs;\

+    pGC->funcs = pGCPriv->wrapFuncs;\

+    pGC->ops = pGCPriv->wrapOps; \

+    SYNC_CHECK(pGC)

+    

+#define XAA_PIXMAP_OP_EPILOGUE(pGC)\

+    pGCPriv->wrapOps = pGC->ops;\

+    pGC->funcs = oldFuncs;\

+    pGC->ops   = &XAAPixmapOps;\

+    pixPriv->flags |= DIRTY

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#define XAA_RENDER_PROLOGUE(pScreen,field)\

+    (GetPictureScreen(pScreen)->field = \

+     ((XAAScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAGetScreenKey()))->field)

+

+#define XAA_RENDER_EPILOGUE(pScreen, field, wrapper)\

+    (GetPictureScreen(pScreen)->field = wrapper)

+

+/* This also works fine for drawables */

+

+#define SYNC_CHECK(pGC) {\

+     XAAInfoRecPtr infoRec =\

+((XAAScreenPtr)dixLookupPrivate(&(pGC)->pScreen->devPrivates, XAAGetScreenKey()))->AccelInfoRec;	\

+    if(infoRec->NeedToSync) {\

+	(*infoRec->Sync)(infoRec->pScrn);\

+	infoRec->NeedToSync = FALSE;\

+    }}

diff --git a/xorg-server/hw/xnest/Color.c b/xorg-server/hw/xnest/Color.c
index 985b5ad95..bb215fc45 100644
--- a/xorg-server/hw/xnest/Color.c
+++ b/xorg-server/hw/xnest/Color.c
@@ -34,8 +34,8 @@ is" without express or implied warranty.
 #include "XNWindow.h"

 #include "Args.h"

 

-static int cmapScrPrivateKeyIndex;

-static DevPrivateKey cmapScrPrivateKey = &cmapScrPrivateKeyIndex;

+static DevPrivateKeyRec cmapScrPrivateKeyRec;

+#define cmapScrPrivateKey (&cmapScrPrivateKeyRec)

 

 #define GetInstalledColormap(s) ((ColormapPtr) dixLookupPrivate(&(s)->devPrivates, cmapScrPrivateKey))

 #define SetInstalledColormap(s,c) (dixSetPrivate(&(s)->devPrivates, cmapScrPrivateKey, c))

@@ -214,8 +214,7 @@ xnestSetInstalledColormapWindows(ScreenPtr pScreen)
   free(icws.cmapIDs);

   

   if (!xnestSameInstalledColormapWindows(icws.windows, icws.numWindows)) {

-    if (xnestOldInstalledColormapWindows)

-      free(xnestOldInstalledColormapWindows);

+    free(xnestOldInstalledColormapWindows);

 

 #ifdef _XSERVER64

     {

@@ -264,14 +263,13 @@ xnestSetInstalledColormapWindows(ScreenPtr pScreen)
 #endif /* DUMB_WINDOW_MANAGERS */

   }

   else

-    if (icws.windows) free(icws.windows);

+    free(icws.windows);

 }

 

 void

 xnestSetScreenSaverColormapWindow(ScreenPtr pScreen)

 {

-  if (xnestOldInstalledColormapWindows)

-    free(xnestOldInstalledColormapWindows);

+  free(xnestOldInstalledColormapWindows);

   

 #ifdef _XSERVER64

   {

@@ -469,6 +467,9 @@ xnestCreateDefaultColormap(ScreenPtr pScreen)
   unsigned short zero = 0, ones = 0xFFFF;  

   Pixel wp, bp;

 

+  if (!dixRegisterPrivateKey(&cmapScrPrivateKeyRec, PRIVATE_SCREEN, 0))

+      return FALSE;

+

   for (pVisual = pScreen->visuals;

        pVisual->vid != pScreen->rootVisual;

        pVisual++);

diff --git a/xorg-server/hw/xnest/Drawable.h b/xorg-server/hw/xnest/Drawable.h
index d94916ecd..7f742cb1f 100644
--- a/xorg-server/hw/xnest/Drawable.h
+++ b/xorg-server/hw/xnest/Drawable.h
@@ -1,26 +1,26 @@
-/*
-
-Copyright 1993 by Davor Matic
-
-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.  Davor Matic makes no representations about
-the suitability of this software for any purpose.  It is provided "as
-is" without express or implied warranty.
-
-*/
-
-#ifndef XNESTDRAWABLE_H
-#define XNESTDRAWABLE_H
-
-#include "XNWindow.h"
-#include "XNPixmap.h"
-
-#define xnestDrawable(pDrawable) \
-  ((pDrawable)->type == DRAWABLE_WINDOW ? \
-   xnestWindow((WindowPtr)pDrawable) : \
-   xnestPixmap((PixmapPtr)pDrawable))
-
-#endif /* XNESTDRAWABLE_H */
+/*

+

+Copyright 1993 by Davor Matic

+

+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.  Davor Matic makes no representations about

+the suitability of this software for any purpose.  It is provided "as

+is" without express or implied warranty.

+

+*/

+

+#ifndef XNESTDRAWABLE_H

+#define XNESTDRAWABLE_H

+

+#include "XNWindow.h"

+#include "XNPixmap.h"

+

+#define xnestDrawable(pDrawable) \

+  (WindowDrawable((pDrawable)->type) ?	\

+   xnestWindow((WindowPtr)pDrawable) : \

+   xnestPixmap((PixmapPtr)pDrawable))

+

+#endif /* XNESTDRAWABLE_H */

diff --git a/xorg-server/hw/xnest/Events.c b/xorg-server/hw/xnest/Events.c
index 277718ba3..88970bbe0 100644
--- a/xorg-server/hw/xnest/Events.c
+++ b/xorg-server/hw/xnest/Events.c
@@ -1,227 +1,227 @@
-/*
-
-Copyright 1993 by Davor Matic
-
-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.  Davor Matic makes no representations about
-the suitability of this software for any purpose.  It is provided "as
-is" without express or implied warranty.
-
-*/
-
-#ifdef HAVE_XNEST_CONFIG_H
-#include <xnest-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "screenint.h"
-#include "input.h"
-#include "misc.h"
-#include "scrnintstr.h"
-#include "windowstr.h"
-#include "servermd.h"
-#include "inputstr.h"
-
-#include "mi.h"
-
-#include "Xnest.h"
-
-#include "Args.h"
-#include "Color.h"
-#include "Display.h"
-#include "Screen.h"
-#include "XNWindow.h"
-#include "Events.h"
-#include "Keyboard.h"
-#include "Pointer.h"
-#include "mipointer.h"
-
-CARD32 lastEventTime = 0;
-
-extern EventList *xnestEvents;
-
-void
-ProcessInputEvents(void)
-{
-  mieqProcessInputEvents();
-}
-
-int
-TimeSinceLastInputEvent(void)
-{
-    if (lastEventTime == 0)
-        lastEventTime = GetTimeInMillis();
-    return GetTimeInMillis() - lastEventTime;
-}
-
-void
-SetTimeSinceLastInputEvent(void)
-{
-  lastEventTime = GetTimeInMillis();
-}
-
-static Bool
-xnestExposurePredicate(Display *display, XEvent *event, char *args)
-{
-  return (event->type == Expose || event->type == ProcessedExpose);
-}
-
-static Bool
-xnestNotExposurePredicate(Display *display, XEvent *event, char *args)
-{
-  return !xnestExposurePredicate(display, event, args);
-}
-
-void
-xnestCollectExposures(void)
-{
-  XEvent X;
-  WindowPtr pWin;
-  RegionRec Rgn;
-  BoxRec Box;
-  
-  while (XCheckIfEvent(xnestDisplay, &X, xnestExposurePredicate, NULL)) {
-    pWin = xnestWindowPtr(X.xexpose.window);
-    
-    if (pWin && X.xexpose.width && X.xexpose.height) {
-      Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + X.xexpose.x;
-      Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + X.xexpose.y;
-      Box.x2 = Box.x1 + X.xexpose.width;
-      Box.y2 = Box.y1 + X.xexpose.height;
-      
-      REGION_INIT(pWin->drawable.pScreen, &Rgn, &Box, 1);
-      
-      miSendExposures(pWin, &Rgn, Box.x2, Box.y2);
-    }
-  }
-}
-
-void
-xnestQueueKeyEvent(int type, unsigned int keycode)
-{
-  int i, n;
-
-  GetEventList(&xnestEvents);
-  lastEventTime = GetTimeInMillis();
-  n = GetKeyboardEvents(xnestEvents, xnestKeyboardDevice, type, keycode);
-  for (i = 0; i < n; i++)
-    mieqEnqueue(xnestKeyboardDevice, (InternalEvent*)(xnestEvents + i)->event);
-}
-
-void
-xnestCollectEvents(void)
-{
-  XEvent X;
-  int i, n, valuators[2];
-  ScreenPtr pScreen;
-  GetEventList(&xnestEvents);
-
-  while (XCheckIfEvent(xnestDisplay, &X, xnestNotExposurePredicate, NULL)) {
-    switch (X.type) {
-    case KeyPress:
-      xnestUpdateModifierState(X.xkey.state);
-      xnestQueueKeyEvent(KeyPress, X.xkey.keycode);
-      break;
-      
-    case KeyRelease:
-      xnestUpdateModifierState(X.xkey.state);
-      xnestQueueKeyEvent(KeyRelease, X.xkey.keycode);
-      break;
-      
-    case ButtonPress:
-      xnestUpdateModifierState(X.xkey.state);
-      lastEventTime = GetTimeInMillis();
-      n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonPress,
-                           X.xbutton.button, POINTER_RELATIVE, 0, 0, NULL);
-      for (i = 0; i < n; i++)
-        mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
-      break;
-      
-    case ButtonRelease:
-      xnestUpdateModifierState(X.xkey.state);
-      lastEventTime = GetTimeInMillis();
-      n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonRelease,
-                           X.xbutton.button, POINTER_RELATIVE, 0, 0, NULL);
-      for (i = 0; i < n; i++)
-        mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
-      break;
-      
-    case MotionNotify:
-      valuators[0] = X.xmotion.x;
-      valuators[1] = X.xmotion.y;
-      lastEventTime = GetTimeInMillis();
-      n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify,
-                           0, POINTER_ABSOLUTE, 0, 2, valuators);
-      for (i = 0; i < n; i++)
-        mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
-      break;
-      
-    case FocusIn:
-      if (X.xfocus.detail != NotifyInferior) {
-	pScreen = xnestScreen(X.xfocus.window);
-	if (pScreen)
-	  xnestDirectInstallColormaps(pScreen);
-      }
-      break;
-   
-    case FocusOut:
-      if (X.xfocus.detail != NotifyInferior) {
-	pScreen = xnestScreen(X.xfocus.window);
-	if (pScreen)
-	  xnestDirectUninstallColormaps(pScreen);
-      }
-      break;
-
-    case KeymapNotify:
-      break;
-
-    case EnterNotify:
-      if (X.xcrossing.detail != NotifyInferior) {
-	pScreen = xnestScreen(X.xcrossing.window);
-	if (pScreen) {
-	  NewCurrentScreen(inputInfo.pointer, pScreen, X.xcrossing.x, X.xcrossing.y);
-          valuators[0] = X.xcrossing.x;
-          valuators[1] = X.xcrossing.y;
-          lastEventTime = GetTimeInMillis();
-          n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify,
-                               0, POINTER_ABSOLUTE, 0, 2, valuators);
-          for (i = 0; i < n; i++)
-            mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
-	  xnestDirectInstallColormaps(pScreen);
-	}
-      }
-      break;
-      
-    case LeaveNotify:
-      if (X.xcrossing.detail != NotifyInferior) {
-	pScreen = xnestScreen(X.xcrossing.window);
-	if (pScreen) {
-	  xnestDirectUninstallColormaps(pScreen);
-	}	
-      }
-      break;
-      
-    case DestroyNotify:
-      if (xnestParentWindow != (Window) 0 &&
-	  X.xdestroywindow.window == xnestParentWindow)
-	exit (0);
-      break;
-
-    case CirculateNotify:
-    case ConfigureNotify:
-    case GravityNotify:
-    case MapNotify:
-    case ReparentNotify:
-    case UnmapNotify:
-      break;
-      
-    default:
-      ErrorF("xnest warning: unhandled event\n");
-      break;
-    }
-  }
-}
+/*

+

+Copyright 1993 by Davor Matic

+

+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.  Davor Matic makes no representations about

+the suitability of this software for any purpose.  It is provided "as

+is" without express or implied warranty.

+

+*/

+

+#ifdef HAVE_XNEST_CONFIG_H

+#include <xnest-config.h>

+#endif

+

+#include <X11/X.h>

+#include <X11/Xproto.h>

+#include "screenint.h"

+#include "input.h"

+#include "misc.h"

+#include "scrnintstr.h"

+#include "windowstr.h"

+#include "servermd.h"

+#include "inputstr.h"

+

+#include "mi.h"

+

+#include "Xnest.h"

+

+#include "Args.h"

+#include "Color.h"

+#include "Display.h"

+#include "Screen.h"

+#include "XNWindow.h"

+#include "Events.h"

+#include "Keyboard.h"

+#include "Pointer.h"

+#include "mipointer.h"

+

+CARD32 lastEventTime = 0;

+

+extern EventList *xnestEvents;

+

+void

+ProcessInputEvents(void)

+{

+  mieqProcessInputEvents();

+}

+

+int

+TimeSinceLastInputEvent(void)

+{

+    if (lastEventTime == 0)

+        lastEventTime = GetTimeInMillis();

+    return GetTimeInMillis() - lastEventTime;

+}

+

+void

+SetTimeSinceLastInputEvent(void)

+{

+  lastEventTime = GetTimeInMillis();

+}

+

+static Bool

+xnestExposurePredicate(Display *display, XEvent *event, char *args)

+{

+  return event->type == Expose || event->type == ProcessedExpose;

+}

+

+static Bool

+xnestNotExposurePredicate(Display *display, XEvent *event, char *args)

+{

+  return !xnestExposurePredicate(display, event, args);

+}

+

+void

+xnestCollectExposures(void)

+{

+  XEvent X;

+  WindowPtr pWin;

+  RegionRec Rgn;

+  BoxRec Box;

+  

+  while (XCheckIfEvent(xnestDisplay, &X, xnestExposurePredicate, NULL)) {

+    pWin = xnestWindowPtr(X.xexpose.window);

+    

+    if (pWin && X.xexpose.width && X.xexpose.height) {

+      Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + X.xexpose.x;

+      Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + X.xexpose.y;

+      Box.x2 = Box.x1 + X.xexpose.width;

+      Box.y2 = Box.y1 + X.xexpose.height;

+      

+      RegionInit(&Rgn, &Box, 1);

+      

+      miSendExposures(pWin, &Rgn, Box.x2, Box.y2);

+    }

+  }

+}

+

+void

+xnestQueueKeyEvent(int type, unsigned int keycode)

+{

+  int i, n;

+

+  GetEventList(&xnestEvents);

+  lastEventTime = GetTimeInMillis();

+  n = GetKeyboardEvents(xnestEvents, xnestKeyboardDevice, type, keycode);

+  for (i = 0; i < n; i++)

+    mieqEnqueue(xnestKeyboardDevice, (InternalEvent*)(xnestEvents + i)->event);

+}

+

+void

+xnestCollectEvents(void)

+{

+  XEvent X;

+  int i, n, valuators[2];

+  ScreenPtr pScreen;

+  GetEventList(&xnestEvents);

+

+  while (XCheckIfEvent(xnestDisplay, &X, xnestNotExposurePredicate, NULL)) {

+    switch (X.type) {

+    case KeyPress:

+      xnestUpdateModifierState(X.xkey.state);

+      xnestQueueKeyEvent(KeyPress, X.xkey.keycode);

+      break;

+      

+    case KeyRelease:

+      xnestUpdateModifierState(X.xkey.state);

+      xnestQueueKeyEvent(KeyRelease, X.xkey.keycode);

+      break;

+      

+    case ButtonPress:

+      xnestUpdateModifierState(X.xkey.state);

+      lastEventTime = GetTimeInMillis();

+      n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonPress,

+                           X.xbutton.button, POINTER_RELATIVE, 0, 0, NULL);

+      for (i = 0; i < n; i++)

+        mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);

+      break;

+      

+    case ButtonRelease:

+      xnestUpdateModifierState(X.xkey.state);

+      lastEventTime = GetTimeInMillis();

+      n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonRelease,

+                           X.xbutton.button, POINTER_RELATIVE, 0, 0, NULL);

+      for (i = 0; i < n; i++)

+        mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);

+      break;

+      

+    case MotionNotify:

+      valuators[0] = X.xmotion.x;

+      valuators[1] = X.xmotion.y;

+      lastEventTime = GetTimeInMillis();

+      n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify,

+                           0, POINTER_ABSOLUTE, 0, 2, valuators);

+      for (i = 0; i < n; i++)

+        mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);

+      break;

+      

+    case FocusIn:

+      if (X.xfocus.detail != NotifyInferior) {

+	pScreen = xnestScreen(X.xfocus.window);

+	if (pScreen)

+	  xnestDirectInstallColormaps(pScreen);

+      }

+      break;

+   

+    case FocusOut:

+      if (X.xfocus.detail != NotifyInferior) {

+	pScreen = xnestScreen(X.xfocus.window);

+	if (pScreen)

+	  xnestDirectUninstallColormaps(pScreen);

+      }

+      break;

+

+    case KeymapNotify:

+      break;

+

+    case EnterNotify:

+      if (X.xcrossing.detail != NotifyInferior) {

+	pScreen = xnestScreen(X.xcrossing.window);

+	if (pScreen) {

+	  NewCurrentScreen(inputInfo.pointer, pScreen, X.xcrossing.x, X.xcrossing.y);

+          valuators[0] = X.xcrossing.x;

+          valuators[1] = X.xcrossing.y;

+          lastEventTime = GetTimeInMillis();

+          n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify,

+                               0, POINTER_ABSOLUTE, 0, 2, valuators);

+          for (i = 0; i < n; i++)

+            mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);

+	  xnestDirectInstallColormaps(pScreen);

+	}

+      }

+      break;

+      

+    case LeaveNotify:

+      if (X.xcrossing.detail != NotifyInferior) {

+	pScreen = xnestScreen(X.xcrossing.window);

+	if (pScreen) {

+	  xnestDirectUninstallColormaps(pScreen);

+	}	

+      }

+      break;

+      

+    case DestroyNotify:

+      if (xnestParentWindow != (Window) 0 &&

+	  X.xdestroywindow.window == xnestParentWindow)

+	exit (0);

+      break;

+

+    case CirculateNotify:

+    case ConfigureNotify:

+    case GravityNotify:

+    case MapNotify:

+    case ReparentNotify:

+    case UnmapNotify:

+      break;

+      

+    default:

+      ErrorF("xnest warning: unhandled event\n");

+      break;

+    }

+  }

+}

diff --git a/xorg-server/hw/xnest/GC.c b/xorg-server/hw/xnest/GC.c
index 9df015728..3c0074cc9 100644
--- a/xorg-server/hw/xnest/GC.c
+++ b/xorg-server/hw/xnest/GC.c
@@ -35,8 +35,7 @@ is" without express or implied warranty.
 #include "XNFont.h"

 #include "Color.h"

 

-static int xnestGCPrivateKeyIndex;

-DevPrivateKey xnestGCPrivateKey = &xnestGCPrivateKeyIndex;

+DevPrivateKeyRec xnestGCPrivateKeyRec;

 

 static GCFuncs xnestFuncs = {

   xnestValidateGC,

@@ -210,10 +209,10 @@ xnestChangeClip(GCPtr pGC, int type, pointer pValue, int nRects)
       break;

       

     case CT_REGION:

-      nRects = REGION_NUM_RECTS((RegionPtr)pValue);

+      nRects = RegionNumRects((RegionPtr)pValue);

       size = nRects * sizeof(*pRects);

       pRects = (XRectangle *) malloc(size);

-      pBox = REGION_RECTS((RegionPtr)pValue);

+      pBox = RegionRects((RegionPtr)pValue);

       for (i = nRects; i-- > 0; ) {

 	pRects[i].x = pBox[i].x1;

 	pRects[i].y = pBox[i].y1;

@@ -277,7 +276,7 @@ xnestChangeClip(GCPtr pGC, int type, pointer pValue, int nRects)
        * other parts of server can only deal with CT_NONE,

        * CT_PIXMAP and CT_REGION client clips.

        */

-      pGC->clientClip = (pointer) RECTS_TO_REGION(pGC->pScreen, nRects,

+      pGC->clientClip = (pointer) RegionFromRects(nRects,

 						  (xRectangle *)pValue, type);

       free(pValue);

       pValue = pGC->clientClip;

@@ -313,7 +312,7 @@ xnestDestroyClipHelper(GCPtr pGC)
       break;

       

     case CT_REGION:

-      REGION_DESTROY(pGC->pScreen, pGC->clientClip); 

+      RegionDestroy(pGC->clientClip);

       break;

     }

 }

@@ -331,8 +330,8 @@ xnestCopyClip(GCPtr pGCDst, GCPtr pGCSrc)
       break;

 

     case CT_REGION:

-      pRgn = REGION_CREATE(pGCDst->pScreen, NULL, 1);

-      REGION_COPY(pGCDst->pScreen, pRgn, pGCSrc->clientClip);

+      pRgn = RegionCreate(NULL, 1);

+      RegionCopy(pRgn, pGCSrc->clientClip);

       xnestChangeClip(pGCDst, CT_REGION, pRgn, 0);

       break;

     }

diff --git a/xorg-server/hw/xnest/GCOps.c b/xorg-server/hw/xnest/GCOps.c
index ad9668ec1..d19ec6710 100644
--- a/xorg-server/hw/xnest/GCOps.c
+++ b/xorg-server/hw/xnest/GCOps.c
@@ -1,327 +1,327 @@
-/*
-
-Copyright 1993 by Davor Matic
-
-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.  Davor Matic makes no representations about
-the suitability of this software for any purpose.  It is provided "as
-is" without express or implied warranty.
-
-*/
-
-#ifdef HAVE_XNEST_CONFIG_H
-#include <xnest-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "regionstr.h"
-#include <X11/fonts/fontstruct.h>
-#include "gcstruct.h"
-#include "scrnintstr.h"
-#include "windowstr.h"
-#include "pixmapstr.h"
-#include "region.h"
-#include "servermd.h"
-
-#include "Xnest.h"
-
-#include "Display.h"
-#include "Screen.h"
-#include "XNGC.h"
-#include "XNFont.h"
-#include "GCOps.h"
-#include "Drawable.h"
-#include "Visual.h"
-
-void
-xnestFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nSpans, xPoint *pPoints,
-	       int *pWidths, int fSorted)
-{
-  ErrorF("xnest warning: function xnestFillSpans not implemented\n");
-}
-
-void
-xnestSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *pSrc,
-	      xPoint *pPoints, int *pWidths, int nSpans, int fSorted)
-{
-  ErrorF("xnest warning: function xnestSetSpans not implemented\n");
-}
-
-void
-xnestGetSpans(DrawablePtr pDrawable, int maxWidth, DDXPointPtr pPoints,
-	      int *pWidths, int nSpans, char *pBuffer)
-{
-  ErrorF("xnest warning: function xnestGetSpans not implemented\n");
-}
-
-void
-xnestQueryBestSize(int class, unsigned short *pWidth, unsigned short *pHeight,
-		   ScreenPtr pScreen)
-{
-  unsigned int width, height;
-
-  width = *pWidth;
-  height = *pHeight;
-
-  XQueryBestSize(xnestDisplay, class, 
-		 xnestDefaultWindows[pScreen->myNum], 
-		 width, height, &width, &height);
-  
-  *pWidth = width;
-  *pHeight = height;
-}
-
-void
-xnestPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
-	      int w, int h, int leftPad, int format, char *pImage)
-{
-  XImage *ximage;
-  
-  ximage = XCreateImage(xnestDisplay, xnestDefaultVisual(pDrawable->pScreen), 
-			depth, format, leftPad, (char *)pImage, 
-			w, h, BitmapPad(xnestDisplay), 
-			(format == ZPixmap) ? 
-			   PixmapBytePad(w, depth) : BitmapBytePad(w+leftPad));
-  
-  if (ximage) {
-      XPutImage(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 
-		ximage, 0, 0, x, y, w, h);
-      XFree(ximage);
-  }
-}
-
-void
-xnestGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
-	      unsigned int format, unsigned long planeMask,
-	      char *pImage)
-{
-  XImage *ximage;
-  int length;
-
-  ximage = XGetImage(xnestDisplay, xnestDrawable(pDrawable),
-                     x, y, w, h, planeMask, format);
-
-  if (ximage) {
-      length = ximage->bytes_per_line * ximage->height;
-  
-      memmove(pImage, ximage->data, length);
-  
-      XDestroyImage(ximage);
-  }
-}
-
-static Bool
-xnestBitBlitPredicate(Display *display, XEvent *event, char *args)
-{
-  return (event->type == GraphicsExpose || event->type == NoExpose);
-}
-
-static RegionPtr
-xnestBitBlitHelper(GCPtr pGC)
-{
-  if (!pGC->graphicsExposures) 
-    return NullRegion;
-  else {
-    XEvent event;
-    RegionPtr pReg, pTmpReg;
-    BoxRec Box;
-    Bool pending, overlap;
-
-    pReg = REGION_CREATE(pGC->pScreen, NULL, 1);
-    pTmpReg = REGION_CREATE(pGC->pScreen, NULL, 1);
-    if(!pReg || !pTmpReg) return NullRegion;
-    
-    pending = True;
-    while (pending) {
-      XIfEvent(xnestDisplay, &event, xnestBitBlitPredicate, NULL);
-      
-      switch (event.type) {
-      case NoExpose:
-	pending = False;
-	break;
-	
-      case GraphicsExpose:
-	Box.x1 = event.xgraphicsexpose.x;
-	Box.y1 = event.xgraphicsexpose.y;
-	Box.x2 = event.xgraphicsexpose.x + event.xgraphicsexpose.width;
-	Box.y2 = event.xgraphicsexpose.y + event.xgraphicsexpose.height;
-	REGION_RESET(pGC->pScreen, pTmpReg, &Box);
-	REGION_APPEND(pGC->pScreen, pReg, pTmpReg);
-	pending = event.xgraphicsexpose.count;
-	break;
-      }
-    }
-
-    REGION_DESTROY(pGC->pScreen, pTmpReg);
-    REGION_VALIDATE(pGC->pScreen, pReg, &overlap);
-    return(pReg);
-  }
-}
-
-RegionPtr
-xnestCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
-	      GCPtr pGC, int srcx, int srcy, int width, int height,
-	      int dstx, int dsty)
-{
-  XCopyArea(xnestDisplay, 
-	    xnestDrawable(pSrcDrawable), xnestDrawable(pDstDrawable),
-	    xnestGC(pGC), srcx, srcy, width, height, dstx, dsty);
-  
-  return xnestBitBlitHelper(pGC);
-}
-
-RegionPtr
-xnestCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
-	       GCPtr pGC, int srcx, int srcy, int width, int height,
-	       int dstx, int dsty, unsigned long plane)
-{
-  XCopyPlane(xnestDisplay, 
-	     xnestDrawable(pSrcDrawable), xnestDrawable(pDstDrawable),
-	     xnestGC(pGC), srcx, srcy, width, height, dstx, dsty, plane);
-  
-  return xnestBitBlitHelper(pGC);
-}
-
-void
-xnestPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,
-	       DDXPointPtr pPoints)
-{
-  XDrawPoints(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 
-              (XPoint *)pPoints, nPoints, mode);
-}
-
-void
-xnestPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,
-	       DDXPointPtr pPoints)
-{
-  XDrawLines(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 
-              (XPoint *)pPoints, nPoints, mode);
-}
-
-void
-xnestPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nSegments,
-		 xSegment *pSegments)
-{
-  XDrawSegments(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 
-                (XSegment *)pSegments, nSegments);
-}
-
-void
-xnestPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,
-		   xRectangle *pRectangles)
-{
-  XDrawRectangles(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
-                  (XRectangle *)pRectangles, nRectangles);
-}
-
-void
-xnestPolyArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc *pArcs)
-{
-  XDrawArcs(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
-            (XArc *)pArcs, nArcs);
-}
-
-void
-xnestFillPolygon(DrawablePtr pDrawable, GCPtr pGC, int shape, int mode,
-		 int nPoints, DDXPointPtr pPoints)
-{
-  XFillPolygon(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 
-               (XPoint *)pPoints, nPoints, shape, mode);
-}
-
-void
-xnestPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,
-		  xRectangle *pRectangles)
-{
-  XFillRectangles(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
-                  (XRectangle *)pRectangles, nRectangles);
-}
-
-void
-xnestPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc *pArcs)
-{
-  XFillArcs(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
-            (XArc *)pArcs, nArcs);
-}
-
-int
-xnestPolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
-	       char *string)
-{
-  int width;
-
-  XDrawString(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
-              x, y, string, count);
-  
-  width = XTextWidth(xnestFontStruct(pGC->font), string, count);
-  
-  return width + x;
-}
-
-int
-xnestPolyText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
-		unsigned short *string)
-{
-  int width;
-
-  XDrawString16(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
-                x, y, (XChar2b *)string, count);
-
-  width = XTextWidth16(xnestFontStruct(pGC->font), (XChar2b *)string, count);
-
-  return width + x;
-}
-
-void
-xnestImageText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
-		char *string)
-{
-  XDrawImageString(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
-                   x, y, string, count);
-}
-
-void
-xnestImageText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
-		 unsigned short *string)
-{
-  XDrawImageString16(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
-                     x, y, (XChar2b *)string, count);
-}
-
-void
-xnestImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
-		   unsigned int nGlyphs, CharInfoPtr *pCharInfo,
-		   pointer pGlyphBase)
-{
-  ErrorF("xnest warning: function xnestImageGlyphBlt not implemented\n");
-}
-
-void
-xnestPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
-		  unsigned int nGlyphs, CharInfoPtr *pCharInfo,
-		  pointer pGlyphBase)
-{
-  ErrorF("xnest warning: function xnestPolyGlyphBlt not implemented\n");
-}
-
-void
-xnestPushPixels(GCPtr pGC, PixmapPtr pBitmap, DrawablePtr pDst,
-		int width, int height, int x, int y)
-{
-  /* only works for solid bitmaps */
-  if (pGC->fillStyle == FillSolid)
-  {
-    XSetStipple (xnestDisplay, xnestGC(pGC), xnestPixmap(pBitmap));
-    XSetTSOrigin (xnestDisplay, xnestGC(pGC), x, y);
-    XSetFillStyle (xnestDisplay, xnestGC(pGC), FillStippled);
-    XFillRectangle (xnestDisplay, xnestDrawable(pDst),
-		    xnestGC(pGC), x, y, width, height);
-    XSetFillStyle (xnestDisplay, xnestGC(pGC), FillSolid);
-  }
-  else
-    ErrorF("xnest warning: function xnestPushPixels not implemented\n");
-}
+/*

+

+Copyright 1993 by Davor Matic

+

+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.  Davor Matic makes no representations about

+the suitability of this software for any purpose.  It is provided "as

+is" without express or implied warranty.

+

+*/

+

+#ifdef HAVE_XNEST_CONFIG_H

+#include <xnest-config.h>

+#endif

+

+#include <X11/X.h>

+#include <X11/Xproto.h>

+#include "regionstr.h"

+#include <X11/fonts/fontstruct.h>

+#include "gcstruct.h"

+#include "scrnintstr.h"

+#include "windowstr.h"

+#include "pixmapstr.h"

+#include "region.h"

+#include "servermd.h"

+

+#include "Xnest.h"

+

+#include "Display.h"

+#include "Screen.h"

+#include "XNGC.h"

+#include "XNFont.h"

+#include "GCOps.h"

+#include "Drawable.h"

+#include "Visual.h"

+

+void

+xnestFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nSpans, xPoint *pPoints,

+	       int *pWidths, int fSorted)

+{

+  ErrorF("xnest warning: function xnestFillSpans not implemented\n");

+}

+

+void

+xnestSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *pSrc,

+	      xPoint *pPoints, int *pWidths, int nSpans, int fSorted)

+{

+  ErrorF("xnest warning: function xnestSetSpans not implemented\n");

+}

+

+void

+xnestGetSpans(DrawablePtr pDrawable, int maxWidth, DDXPointPtr pPoints,

+	      int *pWidths, int nSpans, char *pBuffer)

+{

+  ErrorF("xnest warning: function xnestGetSpans not implemented\n");

+}

+

+void

+xnestQueryBestSize(int class, unsigned short *pWidth, unsigned short *pHeight,

+		   ScreenPtr pScreen)

+{

+  unsigned int width, height;

+

+  width = *pWidth;

+  height = *pHeight;

+

+  XQueryBestSize(xnestDisplay, class, 

+		 xnestDefaultWindows[pScreen->myNum], 

+		 width, height, &width, &height);

+  

+  *pWidth = width;

+  *pHeight = height;

+}

+

+void

+xnestPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,

+	      int w, int h, int leftPad, int format, char *pImage)

+{

+  XImage *ximage;

+  

+  ximage = XCreateImage(xnestDisplay, xnestDefaultVisual(pDrawable->pScreen), 

+			depth, format, leftPad, (char *)pImage, 

+			w, h, BitmapPad(xnestDisplay), 

+			(format == ZPixmap) ? 

+			   PixmapBytePad(w, depth) : BitmapBytePad(w+leftPad));

+  

+  if (ximage) {

+      XPutImage(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

+		ximage, 0, 0, x, y, w, h);

+      XFree(ximage);

+  }

+}

+

+void

+xnestGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,

+	      unsigned int format, unsigned long planeMask,

+	      char *pImage)

+{

+  XImage *ximage;

+  int length;

+

+  ximage = XGetImage(xnestDisplay, xnestDrawable(pDrawable),

+                     x, y, w, h, planeMask, format);

+

+  if (ximage) {

+      length = ximage->bytes_per_line * ximage->height;

+  

+      memmove(pImage, ximage->data, length);

+  

+      XDestroyImage(ximage);

+  }

+}

+

+static Bool

+xnestBitBlitPredicate(Display *display, XEvent *event, char *args)

+{

+  return event->type == GraphicsExpose || event->type == NoExpose;

+}

+

+static RegionPtr

+xnestBitBlitHelper(GCPtr pGC)

+{

+  if (!pGC->graphicsExposures) 

+    return NullRegion;

+  else {

+    XEvent event;

+    RegionPtr pReg, pTmpReg;

+    BoxRec Box;

+    Bool pending, overlap;

+

+    pReg = RegionCreate(NULL, 1);

+    pTmpReg = RegionCreate(NULL, 1);

+    if(!pReg || !pTmpReg) return NullRegion;

+    

+    pending = True;

+    while (pending) {

+      XIfEvent(xnestDisplay, &event, xnestBitBlitPredicate, NULL);

+      

+      switch (event.type) {

+      case NoExpose:

+	pending = False;

+	break;

+	

+      case GraphicsExpose:

+	Box.x1 = event.xgraphicsexpose.x;

+	Box.y1 = event.xgraphicsexpose.y;

+	Box.x2 = event.xgraphicsexpose.x + event.xgraphicsexpose.width;

+	Box.y2 = event.xgraphicsexpose.y + event.xgraphicsexpose.height;

+	RegionReset(pTmpReg, &Box);

+	RegionAppend(pReg, pTmpReg);

+	pending = event.xgraphicsexpose.count;

+	break;

+      }

+    }

+

+    RegionDestroy(pTmpReg);

+    RegionValidate(pReg, &overlap);

+    return pReg;

+  }

+}

+

+RegionPtr

+xnestCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,

+	      GCPtr pGC, int srcx, int srcy, int width, int height,

+	      int dstx, int dsty)

+{

+  XCopyArea(xnestDisplay, 

+	    xnestDrawable(pSrcDrawable), xnestDrawable(pDstDrawable),

+	    xnestGC(pGC), srcx, srcy, width, height, dstx, dsty);

+  

+  return xnestBitBlitHelper(pGC);

+}

+

+RegionPtr

+xnestCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,

+	       GCPtr pGC, int srcx, int srcy, int width, int height,

+	       int dstx, int dsty, unsigned long plane)

+{

+  XCopyPlane(xnestDisplay, 

+	     xnestDrawable(pSrcDrawable), xnestDrawable(pDstDrawable),

+	     xnestGC(pGC), srcx, srcy, width, height, dstx, dsty, plane);

+  

+  return xnestBitBlitHelper(pGC);

+}

+

+void

+xnestPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,

+	       DDXPointPtr pPoints)

+{

+  XDrawPoints(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

+              (XPoint *)pPoints, nPoints, mode);

+}

+

+void

+xnestPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,

+	       DDXPointPtr pPoints)

+{

+  XDrawLines(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

+              (XPoint *)pPoints, nPoints, mode);

+}

+

+void

+xnestPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nSegments,

+		 xSegment *pSegments)

+{

+  XDrawSegments(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

+                (XSegment *)pSegments, nSegments);

+}

+

+void

+xnestPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,

+		   xRectangle *pRectangles)

+{

+  XDrawRectangles(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

+                  (XRectangle *)pRectangles, nRectangles);

+}

+

+void

+xnestPolyArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc *pArcs)

+{

+  XDrawArcs(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

+            (XArc *)pArcs, nArcs);

+}

+

+void

+xnestFillPolygon(DrawablePtr pDrawable, GCPtr pGC, int shape, int mode,

+		 int nPoints, DDXPointPtr pPoints)

+{

+  XFillPolygon(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

+               (XPoint *)pPoints, nPoints, shape, mode);

+}

+

+void

+xnestPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,

+		  xRectangle *pRectangles)

+{

+  XFillRectangles(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

+                  (XRectangle *)pRectangles, nRectangles);

+}

+

+void

+xnestPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc *pArcs)

+{

+  XFillArcs(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

+            (XArc *)pArcs, nArcs);

+}

+

+int

+xnestPolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,

+	       char *string)

+{

+  int width;

+

+  XDrawString(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

+              x, y, string, count);

+  

+  width = XTextWidth(xnestFontStruct(pGC->font), string, count);

+  

+  return width + x;

+}

+

+int

+xnestPolyText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,

+		unsigned short *string)

+{

+  int width;

+

+  XDrawString16(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

+                x, y, (XChar2b *)string, count);

+

+  width = XTextWidth16(xnestFontStruct(pGC->font), (XChar2b *)string, count);

+

+  return width + x;

+}

+

+void

+xnestImageText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,

+		char *string)

+{

+  XDrawImageString(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

+                   x, y, string, count);

+}

+

+void

+xnestImageText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,

+		 unsigned short *string)

+{

+  XDrawImageString16(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

+                     x, y, (XChar2b *)string, count);

+}

+

+void

+xnestImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,

+		   unsigned int nGlyphs, CharInfoPtr *pCharInfo,

+		   pointer pGlyphBase)

+{

+  ErrorF("xnest warning: function xnestImageGlyphBlt not implemented\n");

+}

+

+void

+xnestPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,

+		  unsigned int nGlyphs, CharInfoPtr *pCharInfo,

+		  pointer pGlyphBase)

+{

+  ErrorF("xnest warning: function xnestPolyGlyphBlt not implemented\n");

+}

+

+void

+xnestPushPixels(GCPtr pGC, PixmapPtr pBitmap, DrawablePtr pDst,

+		int width, int height, int x, int y)

+{

+  /* only works for solid bitmaps */

+  if (pGC->fillStyle == FillSolid)

+  {

+    XSetStipple (xnestDisplay, xnestGC(pGC), xnestPixmap(pBitmap));

+    XSetTSOrigin (xnestDisplay, xnestGC(pGC), x, y);

+    XSetFillStyle (xnestDisplay, xnestGC(pGC), FillStippled);

+    XFillRectangle (xnestDisplay, xnestDrawable(pDst),

+		    xnestGC(pGC), x, y, width, height);

+    XSetFillStyle (xnestDisplay, xnestGC(pGC), FillSolid);

+  }

+  else

+    ErrorF("xnest warning: function xnestPushPixels not implemented\n");

+}

diff --git a/xorg-server/hw/xnest/Pixmap.c b/xorg-server/hw/xnest/Pixmap.c
index cd2245b46..da81a1d06 100644
--- a/xorg-server/hw/xnest/Pixmap.c
+++ b/xorg-server/hw/xnest/Pixmap.c
@@ -33,8 +33,7 @@ is" without express or implied warranty.
 #include "Screen.h"

 #include "XNPixmap.h"

 

-static int xnestPixmapPrivateKeyIndex;

-DevPrivateKey xnestPixmapPrivateKey = &xnestPixmapPrivateKeyIndex;

+DevPrivateKeyRec xnestPixmapPrivateKeyRec;

 

 PixmapPtr

 xnestCreatePixmap(ScreenPtr pScreen, int width, int height, int depth,

@@ -42,7 +41,7 @@ xnestCreatePixmap(ScreenPtr pScreen, int width, int height, int depth,
 {

   PixmapPtr pPixmap;

 

-  pPixmap = AllocatePixmap(pScreen, sizeof(xnestPrivPixmap));

+  pPixmap = AllocatePixmap(pScreen, 0);

   if (!pPixmap)

     return NullPixmap;

   pPixmap->drawable.type = DRAWABLE_PIXMAP;

@@ -59,8 +58,6 @@ xnestCreatePixmap(ScreenPtr pScreen, int width, int height, int depth,
   pPixmap->refcnt = 1;

   pPixmap->devKind = PixmapBytePad(width, depth);

   pPixmap->usage_hint = usage_hint;

-  dixSetPrivate(&pPixmap->devPrivates, xnestPixmapPrivateKey,

-		(char *)pPixmap + pScreen->totalPixmapSize);

   if (width && height)

       xnestPixmapPriv(pPixmap)->pixmap = 

 	  XCreatePixmap(xnestDisplay, 

@@ -78,8 +75,7 @@ xnestDestroyPixmap(PixmapPtr pPixmap)
   if(--pPixmap->refcnt)

     return TRUE;

   XFreePixmap(xnestDisplay, xnestPixmap(pPixmap));

-  dixFreePrivates(pPixmap->devPrivates);

-  free(pPixmap);

+  FreePixmap(pPixmap);

   return TRUE;

 }

 

@@ -97,8 +93,8 @@ xnestPixmapToRegion(PixmapPtr pPixmap)
 		     pPixmap->drawable.width, pPixmap->drawable.height,

 		     1, XYPixmap);

   

-  pReg = REGION_CREATE(pPixmap->drawable.pScreen, NULL, 1);

-  pTmpReg = REGION_CREATE(pPixmap->drawable.pScreen, NULL, 1);

+  pReg = RegionCreate(NULL, 1);

+  pTmpReg = RegionCreate(NULL, 1);

   if(!pReg || !pTmpReg) {

       XDestroyImage(ximage);

       return NullRegion;

@@ -118,8 +114,8 @@ xnestPixmapToRegion(PixmapPtr pPixmap)
 	else if (currentPixel == 0L) {

 	  /* right edge */

 	  Box.x2 = x;

-	  REGION_RESET(pPixmap->drawable.pScreen, pTmpReg, &Box);

-	  REGION_APPEND(pPixmap->drawable.pScreen, pReg, pTmpReg);

+	  RegionReset(pTmpReg, &Box);

+	  RegionAppend(pReg, pTmpReg);

 	}

 	previousPixel = currentPixel;

       }

@@ -127,15 +123,15 @@ xnestPixmapToRegion(PixmapPtr pPixmap)
     if (previousPixel != 0L) {

       /* right edge because of the end of pixmap */

       Box.x2 = pPixmap->drawable.width;

-      REGION_RESET(pPixmap->drawable.pScreen, pTmpReg, &Box);

-      REGION_APPEND(pPixmap->drawable.pScreen, pReg, pTmpReg);

+      RegionReset(pTmpReg, &Box);

+      RegionAppend(pReg, pTmpReg);

     }

   }

   

-  REGION_DESTROY(pPixmap->drawable.pScreen, pTmpReg);

+  RegionDestroy(pTmpReg);

   XDestroyImage(ximage);

 

-  REGION_VALIDATE(pPixmap->drawable.pScreen, pReg, &overlap);

+  RegionValidate(pReg, &overlap);

 

-  return(pReg);

+  return pReg;

 }

diff --git a/xorg-server/hw/xnest/Screen.c b/xorg-server/hw/xnest/Screen.c
index d25666508..cf225d0ab 100644
--- a/xorg-server/hw/xnest/Screen.c
+++ b/xorg-server/hw/xnest/Screen.c
@@ -45,8 +45,7 @@ is" without express or implied warranty.
 

 Window xnestDefaultWindows[MAXSCREENS];

 Window xnestScreenSaverWindows[MAXSCREENS];

-static int xnestCursorScreenKeyIndex;

-DevPrivateKey xnestCursorScreenKey = &xnestCursorScreenKeyIndex;

+DevPrivateKeyRec xnestCursorScreenKeyRec;

 

 ScreenPtr

 xnestScreen(Window window)

@@ -146,10 +145,14 @@ xnestOpenScreen(int index, ScreenPtr pScreen, int argc, char *argv[])
   int rootDepth;

   miPointerScreenPtr PointPriv;

 

-  if (!dixRequestPrivate(xnestWindowPrivateKey, sizeof(xnestPrivWin)))

-      return False;

-  if (!dixRequestPrivate(xnestGCPrivateKey, sizeof(xnestPrivGC)))

-    return False;

+  if (!dixRegisterPrivateKey(&xnestWindowPrivateKeyRec, PRIVATE_WINDOW, sizeof(xnestPrivWin)))

+      return FALSE;

+  if (!dixRegisterPrivateKey(&xnestGCPrivateKeyRec, PRIVATE_GC, sizeof(xnestPrivGC)))

+    return FALSE;

+  if (!dixRegisterPrivateKey(&xnestPixmapPrivateKeyRec, PRIVATE_PIXMAP, sizeof (xnestPrivPixmap)))

+      return FALSE;

+  if (!dixRegisterPrivateKey(&xnestCursorScreenKeyRec, PRIVATE_SCREEN, 0))

+      return FALSE;

 

   visuals = (VisualPtr)malloc(xnestNumVisuals * sizeof(VisualRec));

   numVisuals = 0;

diff --git a/xorg-server/hw/xnest/Window.c b/xorg-server/hw/xnest/Window.c
index 48c870fac..7ef3d8b96 100644
--- a/xorg-server/hw/xnest/Window.c
+++ b/xorg-server/hw/xnest/Window.c
@@ -1,526 +1,519 @@
-/*
-
-Copyright 1993 by Davor Matic
-
-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.  Davor Matic makes no representations about
-the suitability of this software for any purpose.  It is provided "as
-is" without express or implied warranty.
-
-*/
-
-#ifdef HAVE_XNEST_CONFIG_H
-#include <xnest-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "gcstruct.h"
-#include "window.h"
-#include "windowstr.h"
-#include "pixmapstr.h"
-#include "colormapst.h"
-#include "scrnintstr.h"
-#include "region.h"
-
-#include "mi.h"
-
-#include "Xnest.h"
-
-#include "Display.h"
-#include "Screen.h"
-#include "XNGC.h"
-#include "Drawable.h"
-#include "Color.h"
-#include "Visual.h"
-#include "Events.h"
-#include "Args.h"
-
-static int xnestWindowPrivateKeyIndex;
-DevPrivateKey xnestWindowPrivateKey = &xnestWindowPrivateKeyIndex;
-
-static int
-xnestFindWindowMatch(WindowPtr pWin, pointer ptr)
-{
-  xnestWindowMatch *wm = (xnestWindowMatch *)ptr;
-  if (wm->window == xnestWindow(pWin)) {
-    wm->pWin = pWin;
-    return WT_STOPWALKING;
-  }
-  else
-    return WT_WALKCHILDREN;
-}
-
-WindowPtr
-xnestWindowPtr(Window window)
-{
-  xnestWindowMatch wm;
-  int i;
-
-  wm.pWin = NullWindow;
-  wm.window = window;
-
-  for (i = 0; i < xnestNumScreens; i++) {
-    WalkTree(screenInfo.screens[i], xnestFindWindowMatch, (pointer) &wm);
-    if (wm.pWin) break;
-  }
-  
-  return wm.pWin;
-}
-    
-Bool
-xnestCreateWindow(WindowPtr pWin)
-{
-  unsigned long mask;
-  XSetWindowAttributes attributes;
-  Visual *visual;
-  ColormapPtr pCmap;
-
-  if (pWin->drawable.class == InputOnly) {
-    mask = 0L;
-    visual = CopyFromParent;
-  }
-  else {
-    mask = CWEventMask | CWBackingStore;
-    attributes.event_mask = ExposureMask;
-    attributes.backing_store = NotUseful;
-    
-    if (pWin->parent) {
-      if (pWin->optional && pWin->optional->visual != wVisual(pWin->parent)) {
-	visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));
-	mask |= CWColormap;
-	if (pWin->optional->colormap) {
-	  dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin),
-				  RT_COLORMAP, serverClient, DixUseAccess);
-	  attributes.colormap = xnestColormap(pCmap);
-	}
-	else
-	  attributes.colormap = xnestDefaultVisualColormap(visual);
-      }
-      else 
-	visual = CopyFromParent;
-    }
-    else { /* root windows have their own colormaps at creation time */
-      visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));      
-      dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin),
-			      RT_COLORMAP, serverClient, DixUseAccess);
-      mask |= CWColormap;
-      attributes.colormap = xnestColormap(pCmap);
-    }
-  }
-  
-  xnestWindowPriv(pWin)->window = XCreateWindow(xnestDisplay,
-						xnestWindowParent(pWin),
-						pWin->origin.x - 
-						wBorderWidth(pWin),
-						pWin->origin.y - 
-						wBorderWidth(pWin),
-						pWin->drawable.width,
-						pWin->drawable.height,
-						pWin->borderWidth,
-						pWin->drawable.depth, 
-						pWin->drawable.class,
-						visual,
-						mask, &attributes);
-  xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
-  xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
-  xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
-  xnestWindowPriv(pWin)->width = pWin->drawable.width;
-  xnestWindowPriv(pWin)->height = pWin->drawable.height;
-  xnestWindowPriv(pWin)->border_width = pWin->borderWidth;
-  xnestWindowPriv(pWin)->sibling_above = None;
-  if (pWin->nextSib)
-    xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
-  xnestWindowPriv(pWin)->bounding_shape = 
-    REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
-  xnestWindowPriv(pWin)->clip_shape = 
-    REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
-
-  if (!pWin->parent) /* only the root window will have the right colormap */
-    xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
-  
-  return True;
-}
-
-Bool
-xnestDestroyWindow(WindowPtr pWin)
-{
-  if (pWin->nextSib)
-    xnestWindowPriv(pWin->nextSib)->sibling_above = 
-      xnestWindowPriv(pWin)->sibling_above;
-  REGION_DESTROY(pWin->drawable.pScreen, 
-				xnestWindowPriv(pWin)->bounding_shape);
-  REGION_DESTROY(pWin->drawable.pScreen, 
-				xnestWindowPriv(pWin)->clip_shape);
-  XDestroyWindow(xnestDisplay, xnestWindow(pWin));
-  xnestWindowPriv(pWin)->window = None;
-
-  if (pWin->optional && pWin->optional->colormap && pWin->parent)
-    xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
-
-  return True;
-}
-
-Bool
-xnestPositionWindow(WindowPtr pWin, int x, int y)
-{
-  xnestConfigureWindow(pWin, 
-		       CWParent |
-		       CWX | CWY | 
-		       CWWidth | CWHeight | 
-		       CWBorderWidth);
-  
-  return True;
-}
-
-void
-xnestConfigureWindow(WindowPtr pWin, unsigned int mask)
-{
-  unsigned int valuemask;
-  XWindowChanges values;
-
-  if (mask & CWParent &&
-      xnestWindowPriv(pWin)->parent != xnestWindowParent(pWin)) {
-    XReparentWindow(xnestDisplay, xnestWindow(pWin), 
-		    xnestWindowParent(pWin), 
-		    pWin->origin.x - wBorderWidth(pWin),
-		    pWin->origin.y - wBorderWidth(pWin));
-    xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
-    xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
-    xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
-    xnestWindowPriv(pWin)->sibling_above = None;
-    if (pWin->nextSib)
-      xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
-  }
-  
-  valuemask = 0;
-  
-  if (mask & CWX &&
-      xnestWindowPriv(pWin)->x != pWin->origin.x - wBorderWidth(pWin)) {
-    valuemask |= CWX;
-    values.x =
-      xnestWindowPriv(pWin)->x = 
-	pWin->origin.x - wBorderWidth(pWin);
-  }
-
-  if (mask & CWY &&
-      xnestWindowPriv(pWin)->y != pWin->origin.y - wBorderWidth(pWin)) {
-    valuemask |= CWY;
-    values.y =
-      xnestWindowPriv(pWin)->y = 
-	pWin->origin.y - wBorderWidth(pWin);
-  }
-
-  if (mask & CWWidth &&
-      xnestWindowPriv(pWin)->width != pWin->drawable.width) {
-    valuemask |= CWWidth;
-    values.width = 
-      xnestWindowPriv(pWin)->width = 
-	pWin->drawable.width;
-  }
-  
-  if (mask & CWHeight &&
-      xnestWindowPriv(pWin)->height != pWin->drawable.height) {
-    valuemask |= CWHeight;
-    values.height = 
-      xnestWindowPriv(pWin)->height = 
-	pWin->drawable.height;
-  }
-  
-  if (mask & CWBorderWidth &&
-      xnestWindowPriv(pWin)->border_width != pWin->borderWidth) {
-    valuemask |= CWBorderWidth;
-    values.border_width = 
-      xnestWindowPriv(pWin)->border_width = 
-	pWin->borderWidth;
-  }
- 
-  if (valuemask)
-    XConfigureWindow(xnestDisplay, xnestWindow(pWin), valuemask, &values);  
-  
-  if (mask & CWStackingOrder &&
-      xnestWindowPriv(pWin)->sibling_above != xnestWindowSiblingAbove(pWin)) {
-    WindowPtr pSib;
-    
-    /* find the top sibling */
-    for (pSib = pWin; pSib->prevSib != NullWindow; pSib = pSib->prevSib);
-    
-    /* the top sibling */
-    valuemask = CWStackMode;
-    values.stack_mode = Above;
-    XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values); 
-    xnestWindowPriv(pSib)->sibling_above = None;
-
-    /* the rest of siblings */
-    for (pSib = pSib->nextSib; pSib != NullWindow; pSib = pSib->nextSib) {
-      valuemask = CWSibling | CWStackMode;
-      values.sibling = xnestWindowSiblingAbove(pSib);
-      values.stack_mode = Below;
-      XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values);
-      xnestWindowPriv(pSib)->sibling_above = xnestWindowSiblingAbove(pSib);
-    }
-  }
-}
-
-Bool
-xnestChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
-{
-  XSetWindowAttributes attributes;
-  
-  if (mask & CWBackPixmap)
-    switch (pWin->backgroundState) {
-    case None:
-      attributes.background_pixmap = None;
-      break;
-      
-    case ParentRelative:
-      attributes.background_pixmap = ParentRelative;
-      break;
-      
-    case BackgroundPixmap:
-      attributes.background_pixmap = xnestPixmap(pWin->background.pixmap);
-      break;
-
-    case BackgroundPixel:
-      mask &= ~CWBackPixmap;  
-      break;
-    }
-
-  if (mask & CWBackPixel) {
-    if (pWin->backgroundState == BackgroundPixel)
-      attributes.background_pixel = xnestPixel(pWin->background.pixel);
-    else
-      mask &= ~CWBackPixel;
-  }
-  
-  if (mask & CWBorderPixmap) {
-    if (pWin->borderIsPixel)
-      mask &= ~CWBorderPixmap;
-    else
-      attributes.border_pixmap = xnestPixmap(pWin->border.pixmap);
-  }
-  
-  if (mask & CWBorderPixel) {
-    if (pWin->borderIsPixel)
-      attributes.border_pixel = xnestPixel(pWin->border.pixel);
-    else
-      mask &= ~CWBorderPixel;
-  }
-  
-  if (mask & CWBitGravity) 
-    attributes.bit_gravity = pWin->bitGravity;
-  
-  if (mask & CWWinGravity) /* dix does this for us */
-    mask &= ~CWWinGravity;
-
-  if (mask & CWBackingStore) /* this is really not useful */
-    mask &= ~CWBackingStore;
-
-  if (mask & CWBackingPlanes) /* this is really not useful */
-    mask &= ~CWBackingPlanes;
-
-  if (mask & CWBackingPixel) /* this is really not useful */ 
-    mask &= ~CWBackingPixel;
-
-  if (mask & CWOverrideRedirect)
-    attributes.override_redirect = pWin->overrideRedirect;
-
-  if (mask & CWSaveUnder) /* this is really not useful */
-    mask &= ~CWSaveUnder;
-
-  if (mask & CWEventMask) /* events are handled elsewhere */
-    mask &= ~CWEventMask;
-
-  if (mask & CWDontPropagate) /* events are handled elsewhere */
-    mask &= ~CWDontPropagate; 
-
-  if (mask & CWColormap) {
-    ColormapPtr pCmap;
-    
-    dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin), RT_COLORMAP,
-			    serverClient, DixUseAccess);
-
-    attributes.colormap = xnestColormap(pCmap);
-
-    xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
-  }
-
-  if (mask & CWCursor) /* this is handeled in cursor code */
-    mask &= ~CWCursor;
-
-  if (mask)
-    XChangeWindowAttributes(xnestDisplay, xnestWindow(pWin),
-			    mask, &attributes);
-  
-  return True;
-}	  
-
-Bool
-xnestRealizeWindow(WindowPtr pWin)
-{
-  xnestConfigureWindow(pWin, CWStackingOrder);
-  xnestShapeWindow(pWin);
-  XMapWindow(xnestDisplay, xnestWindow(pWin));
-
-  return True;
-}
-
-Bool
-xnestUnrealizeWindow(WindowPtr pWin)
-{
-  XUnmapWindow(xnestDisplay, xnestWindow(pWin));
-
-  return True;
-}
-
-void
-xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion)
-{
-}
-
-void
-xnestClipNotify(WindowPtr pWin, int dx, int dy)
-{
-  xnestConfigureWindow(pWin, CWStackingOrder); 
-  xnestShapeWindow(pWin);
-}
-
-static Bool
-xnestWindowExposurePredicate(Display *display, XEvent *event, XPointer ptr)
-{
-  return (event->type == Expose && event->xexpose.window == *(Window *)ptr);
-}
-
-void
-xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)
-{
-  XEvent event;
-  Window window;
-  BoxRec Box;
-  
-  XSync(xnestDisplay, False);
-  
-  window = xnestWindow(pWin);
-  
-  while (XCheckIfEvent(xnestDisplay, &event, 
-		       xnestWindowExposurePredicate, (char *)&window)) {
-    
-    Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + event.xexpose.x;
-    Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + event.xexpose.y;
-    Box.x2 = Box.x1 + event.xexpose.width;
-    Box.y2 = Box.y1 + event.xexpose.height;
-	
-    event.xexpose.type = ProcessedExpose;
-	
-    if (RECT_IN_REGION(pWin->drawable.pScreen, pRgn, &Box) != rgnIN)
-      XPutBackEvent(xnestDisplay, &event);
-  }
-  
-  miWindowExposures(pWin, pRgn, other_exposed);
-}
-
-void
-xnestSetShape(WindowPtr pWin)
-{
-  xnestShapeWindow(pWin);
-  miSetShape(pWin);
-}
-
-static Bool
-xnestRegionEqual(RegionPtr pReg1, RegionPtr pReg2)
-{
-  BoxPtr pBox1, pBox2;
-  unsigned int n1, n2;
-
-  if (pReg1 == pReg2) return True;
-
-  if (pReg1 == NullRegion || pReg2 == NullRegion) return False;
-
-  pBox1 = REGION_RECTS(pReg1);
-  n1 = REGION_NUM_RECTS(pReg1);
-
-  pBox2 = REGION_RECTS(pReg2);
-  n2 = REGION_NUM_RECTS(pReg2);
-
-  if (n1 != n2) return False;
-
-  if (pBox1 == pBox2) return True;
-
-  if (memcmp(pBox1, pBox2, n1 * sizeof(BoxRec))) return False;
-
-  return True;
-}
-
-void
-xnestShapeWindow(WindowPtr pWin)
-{
-  Region reg;
-  BoxPtr pBox;
-  XRectangle rect;
-  int i;
-
-  if (!xnestRegionEqual(xnestWindowPriv(pWin)->bounding_shape,
-			wBoundingShape(pWin))) {
-    
-    if (wBoundingShape(pWin)) {
-      REGION_COPY(pWin->drawable.pScreen, 
-		xnestWindowPriv(pWin)->bounding_shape, wBoundingShape(pWin));
-      
-      reg = XCreateRegion();
-      pBox = REGION_RECTS(xnestWindowPriv(pWin)->bounding_shape);
-      for (i = 0; 
-	   i < REGION_NUM_RECTS(xnestWindowPriv(pWin)->bounding_shape);
-	   i++) {
-        rect.x = pBox[i].x1;
-        rect.y = pBox[i].y1;
-        rect.width = pBox[i].x2 - pBox[i].x1;
-        rect.height = pBox[i].y2 - pBox[i].y1;
-        XUnionRectWithRegion(&rect, reg, reg);
-      }
-      XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
-			  ShapeBounding, 0, 0, reg, ShapeSet);
-      XDestroyRegion(reg);
-    }
-    else {
-      REGION_EMPTY(pWin->drawable.pScreen, 
-				xnestWindowPriv(pWin)->bounding_shape);
-      
-      XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
-			ShapeBounding, 0, 0, None, ShapeSet);
-    }
-  }
-  
-  if (!xnestRegionEqual(xnestWindowPriv(pWin)->clip_shape,
-			wClipShape(pWin))) {
-    
-    if (wClipShape(pWin)) {
-      REGION_COPY(pWin->drawable.pScreen, 
-			xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin));
-      
-      reg = XCreateRegion();
-      pBox = REGION_RECTS(xnestWindowPriv(pWin)->clip_shape);
-      for (i = 0; 
-	   i < REGION_NUM_RECTS(xnestWindowPriv(pWin)->clip_shape);
-	   i++) {
-        rect.x = pBox[i].x1;
-        rect.y = pBox[i].y1;
-        rect.width = pBox[i].x2 - pBox[i].x1;
-        rect.height = pBox[i].y2 - pBox[i].y1;
-        XUnionRectWithRegion(&rect, reg, reg);
-      }
-      XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
-			  ShapeClip, 0, 0, reg, ShapeSet);
-      XDestroyRegion(reg);
-    }
-    else {
-      REGION_EMPTY(pWin->drawable.pScreen, 
-				     xnestWindowPriv(pWin)->clip_shape);
-      
-      XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
-			ShapeClip, 0, 0, None, ShapeSet);
-    }
-  }
-}
+/*

+

+Copyright 1993 by Davor Matic

+

+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.  Davor Matic makes no representations about

+the suitability of this software for any purpose.  It is provided "as

+is" without express or implied warranty.

+

+*/

+

+#ifdef HAVE_XNEST_CONFIG_H

+#include <xnest-config.h>

+#endif

+

+#include <X11/X.h>

+#include <X11/Xproto.h>

+#include "gcstruct.h"

+#include "window.h"

+#include "windowstr.h"

+#include "pixmapstr.h"

+#include "colormapst.h"

+#include "scrnintstr.h"

+#include "region.h"

+

+#include "mi.h"

+

+#include "Xnest.h"

+

+#include "Display.h"

+#include "Screen.h"

+#include "XNGC.h"

+#include "Drawable.h"

+#include "Color.h"

+#include "Visual.h"

+#include "Events.h"

+#include "Args.h"

+

+DevPrivateKeyRec xnestWindowPrivateKeyRec;

+

+static int

+xnestFindWindowMatch(WindowPtr pWin, pointer ptr)

+{

+  xnestWindowMatch *wm = (xnestWindowMatch *)ptr;

+  if (wm->window == xnestWindow(pWin)) {

+    wm->pWin = pWin;

+    return WT_STOPWALKING;

+  }

+  else

+    return WT_WALKCHILDREN;

+}

+

+WindowPtr

+xnestWindowPtr(Window window)

+{

+  xnestWindowMatch wm;

+  int i;

+

+  wm.pWin = NullWindow;

+  wm.window = window;

+

+  for (i = 0; i < xnestNumScreens; i++) {

+    WalkTree(screenInfo.screens[i], xnestFindWindowMatch, (pointer) &wm);

+    if (wm.pWin) break;

+  }

+  

+  return wm.pWin;

+}

+    

+Bool

+xnestCreateWindow(WindowPtr pWin)

+{

+  unsigned long mask;

+  XSetWindowAttributes attributes;

+  Visual *visual;

+  ColormapPtr pCmap;

+

+  if (pWin->drawable.class == InputOnly) {

+    mask = 0L;

+    visual = CopyFromParent;

+  }

+  else {

+    mask = CWEventMask | CWBackingStore;

+    attributes.event_mask = ExposureMask;

+    attributes.backing_store = NotUseful;

+    

+    if (pWin->parent) {

+      if (pWin->optional && pWin->optional->visual != wVisual(pWin->parent)) {

+	visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));

+	mask |= CWColormap;

+	if (pWin->optional->colormap) {

+	  dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin),

+				  RT_COLORMAP, serverClient, DixUseAccess);

+	  attributes.colormap = xnestColormap(pCmap);

+	}

+	else

+	  attributes.colormap = xnestDefaultVisualColormap(visual);

+      }

+      else 

+	visual = CopyFromParent;

+    }

+    else { /* root windows have their own colormaps at creation time */

+      visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));      

+      dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin),

+			      RT_COLORMAP, serverClient, DixUseAccess);

+      mask |= CWColormap;

+      attributes.colormap = xnestColormap(pCmap);

+    }

+  }

+  

+  xnestWindowPriv(pWin)->window = XCreateWindow(xnestDisplay,

+						xnestWindowParent(pWin),

+						pWin->origin.x - 

+						wBorderWidth(pWin),

+						pWin->origin.y - 

+						wBorderWidth(pWin),

+						pWin->drawable.width,

+						pWin->drawable.height,

+						pWin->borderWidth,

+						pWin->drawable.depth, 

+						pWin->drawable.class,

+						visual,

+						mask, &attributes);

+  xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);

+  xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);

+  xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);

+  xnestWindowPriv(pWin)->width = pWin->drawable.width;

+  xnestWindowPriv(pWin)->height = pWin->drawable.height;

+  xnestWindowPriv(pWin)->border_width = pWin->borderWidth;

+  xnestWindowPriv(pWin)->sibling_above = None;

+  if (pWin->nextSib)

+    xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);

+  xnestWindowPriv(pWin)->bounding_shape = 

+    RegionCreate(NULL, 1);

+  xnestWindowPriv(pWin)->clip_shape = 

+    RegionCreate(NULL, 1);

+

+  if (!pWin->parent) /* only the root window will have the right colormap */

+    xnestSetInstalledColormapWindows(pWin->drawable.pScreen);

+  

+  return True;

+}

+

+Bool

+xnestDestroyWindow(WindowPtr pWin)

+{

+  if (pWin->nextSib)

+    xnestWindowPriv(pWin->nextSib)->sibling_above = 

+      xnestWindowPriv(pWin)->sibling_above;

+  RegionDestroy(xnestWindowPriv(pWin)->bounding_shape);

+  RegionDestroy(xnestWindowPriv(pWin)->clip_shape);

+  XDestroyWindow(xnestDisplay, xnestWindow(pWin));

+  xnestWindowPriv(pWin)->window = None;

+

+  if (pWin->optional && pWin->optional->colormap && pWin->parent)

+    xnestSetInstalledColormapWindows(pWin->drawable.pScreen);

+

+  return True;

+}

+

+Bool

+xnestPositionWindow(WindowPtr pWin, int x, int y)

+{

+  xnestConfigureWindow(pWin, 

+		       CWParent |

+		       CWX | CWY | 

+		       CWWidth | CWHeight | 

+		       CWBorderWidth);

+  

+  return True;

+}

+

+void

+xnestConfigureWindow(WindowPtr pWin, unsigned int mask)

+{

+  unsigned int valuemask;

+  XWindowChanges values;

+

+  if (mask & CWParent &&

+      xnestWindowPriv(pWin)->parent != xnestWindowParent(pWin)) {

+    XReparentWindow(xnestDisplay, xnestWindow(pWin), 

+		    xnestWindowParent(pWin), 

+		    pWin->origin.x - wBorderWidth(pWin),

+		    pWin->origin.y - wBorderWidth(pWin));

+    xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);

+    xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);

+    xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);

+    xnestWindowPriv(pWin)->sibling_above = None;

+    if (pWin->nextSib)

+      xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);

+  }

+  

+  valuemask = 0;

+  

+  if (mask & CWX &&

+      xnestWindowPriv(pWin)->x != pWin->origin.x - wBorderWidth(pWin)) {

+    valuemask |= CWX;

+    values.x =

+      xnestWindowPriv(pWin)->x = 

+	pWin->origin.x - wBorderWidth(pWin);

+  }

+

+  if (mask & CWY &&

+      xnestWindowPriv(pWin)->y != pWin->origin.y - wBorderWidth(pWin)) {

+    valuemask |= CWY;

+    values.y =

+      xnestWindowPriv(pWin)->y = 

+	pWin->origin.y - wBorderWidth(pWin);

+  }

+

+  if (mask & CWWidth &&

+      xnestWindowPriv(pWin)->width != pWin->drawable.width) {

+    valuemask |= CWWidth;

+    values.width = 

+      xnestWindowPriv(pWin)->width = 

+	pWin->drawable.width;

+  }

+  

+  if (mask & CWHeight &&

+      xnestWindowPriv(pWin)->height != pWin->drawable.height) {

+    valuemask |= CWHeight;

+    values.height = 

+      xnestWindowPriv(pWin)->height = 

+	pWin->drawable.height;

+  }

+  

+  if (mask & CWBorderWidth &&

+      xnestWindowPriv(pWin)->border_width != pWin->borderWidth) {

+    valuemask |= CWBorderWidth;

+    values.border_width = 

+      xnestWindowPriv(pWin)->border_width = 

+	pWin->borderWidth;

+  }

+ 

+  if (valuemask)

+    XConfigureWindow(xnestDisplay, xnestWindow(pWin), valuemask, &values);  

+  

+  if (mask & CWStackingOrder &&

+      xnestWindowPriv(pWin)->sibling_above != xnestWindowSiblingAbove(pWin)) {

+    WindowPtr pSib;

+    

+    /* find the top sibling */

+    for (pSib = pWin; pSib->prevSib != NullWindow; pSib = pSib->prevSib);

+    

+    /* the top sibling */

+    valuemask = CWStackMode;

+    values.stack_mode = Above;

+    XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values); 

+    xnestWindowPriv(pSib)->sibling_above = None;

+

+    /* the rest of siblings */

+    for (pSib = pSib->nextSib; pSib != NullWindow; pSib = pSib->nextSib) {

+      valuemask = CWSibling | CWStackMode;

+      values.sibling = xnestWindowSiblingAbove(pSib);

+      values.stack_mode = Below;

+      XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values);

+      xnestWindowPriv(pSib)->sibling_above = xnestWindowSiblingAbove(pSib);

+    }

+  }

+}

+

+Bool

+xnestChangeWindowAttributes(WindowPtr pWin, unsigned long mask)

+{

+  XSetWindowAttributes attributes;

+  

+  if (mask & CWBackPixmap)

+    switch (pWin->backgroundState) {

+    case None:

+      attributes.background_pixmap = None;

+      break;

+      

+    case ParentRelative:

+      attributes.background_pixmap = ParentRelative;

+      break;

+      

+    case BackgroundPixmap:

+      attributes.background_pixmap = xnestPixmap(pWin->background.pixmap);

+      break;

+

+    case BackgroundPixel:

+      mask &= ~CWBackPixmap;  

+      break;

+    }

+

+  if (mask & CWBackPixel) {

+    if (pWin->backgroundState == BackgroundPixel)

+      attributes.background_pixel = xnestPixel(pWin->background.pixel);

+    else

+      mask &= ~CWBackPixel;

+  }

+  

+  if (mask & CWBorderPixmap) {

+    if (pWin->borderIsPixel)

+      mask &= ~CWBorderPixmap;

+    else

+      attributes.border_pixmap = xnestPixmap(pWin->border.pixmap);

+  }

+  

+  if (mask & CWBorderPixel) {

+    if (pWin->borderIsPixel)

+      attributes.border_pixel = xnestPixel(pWin->border.pixel);

+    else

+      mask &= ~CWBorderPixel;

+  }

+  

+  if (mask & CWBitGravity) 

+    attributes.bit_gravity = pWin->bitGravity;

+  

+  if (mask & CWWinGravity) /* dix does this for us */

+    mask &= ~CWWinGravity;

+

+  if (mask & CWBackingStore) /* this is really not useful */

+    mask &= ~CWBackingStore;

+

+  if (mask & CWBackingPlanes) /* this is really not useful */

+    mask &= ~CWBackingPlanes;

+

+  if (mask & CWBackingPixel) /* this is really not useful */ 

+    mask &= ~CWBackingPixel;

+

+  if (mask & CWOverrideRedirect)

+    attributes.override_redirect = pWin->overrideRedirect;

+

+  if (mask & CWSaveUnder) /* this is really not useful */

+    mask &= ~CWSaveUnder;

+

+  if (mask & CWEventMask) /* events are handled elsewhere */

+    mask &= ~CWEventMask;

+

+  if (mask & CWDontPropagate) /* events are handled elsewhere */

+    mask &= ~CWDontPropagate; 

+

+  if (mask & CWColormap) {

+    ColormapPtr pCmap;

+    

+    dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin), RT_COLORMAP,

+			    serverClient, DixUseAccess);

+

+    attributes.colormap = xnestColormap(pCmap);

+

+    xnestSetInstalledColormapWindows(pWin->drawable.pScreen);

+  }

+

+  if (mask & CWCursor) /* this is handeled in cursor code */

+    mask &= ~CWCursor;

+

+  if (mask)

+    XChangeWindowAttributes(xnestDisplay, xnestWindow(pWin),

+			    mask, &attributes);

+  

+  return True;

+}	  

+

+Bool

+xnestRealizeWindow(WindowPtr pWin)

+{

+  xnestConfigureWindow(pWin, CWStackingOrder);

+  xnestShapeWindow(pWin);

+  XMapWindow(xnestDisplay, xnestWindow(pWin));

+

+  return True;

+}

+

+Bool

+xnestUnrealizeWindow(WindowPtr pWin)

+{

+  XUnmapWindow(xnestDisplay, xnestWindow(pWin));

+

+  return True;

+}

+

+void

+xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion)

+{

+}

+

+void

+xnestClipNotify(WindowPtr pWin, int dx, int dy)

+{

+  xnestConfigureWindow(pWin, CWStackingOrder); 

+  xnestShapeWindow(pWin);

+}

+

+static Bool

+xnestWindowExposurePredicate(Display *display, XEvent *event, XPointer ptr)

+{

+  return (event->type == Expose && event->xexpose.window == *(Window *)ptr);

+}

+

+void

+xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)

+{

+  XEvent event;

+  Window window;

+  BoxRec Box;

+  

+  XSync(xnestDisplay, False);

+  

+  window = xnestWindow(pWin);

+  

+  while (XCheckIfEvent(xnestDisplay, &event, 

+		       xnestWindowExposurePredicate, (char *)&window)) {

+    

+    Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + event.xexpose.x;

+    Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + event.xexpose.y;

+    Box.x2 = Box.x1 + event.xexpose.width;

+    Box.y2 = Box.y1 + event.xexpose.height;

+	

+    event.xexpose.type = ProcessedExpose;

+	

+    if (RegionContainsRect(pRgn, &Box) != rgnIN)

+      XPutBackEvent(xnestDisplay, &event);

+  }

+  

+  miWindowExposures(pWin, pRgn, other_exposed);

+}

+

+void

+xnestSetShape(WindowPtr pWin, int kind)

+{

+  xnestShapeWindow(pWin);

+  miSetShape(pWin, kind);

+}

+

+static Bool

+xnestRegionEqual(RegionPtr pReg1, RegionPtr pReg2)

+{

+  BoxPtr pBox1, pBox2;

+  unsigned int n1, n2;

+

+  if (pReg1 == pReg2) return True;

+

+  if (pReg1 == NullRegion || pReg2 == NullRegion) return False;

+

+  pBox1 = RegionRects(pReg1);

+  n1 = RegionNumRects(pReg1);

+

+  pBox2 = RegionRects(pReg2);

+  n2 = RegionNumRects(pReg2);

+

+  if (n1 != n2) return False;

+

+  if (pBox1 == pBox2) return True;

+

+  if (memcmp(pBox1, pBox2, n1 * sizeof(BoxRec))) return False;

+

+  return True;

+}

+

+void

+xnestShapeWindow(WindowPtr pWin)

+{

+  Region reg;

+  BoxPtr pBox;

+  XRectangle rect;

+  int i;

+

+  if (!xnestRegionEqual(xnestWindowPriv(pWin)->bounding_shape,

+			wBoundingShape(pWin))) {

+    

+    if (wBoundingShape(pWin)) {

+      RegionCopy(xnestWindowPriv(pWin)->bounding_shape, wBoundingShape(pWin));

+      

+      reg = XCreateRegion();

+      pBox = RegionRects(xnestWindowPriv(pWin)->bounding_shape);

+      for (i = 0; 

+	   i < RegionNumRects(xnestWindowPriv(pWin)->bounding_shape);

+	   i++) {

+        rect.x = pBox[i].x1;

+        rect.y = pBox[i].y1;

+        rect.width = pBox[i].x2 - pBox[i].x1;

+        rect.height = pBox[i].y2 - pBox[i].y1;

+        XUnionRectWithRegion(&rect, reg, reg);

+      }

+      XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),

+			  ShapeBounding, 0, 0, reg, ShapeSet);

+      XDestroyRegion(reg);

+    }

+    else {

+      RegionEmpty(xnestWindowPriv(pWin)->bounding_shape);

+      

+      XShapeCombineMask(xnestDisplay, xnestWindow(pWin),

+			ShapeBounding, 0, 0, None, ShapeSet);

+    }

+  }

+  

+  if (!xnestRegionEqual(xnestWindowPriv(pWin)->clip_shape,

+			wClipShape(pWin))) {

+    

+    if (wClipShape(pWin)) {

+      RegionCopy(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin));

+      

+      reg = XCreateRegion();

+      pBox = RegionRects(xnestWindowPriv(pWin)->clip_shape);

+      for (i = 0; 

+	   i < RegionNumRects(xnestWindowPriv(pWin)->clip_shape);

+	   i++) {

+        rect.x = pBox[i].x1;

+        rect.y = pBox[i].y1;

+        rect.width = pBox[i].x2 - pBox[i].x1;

+        rect.height = pBox[i].y2 - pBox[i].y1;

+        XUnionRectWithRegion(&rect, reg, reg);

+      }

+      XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),

+			  ShapeClip, 0, 0, reg, ShapeSet);

+      XDestroyRegion(reg);

+    }

+    else {

+      RegionEmpty(xnestWindowPriv(pWin)->clip_shape);

+      

+      XShapeCombineMask(xnestDisplay, xnestWindow(pWin),

+			ShapeClip, 0, 0, None, ShapeSet);

+    }

+  }

+}

diff --git a/xorg-server/hw/xnest/XNCursor.h b/xorg-server/hw/xnest/XNCursor.h
index ab2c3b1e6..c50b79d1d 100644
--- a/xorg-server/hw/xnest/XNCursor.h
+++ b/xorg-server/hw/xnest/XNCursor.h
@@ -1,58 +1,59 @@
-/*
-
-Copyright 1993 by Davor Matic
-
-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.  Davor Matic makes no representations about
-the suitability of this software for any purpose.  It is provided "as
-is" without express or implied warranty.
-
-*/
-
-#ifndef XNESTCURSOR_H
-#define XNESTCURSOR_H
-
-#include "mipointrst.h"
-
-typedef struct {
-    miPointerSpriteFuncPtr spriteFuncs;
-} xnestCursorFuncRec, *xnestCursorFuncPtr;
-
-extern DevPrivateKey xnestCursorScreenKey;
-extern xnestCursorFuncRec xnestCursorFuncs;
-
-typedef struct {
-  Cursor cursor;
-} xnestPrivCursor;
-
-#define xnestGetCursorPriv(pCursor, pScreen) ((xnestPrivCursor *) \
-    dixLookupPrivate(&(pCursor)->devPrivates, CursorScreenKey(pScreen)))
-
-#define xnestSetCursorPriv(pCursor, pScreen, v) \
-    dixSetPrivate(&(pCursor)->devPrivates, CursorScreenKey(pScreen), v)
-
-#define xnestCursor(pCursor, pScreen) \
-  (xnestGetCursorPriv(pCursor, pScreen)->cursor)
-
-Bool xnestRealizeCursor(DeviceIntPtr pDev,
-                        ScreenPtr pScreen,
-                        CursorPtr pCursor);
-Bool xnestUnrealizeCursor(DeviceIntPtr pDev,
-                          ScreenPtr pScreen,
-                          CursorPtr pCursor);
-void xnestRecolorCursor(ScreenPtr pScreen,
-                        CursorPtr pCursor,
-                        Bool displayed);
-void xnestSetCursor (DeviceIntPtr pDev,
-                     ScreenPtr pScreen,
-                     CursorPtr pCursor,
-                     int x, int y);
-void xnestMoveCursor (DeviceIntPtr pDev,
-                      ScreenPtr pScreen,
-                      int x, int y);
-Bool xnestDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen);
-void xnestDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen);
-#endif /* XNESTCURSOR_H */
+/*

+

+Copyright 1993 by Davor Matic

+

+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.  Davor Matic makes no representations about

+the suitability of this software for any purpose.  It is provided "as

+is" without express or implied warranty.

+

+*/

+

+#ifndef XNESTCURSOR_H

+#define XNESTCURSOR_H

+

+#include "mipointrst.h"

+

+typedef struct {

+    miPointerSpriteFuncPtr spriteFuncs;

+} xnestCursorFuncRec, *xnestCursorFuncPtr;

+

+extern DevPrivateKeyRec xnestCursorScreenKeyRec;

+#define xnestCursorScreenKey (&xnestCursorScreenKeyRec)

+extern xnestCursorFuncRec xnestCursorFuncs;

+

+typedef struct {

+  Cursor cursor;

+} xnestPrivCursor;

+

+#define xnestGetCursorPriv(pCursor, pScreen) ((xnestPrivCursor *) \

+    dixLookupPrivate(&(pCursor)->devPrivates, CursorScreenKey(pScreen)))

+

+#define xnestSetCursorPriv(pCursor, pScreen, v) \

+    dixSetPrivate(&(pCursor)->devPrivates, CursorScreenKey(pScreen), v)

+

+#define xnestCursor(pCursor, pScreen) \

+  (xnestGetCursorPriv(pCursor, pScreen)->cursor)

+

+Bool xnestRealizeCursor(DeviceIntPtr pDev,

+                        ScreenPtr pScreen,

+                        CursorPtr pCursor);

+Bool xnestUnrealizeCursor(DeviceIntPtr pDev,

+                          ScreenPtr pScreen,

+                          CursorPtr pCursor);

+void xnestRecolorCursor(ScreenPtr pScreen,

+                        CursorPtr pCursor,

+                        Bool displayed);

+void xnestSetCursor (DeviceIntPtr pDev,

+                     ScreenPtr pScreen,

+                     CursorPtr pCursor,

+                     int x, int y);

+void xnestMoveCursor (DeviceIntPtr pDev,

+                      ScreenPtr pScreen,

+                      int x, int y);

+Bool xnestDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen);

+void xnestDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen);

+#endif /* XNESTCURSOR_H */

diff --git a/xorg-server/hw/xnest/XNGC.h b/xorg-server/hw/xnest/XNGC.h
index 19535fe3a..2eb89533d 100644
--- a/xorg-server/hw/xnest/XNGC.h
+++ b/xorg-server/hw/xnest/XNGC.h
@@ -1,42 +1,43 @@
-/*
-
-Copyright 1993 by Davor Matic
-
-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.  Davor Matic makes no representations about
-the suitability of this software for any purpose.  It is provided "as
-is" without express or implied warranty.
-
-*/
-
-#ifndef XNESTGC_H
-#define XNESTGC_H
-
-/* This file uses the GC definition form Xlib.h as XlibGC. */
-
-typedef struct {
-  XlibGC gc;
-  int nClipRects;
-} xnestPrivGC;
-
-extern DevPrivateKey xnestGCPrivateKey;
-
-#define xnestGCPriv(pGC) ((xnestPrivGC *) \
-    dixLookupPrivate(&(pGC)->devPrivates, xnestGCPrivateKey))
-
-#define xnestGC(pGC) (xnestGCPriv(pGC)->gc)
-
-Bool xnestCreateGC(GCPtr pGC);
-void xnestValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable);
-void xnestChangeGC(GCPtr pGC, unsigned long mask);
-void xnestCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
-void xnestDestroyGC(GCPtr pGC);
-void xnestChangeClip(GCPtr pGC, int type, pointer pValue, int nRects);
-void xnestDestroyClip(GCPtr pGC);
-void xnestDestroyClipHelper(GCPtr pGC);
-void xnestCopyClip(GCPtr pGCDst, GCPtr pGCSrc);
-
-#endif /* XNESTGC_H */
+/*

+

+Copyright 1993 by Davor Matic

+

+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.  Davor Matic makes no representations about

+the suitability of this software for any purpose.  It is provided "as

+is" without express or implied warranty.

+

+*/

+

+#ifndef XNESTGC_H

+#define XNESTGC_H

+

+/* This file uses the GC definition form Xlib.h as XlibGC. */

+

+typedef struct {

+  XlibGC gc;

+  int nClipRects;

+} xnestPrivGC;

+

+extern DevPrivateKeyRec xnestGCPrivateKeyRec;

+#define xnestGCPrivateKey (&xnestGCPrivateKeyRec)

+

+#define xnestGCPriv(pGC) ((xnestPrivGC *) \

+    dixLookupPrivate(&(pGC)->devPrivates, xnestGCPrivateKey))

+

+#define xnestGC(pGC) (xnestGCPriv(pGC)->gc)

+

+Bool xnestCreateGC(GCPtr pGC);

+void xnestValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable);

+void xnestChangeGC(GCPtr pGC, unsigned long mask);

+void xnestCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);

+void xnestDestroyGC(GCPtr pGC);

+void xnestChangeClip(GCPtr pGC, int type, pointer pValue, int nRects);

+void xnestDestroyClip(GCPtr pGC);

+void xnestDestroyClipHelper(GCPtr pGC);

+void xnestCopyClip(GCPtr pGCDst, GCPtr pGCSrc);

+

+#endif /* XNESTGC_H */

diff --git a/xorg-server/hw/xnest/XNPixmap.h b/xorg-server/hw/xnest/XNPixmap.h
index 614827587..0d7c6b61e 100644
--- a/xorg-server/hw/xnest/XNPixmap.h
+++ b/xorg-server/hw/xnest/XNPixmap.h
@@ -1,36 +1,37 @@
-/*
-
-Copyright 1993 by Davor Matic
-
-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.  Davor Matic makes no representations about
-the suitability of this software for any purpose.  It is provided "as
-is" without express or implied warranty.
-
-*/
-
-#ifndef XNESTPIXMAP_H
-#define XNESTPIXMAP_H
-
-extern DevPrivateKey xnestPixmapPrivateKey;
-
-typedef struct {
-  Pixmap pixmap;
-} xnestPrivPixmap;
-
-#define xnestPixmapPriv(pPixmap) ((xnestPrivPixmap *) \
-    dixLookupPrivate(&(pPixmap)->devPrivates, xnestPixmapPrivateKey))
-
-#define xnestPixmap(pPixmap) (xnestPixmapPriv(pPixmap)->pixmap)
-
-#define xnestSharePixmap(pPixmap) ((pPixmap)->refcnt++)
-
-PixmapPtr xnestCreatePixmap(ScreenPtr pScreen, int width, int height,
-			    int depth, unsigned usage_hint);
-Bool xnestDestroyPixmap(PixmapPtr pPixmap);
-RegionPtr xnestPixmapToRegion(PixmapPtr pPixmap);
-
-#endif /* XNESTPIXMAP_H */
+/*

+

+Copyright 1993 by Davor Matic

+

+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.  Davor Matic makes no representations about

+the suitability of this software for any purpose.  It is provided "as

+is" without express or implied warranty.

+

+*/

+

+#ifndef XNESTPIXMAP_H

+#define XNESTPIXMAP_H

+

+extern DevPrivateKeyRec xnestPixmapPrivateKeyRec;

+#define xnestPixmapPrivateKey (&xnestPixmapPrivateKeyRec)

+

+typedef struct {

+  Pixmap pixmap;

+} xnestPrivPixmap;

+

+#define xnestPixmapPriv(pPixmap) ((xnestPrivPixmap *) \

+    dixLookupPrivate(&(pPixmap)->devPrivates, xnestPixmapPrivateKey))

+

+#define xnestPixmap(pPixmap) (xnestPixmapPriv(pPixmap)->pixmap)

+

+#define xnestSharePixmap(pPixmap) ((pPixmap)->refcnt++)

+

+PixmapPtr xnestCreatePixmap(ScreenPtr pScreen, int width, int height,

+			    int depth, unsigned usage_hint);

+Bool xnestDestroyPixmap(PixmapPtr pPixmap);

+RegionPtr xnestPixmapToRegion(PixmapPtr pPixmap);

+

+#endif /* XNESTPIXMAP_H */

diff --git a/xorg-server/hw/xnest/XNWindow.h b/xorg-server/hw/xnest/XNWindow.h
index b59d86a97..c620767aa 100644
--- a/xorg-server/hw/xnest/XNWindow.h
+++ b/xorg-server/hw/xnest/XNWindow.h
@@ -1,72 +1,73 @@
-/*
-
-Copyright 1993 by Davor Matic
-
-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.  Davor Matic makes no representations about
-the suitability of this software for any purpose.  It is provided "as
-is" without express or implied warranty.
-
-*/
-
-#ifndef XNESTWINDOW_H
-#define XNESTWINDOW_H
-
-typedef struct {
-  Window window;
-  Window parent;
-  int x;
-  int y;
-  unsigned int width;
-  unsigned int height;
-  unsigned int border_width;
-  Window sibling_above;
-  RegionPtr bounding_shape;
-  RegionPtr clip_shape;
-} xnestPrivWin;
-
-typedef struct {
-  WindowPtr pWin;
-  Window window;
-} xnestWindowMatch;
-
-extern DevPrivateKey xnestWindowPrivateKey;
-
-#define xnestWindowPriv(pWin) ((xnestPrivWin *) \
-    dixLookupPrivate(&(pWin)->devPrivates, xnestWindowPrivateKey))
-
-#define xnestWindow(pWin) (xnestWindowPriv(pWin)->window)
-
-#define xnestWindowParent(pWin) \
-  ((pWin)->parent ? \
-   xnestWindow((pWin)->parent) : \
-   xnestDefaultWindows[pWin->drawable.pScreen->myNum])
-
-#define xnestWindowSiblingAbove(pWin) \
-  ((pWin)->prevSib ? xnestWindow((pWin)->prevSib) : None)
-
-#define xnestWindowSiblingBelow(pWin) \
-  ((pWin)->nextSib ? xnestWindow((pWin)->nextSib) : None)
-
-#define CWParent CWSibling
-#define CWStackingOrder CWStackMode
-
-WindowPtr xnestWindowPtr(Window window);
-Bool xnestCreateWindow(WindowPtr pWin);
-Bool xnestDestroyWindow(WindowPtr pWin);
-Bool xnestPositionWindow(WindowPtr pWin, int x, int y);
-void xnestConfigureWindow(WindowPtr pWin, unsigned int mask);
-Bool xnestChangeWindowAttributes(WindowPtr pWin, unsigned long mask);
-Bool xnestRealizeWindow(WindowPtr pWin);
-Bool xnestUnrealizeWindow(WindowPtr pWin);
-void xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion);
-void xnestClipNotify(WindowPtr pWin, int dx, int dy);
-void xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn,
-			  RegionPtr other_exposed);
-void xnestSetShape(WindowPtr pWin);
-void xnestShapeWindow(WindowPtr pWin);
-
-#endif /* XNESTWINDOW_H */
+/*

+

+Copyright 1993 by Davor Matic

+

+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.  Davor Matic makes no representations about

+the suitability of this software for any purpose.  It is provided "as

+is" without express or implied warranty.

+

+*/

+

+#ifndef XNESTWINDOW_H

+#define XNESTWINDOW_H

+

+typedef struct {

+  Window window;

+  Window parent;

+  int x;

+  int y;

+  unsigned int width;

+  unsigned int height;

+  unsigned int border_width;

+  Window sibling_above;

+  RegionPtr bounding_shape;

+  RegionPtr clip_shape;

+} xnestPrivWin;

+

+typedef struct {

+  WindowPtr pWin;

+  Window window;

+} xnestWindowMatch;

+

+extern DevPrivateKeyRec xnestWindowPrivateKeyRec;

+#define xnestWindowPrivateKey (&xnestWindowPrivateKeyRec)

+

+#define xnestWindowPriv(pWin) ((xnestPrivWin *) \

+    dixLookupPrivate(&(pWin)->devPrivates, xnestWindowPrivateKey))

+

+#define xnestWindow(pWin) (xnestWindowPriv(pWin)->window)

+

+#define xnestWindowParent(pWin) \

+  ((pWin)->parent ? \

+   xnestWindow((pWin)->parent) : \

+   xnestDefaultWindows[pWin->drawable.pScreen->myNum])

+

+#define xnestWindowSiblingAbove(pWin) \

+  ((pWin)->prevSib ? xnestWindow((pWin)->prevSib) : None)

+

+#define xnestWindowSiblingBelow(pWin) \

+  ((pWin)->nextSib ? xnestWindow((pWin)->nextSib) : None)

+

+#define CWParent CWSibling

+#define CWStackingOrder CWStackMode

+

+WindowPtr xnestWindowPtr(Window window);

+Bool xnestCreateWindow(WindowPtr pWin);

+Bool xnestDestroyWindow(WindowPtr pWin);

+Bool xnestPositionWindow(WindowPtr pWin, int x, int y);

+void xnestConfigureWindow(WindowPtr pWin, unsigned int mask);

+Bool xnestChangeWindowAttributes(WindowPtr pWin, unsigned long mask);

+Bool xnestRealizeWindow(WindowPtr pWin);

+Bool xnestUnrealizeWindow(WindowPtr pWin);

+void xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion);

+void xnestClipNotify(WindowPtr pWin, int dx, int dy);

+void xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn,

+			  RegionPtr other_exposed);

+void xnestSetShape(WindowPtr pWin, int kind);

+void xnestShapeWindow(WindowPtr pWin);

+

+#endif /* XNESTWINDOW_H */

diff --git a/xorg-server/hw/xquartz/applewm.c b/xorg-server/hw/xquartz/applewm.c
index 64851e791..054fff776 100644
--- a/xorg-server/hw/xquartz/applewm.c
+++ b/xorg-server/hw/xquartz/applewm.c
@@ -140,10 +140,8 @@ AppleWMSetScreenOrigin(
 {

     int32_t data[2];

 

-    data[0] = (dixScreenOrigins[pWin->drawable.pScreen->myNum].x

-                + darwinMainScreenX);

-    data[1] = (dixScreenOrigins[pWin->drawable.pScreen->myNum].y

-                + darwinMainScreenY);

+    data[0] = pWin->drawable.pScreen->x + darwinMainScreenX;

+    data[1] = pWin->drawable.pScreen->y + darwinMainScreenY;

 

     dixChangeWindowProperty(serverClient, pWin, xa_native_screen_origin(),

 			    XA_INTEGER, 32, PropModeReplace, 2, data, TRUE);

diff --git a/xorg-server/hw/xquartz/darwin.c b/xorg-server/hw/xquartz/darwin.c
index ed9543eb2..7814967b8 100644
--- a/xorg-server/hw/xquartz/darwin.c
+++ b/xorg-server/hw/xquartz/darwin.c
@@ -84,8 +84,7 @@ FILE *debug_log_fp = NULL;
  * X server shared global variables

  */

 int                     darwinScreensFound = 0;

-static int              darwinScreenKeyIndex;

-DevPrivateKey           darwinScreenKey = &darwinScreenKeyIndex;

+DevPrivateKeyRec        darwinScreenKeyRec;

 io_connect_t            darwinParamConnect = 0;

 int                     darwinEventReadFD = -1;

 int                     darwinEventWriteFD = -1;

@@ -185,6 +184,9 @@ static Bool DarwinScreenInit(int index, ScreenPtr pScreen, int argc, char **argv
     Bool        ret;

     DarwinFramebufferPtr dfb;

 

+    if (!dixRegisterPrivateKey(&darwinScreenKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+

     // reset index of found screens for each server generation

     if (index == 0) {

         foundIndex = 0;

@@ -262,8 +264,8 @@ static Bool DarwinScreenInit(int index, ScreenPtr pScreen, int argc, char **argv
         return FALSE;

     }

 

-    dixScreenOrigins[index].x = dfb->x;

-    dixScreenOrigins[index].y = dfb->y;

+    pScreen->x = dfb->x;

+    pScreen->y = dfb->y;

 

     /*    ErrorF("Screen %d added: %dx%d @ (%d,%d)\n",

 	  index, dfb->width, dfb->height, dfb->x, dfb->y); */

@@ -526,16 +528,16 @@ DarwinAdjustScreenOrigins(ScreenInfo *pScreenInfo)
 {

     int i, left, top;

 

-    left = dixScreenOrigins[0].x;

-    top  = dixScreenOrigins[0].y;

+    left = pScreenInfo->screens[0]->x;

+    top  = pScreenInfo->screens[0]->y;

 

     /* Find leftmost screen. If there's a tie, take the topmost of the two. */

     for (i = 1; i < pScreenInfo->numScreens; i++) {

-        if (dixScreenOrigins[i].x < left  ||

-            (dixScreenOrigins[i].x == left && dixScreenOrigins[i].y < top))

+        if (pScreenInfo->screens[i]->x < left  ||

+            (pScreenInfo->screens[i]->x == left && pScreenInfo->screens[i]->y < top))

         {

-            left = dixScreenOrigins[i].x;

-            top = dixScreenOrigins[i].y;

+            left = pScreenInfo->screens[i]->x;

+            top = pScreenInfo->screens[i]->y;

         }

     }

 

@@ -551,10 +553,10 @@ DarwinAdjustScreenOrigins(ScreenInfo *pScreenInfo)
 

     if (darwinMainScreenX != 0 || darwinMainScreenY != 0) {

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

-            dixScreenOrigins[i].x -= darwinMainScreenX;

-            dixScreenOrigins[i].y -= darwinMainScreenY;

+            pScreenInfo->screens[i]->x -= darwinMainScreenX;

+            pScreenInfo->screens[i]->y -= darwinMainScreenY;

             DEBUG_LOG("Screen %d placed at X11 coordinate (%d,%d).\n",

-                      i, dixScreenOrigins[i].x, dixScreenOrigins[i].y);

+                      i, pScreenInfo->screens[i]->x, pScreenInfo->screens[i]->y);

         }

     }

 }

@@ -793,7 +795,7 @@ void AbortDDX( void )
 void

 xf86SetRootClip (ScreenPtr pScreen, int enable)

 {

-    WindowPtr	pWin = WindowTable[pScreen->myNum];

+    WindowPtr	pWin = pScreen->root;

     WindowPtr	pChild;

     Bool	WasViewable = (Bool)(pWin->viewable);

     Bool	anyMarked = TRUE;

@@ -817,8 +819,8 @@ xf86SetRootClip (ScreenPtr pScreen, int enable)
 	    {

 		RegionPtr	borderVisible;

 

-		borderVisible = REGION_CREATE(pScreen, NullBox, 1);

-		REGION_SUBTRACT(pScreen, borderVisible,

+		borderVisible = RegionCreate(NullBox, 1);

+		RegionSubtract(borderVisible,

 				&pWin->borderClip, &pWin->winSize);

 		pWin->valdata->before.borderVisible = borderVisible;

 	    }

@@ -837,13 +839,13 @@ xf86SetRootClip (ScreenPtr pScreen, int enable)
 	box.y1 = 0;

 	box.x2 = pScreen->width;

 	box.y2 = pScreen->height;

-	REGION_RESET(pScreen, &pWin->borderClip, &box);

-	REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList);

+	RegionReset(&pWin->borderClip, &box);

+	RegionBreak(&pWin->clipList);

     }

     else

     {

-	REGION_EMPTY(pScreen, &pWin->borderClip);

-	REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList);

+	RegionEmpty(&pWin->borderClip);

+	RegionBreak(&pWin->clipList);

     }

 

     ResizeChildrenWinSize (pWin, 0, 0, 0, 0);

@@ -852,8 +854,8 @@ xf86SetRootClip (ScreenPtr pScreen, int enable)
     {

 	if (pWin->backStorage)

 	{

-	    pOldClip = REGION_CREATE(pScreen, NullBox, 1);

-	    REGION_COPY(pScreen, pOldClip, &pWin->clipList);

+	    pOldClip = RegionCreate(NullBox, 1);

+	    RegionCopy(pOldClip, &pWin->clipList);

 	}

 

 	if (pWin->firstChild)

@@ -882,7 +884,7 @@ xf86SetRootClip (ScreenPtr pScreen, int enable)
 			     (pWin, 0, 0, pOldClip,

 			      pWin->drawable.x, pWin->drawable.y);

 	if (WasViewable)

-	    REGION_DESTROY(pScreen, pOldClip);

+	    RegionDestroy(pOldClip);

 	if (bsExposed)

 	{

 	    RegionPtr	valExposed = NullRegion;

@@ -891,8 +893,8 @@ xf86SetRootClip (ScreenPtr pScreen, int enable)
 		valExposed = &pWin->valdata->after.exposed;

 	    (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);

 	    if (valExposed)

-		REGION_EMPTY(pScreen, valExposed);

-	    REGION_DESTROY(pScreen, bsExposed);

+		RegionEmpty(valExposed);

+	    RegionDestroy(bsExposed);

 	}

     }

     if (WasViewable)

diff --git a/xorg-server/hw/xquartz/darwin.h b/xorg-server/hw/xquartz/darwin.h
index 6209b5ef1..7cd4336cd 100644
--- a/xorg-server/hw/xquartz/darwin.h
+++ b/xorg-server/hw/xquartz/darwin.h
@@ -50,7 +50,8 @@ void xf86SetRootClip (ScreenPtr pScreen, int enable);
 /*

  * Global variables from darwin.c

  */

-extern DevPrivateKey    darwinScreenKey; // index into pScreen.devPrivates

+extern DevPrivateKeyRec darwinScreenKeyRec;

+#define darwinScreenKey (&darwinScreenKeyRec)

 extern int              darwinScreensFound;

 extern io_connect_t     darwinParamConnect;

 extern int              darwinEventReadFD;

diff --git a/xorg-server/hw/xquartz/darwinEvents.c b/xorg-server/hw/xquartz/darwinEvents.c
index 421efcedf..db3f5b24e 100644
--- a/xorg-server/hw/xquartz/darwinEvents.c
+++ b/xorg-server/hw/xquartz/darwinEvents.c
@@ -1,576 +1,576 @@
-/*
-Darwin event queue and event handling
-
-Copyright 2007-2008 Apple Inc.
-Copyright 2004 Kaleb S. KEITHLEY. All Rights Reserved.
-Copyright (c) 2002-2004 Torrey T. Lyons. All Rights Reserved.
-
-This file is based on mieq.c by Keith Packard,
-which contains the following copyright:
-Copyright 1990, 1998  The Open Group
-
-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.
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-Except as contained in this notice, the name of The Open Group shall not be
-used in advertising or otherwise to promote the sale, use or other dealings
-in this Software without prior written authorization from The Open Group.
- */
-
-#include "sanitizedCarbon.h"
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include   <X11/X.h>
-#include   <X11/Xmd.h>
-#include   <X11/Xproto.h>
-#include   "misc.h"
-#include   "windowstr.h"
-#include   "pixmapstr.h"
-#include   "inputstr.h"
-#include   "eventstr.h"
-#include   "mi.h"
-#include   "scrnintstr.h"
-#include   "mipointer.h"
-#include   "os.h"
-
-#include "darwin.h"
-#include "quartz.h"
-#include "quartzKeyboard.h"
-#include "darwinEvents.h"
-
-#include <sys/types.h>
-#include <sys/uio.h>
-#include <unistd.h>
-#include <pthread.h>
-#include <errno.h>
-
-#include <IOKit/hidsystem/IOLLEvent.h>
-
-/* Fake button press/release for scroll wheel move. */
-#define SCROLLWHEELUPFAKE    4
-#define SCROLLWHEELDOWNFAKE  5
-#define SCROLLWHEELLEFTFAKE  6
-#define SCROLLWHEELRIGHTFAKE 7
-
-#include <X11/extensions/applewmconst.h>
-#include "applewmExt.h"
-
-/* FIXME: Abstract this better */
-extern Bool QuartzModeEventHandler(int screenNum, XQuartzEvent *e, DeviceIntPtr dev);
-
-int darwin_all_modifier_flags = 0;  // last known modifier state
-int darwin_all_modifier_mask = 0;
-int darwin_x11_modifier_mask = 0;
-
-#define FD_ADD_MAX 128
-static int fd_add[FD_ADD_MAX];
-int fd_add_count = 0;
-static pthread_mutex_t fd_add_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t fd_add_ready_cond = PTHREAD_COND_INITIALIZER;
-static pthread_t fd_add_tid = NULL;
-
-static EventListPtr darwinEvents = NULL;
-
-static pthread_mutex_t mieq_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t mieq_ready_cond = PTHREAD_COND_INITIALIZER;
-
-/*** Pthread Magics ***/
-static pthread_t create_thread(void *func, void *arg) {
-    pthread_attr_t attr;
-    pthread_t tid;
-
-    pthread_attr_init (&attr);
-    pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
-    pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
-    pthread_create (&tid, &attr, func, arg);
-    pthread_attr_destroy (&attr);
-
-    return tid;
-}
-
-void darwinEvents_lock(void);
-void darwinEvents_lock(void) {
-    int err;
-    if((err = pthread_mutex_lock(&mieq_lock))) {
-        ErrorF("%s:%s:%d: Failed to lock mieq_lock: %d\n",
-               __FILE__, __FUNCTION__, __LINE__, err);
-        spewCallStack();
-    }
-    if(darwinEvents == NULL) {
-        pthread_cond_wait(&mieq_ready_cond, &mieq_lock);
-    }
-}
-
-void darwinEvents_unlock(void);
-void darwinEvents_unlock(void) {
-    int err;
-    if((err = pthread_mutex_unlock(&mieq_lock))) {
-        ErrorF("%s:%s:%d: Failed to unlock mieq_lock: %d\n",
-               __FILE__, __FUNCTION__, __LINE__, err);
-        spewCallStack();
-    }
-}
-
-/*
- * DarwinPressModifierKey
- * Press or release the given modifier key (one of NX_MODIFIERKEY_* constants)
- */
-static void DarwinPressModifierKey(int pressed, int key) {
-    int keycode = DarwinModifierNXKeyToNXKeycode(key, 0);
-
-    if (keycode == 0) {
-        ErrorF("DarwinPressModifierKey bad keycode: key=%d\n", key);
-        return;
-    }
-
-    DarwinSendKeyboardEvents(pressed, keycode);
-}
-
-/*
- * DarwinUpdateModifiers
- *  Send events to update the modifier state.
- */
-
-static int darwin_x11_modifier_mask_list[] = {
-#ifdef NX_DEVICELCMDKEYMASK
-    NX_DEVICELCTLKEYMASK, NX_DEVICERCTLKEYMASK,
-    NX_DEVICELSHIFTKEYMASK, NX_DEVICERSHIFTKEYMASK,
-    NX_DEVICELCMDKEYMASK, NX_DEVICERCMDKEYMASK,
-    NX_DEVICELALTKEYMASK, NX_DEVICERALTKEYMASK,
-#else
-    NX_CONTROLMASK, NX_SHIFTMASK, NX_COMMANDMASK, NX_ALTERNATEMASK,
-#endif
-    NX_ALPHASHIFTMASK,
-    0
-};
-
-static int darwin_all_modifier_mask_additions[] = { NX_SECONDARYFNMASK, };
-
-static void DarwinUpdateModifiers(
-    int pressed,        // KeyPress or KeyRelease
-    int flags )         // modifier flags that have changed
-{
-    int *f;
-    int key;
-
-    /* Capslock is special.  This mask is the state of capslock (on/off),
-     * not the state of the button.  Hopefully we can find a better solution.
-     */
-    if(NX_ALPHASHIFTMASK & flags) {
-        DarwinPressModifierKey(KeyPress, NX_MODIFIERKEY_ALPHALOCK);
-        DarwinPressModifierKey(KeyRelease, NX_MODIFIERKEY_ALPHALOCK);
-    }
-    
-    for(f=darwin_x11_modifier_mask_list; *f; f++)
-        if(*f & flags && *f != NX_ALPHASHIFTMASK) {
-            key = DarwinModifierNXMaskToNXKey(*f);
-            if(key == -1)
-                ErrorF("DarwinUpdateModifiers: Unsupported NXMask: 0x%x\n", *f);
-            else
-                DarwinPressModifierKey(pressed, key);
-        }
-}
-
-/* Generic handler for Xquartz-specifc events.  When possible, these should
-   be moved into their own individual functions and set as handlers using
-   mieqSetHandler. */
-
-static void DarwinEventHandler(int screenNum, InternalEvent *ie, DeviceIntPtr dev) {
-    XQuartzEvent *e = &(ie->xquartz_event);
-
-    TA_SERVER();
-
-    switch(e->subtype) {
-        case kXquartzControllerNotify:
-            DEBUG_LOG("kXquartzControllerNotify\n");
-            AppleWMSendEvent(AppleWMControllerNotify,
-                             AppleWMControllerNotifyMask,
-                             e->data[0],
-                             e->data[1]);
-            break;
-            
-        case kXquartzPasteboardNotify:
-            DEBUG_LOG("kXquartzPasteboardNotify\n");
-            AppleWMSendEvent(AppleWMPasteboardNotify,
-                             AppleWMPasteboardNotifyMask,
-                             e->data[0],
-                             e->data[1]);
-            break;
-            
-        case kXquartzActivate:
-            DEBUG_LOG("kXquartzActivate\n");
-            QuartzShow();
-            AppleWMSendEvent(AppleWMActivationNotify,
-                             AppleWMActivationNotifyMask,
-                             AppleWMIsActive, 0);
-            break;
-            
-        case kXquartzDeactivate:
-            DEBUG_LOG("kXquartzDeactivate\n");
-            AppleWMSendEvent(AppleWMActivationNotify,
-                             AppleWMActivationNotifyMask,
-                             AppleWMIsInactive, 0);
-            QuartzHide();
-            break;
-
-        case kXquartzReloadPreferences:
-            DEBUG_LOG("kXquartzReloadPreferences\n");
-            AppleWMSendEvent(AppleWMActivationNotify,
-                             AppleWMActivationNotifyMask,
-                             AppleWMReloadPreferences, 0);
-            break;
-            
-        case kXquartzToggleFullscreen:
-            DEBUG_LOG("kXquartzToggleFullscreen\n");
-            if (quartzEnableRootless) 
-                QuartzSetFullscreen(!quartzHasRoot);
-            else if (quartzHasRoot)
-                QuartzHide();
-            else
-                QuartzShow();
-            break;
-            
-        case kXquartzSetRootless:
-            DEBUG_LOG("kXquartzSetRootless\n");
-            QuartzSetRootless(e->data[0]);
-            if (!quartzEnableRootless && !quartzHasRoot)
-                QuartzHide();
-            break;
-            
-        case kXquartzSetRootClip:
-            QuartzSetRootClip((Bool)e->data[0]);
-            break;
-            
-        case kXquartzQuit:
-            GiveUp(0);
-            break;
-            
-        case kXquartzSpaceChanged:
-            DEBUG_LOG("kXquartzSpaceChanged\n");
-            QuartzSpaceChanged(e->data[0]);
-            break;
-
-        case kXquartzListenOnOpenFD:
-            ErrorF("Calling ListenOnOpenFD() for new fd: %d\n", (int)e->data[0]);
-            ListenOnOpenFD((int)e->data[0], 1);
-            break;
-            
-        case kXquartzReloadKeymap:
-            DarwinKeyboardReloadHandler();
-            break;
-            
-        case kXquartzDisplayChanged:
-            QuartzUpdateScreens();
-            break;
-            
-        default:
-            if(!QuartzModeEventHandler(screenNum, e, dev))
-                ErrorF("Unknown application defined event type %d.\n", e->subtype);
-    }	
-}
-
-void DarwinListenOnOpenFD(int fd) {
-    ErrorF("DarwinListenOnOpenFD: %d\n", fd);
-    
-    pthread_mutex_lock(&fd_add_lock);
-    if(fd_add_count < FD_ADD_MAX)
-        fd_add[fd_add_count++] = fd;
-    else
-        ErrorF("FD Addition buffer at max.  Dropping fd addition request.\n");
-
-    pthread_cond_broadcast(&fd_add_ready_cond);
-    pthread_mutex_unlock(&fd_add_lock);
-}
-
-static void DarwinProcessFDAdditionQueue_thread(void *args) {
-    pthread_mutex_lock(&fd_add_lock);
-    while(true) {
-        while(fd_add_count) {
-            DarwinSendDDXEvent(kXquartzListenOnOpenFD, 1, fd_add[--fd_add_count]);
-        }
-        pthread_cond_wait(&fd_add_ready_cond, &fd_add_lock);
-    }
-}
-
-Bool DarwinEQInit(void) { 
-    int *p;
-
-    for(p=darwin_x11_modifier_mask_list, darwin_all_modifier_mask=0; *p; p++) {
-        darwin_x11_modifier_mask |= *p;
-    }
-    
-    for(p=darwin_all_modifier_mask_additions, darwin_all_modifier_mask= darwin_x11_modifier_mask; *p; p++) {
-        darwin_all_modifier_mask |= *p;
-    }
-    
-    mieqInit();
-    mieqSetHandler(ET_XQuartz, DarwinEventHandler);
-
-    /* Note that this *could* cause a potential async issue, since we're checking
-     * darwinEvents without holding the lock, but darwinEvents is only ever set
-     * here, so I don't bother.
-     */
-    if (!darwinEvents) {
-        darwinEvents = InitEventList(GetMaximumEventsNum());;
-        
-        if (!darwinEvents)
-            FatalError("Couldn't allocate event buffer\n");
-        
-        darwinEvents_lock();
-        pthread_cond_broadcast(&mieq_ready_cond);
-        darwinEvents_unlock();
-    }
-
-    if(!fd_add_tid)
-        fd_add_tid = create_thread(DarwinProcessFDAdditionQueue_thread, NULL);
-    
-    return TRUE;
-}
-
-/*
- * ProcessInputEvents
- *  Read and process events from the event queue until it is empty.
- */
-void ProcessInputEvents(void) {
-    char nullbyte;
-	int x = sizeof(nullbyte);
-    
-    TA_SERVER();
-
-    mieqProcessInputEvents();
-
-    // Empty the signaling pipe
-    while (x == sizeof(nullbyte)) {
-      x = read(darwinEventReadFD, &nullbyte, sizeof(nullbyte));
-    }
-}
-
-/* Sends a null byte down darwinEventWriteFD, which will cause the
-   Dispatch() event loop to check out event queue */
-static void DarwinPokeEQ(void) {
-	char nullbyte=0;
-	//  <daniels> oh, i ... er ... christ.
-	write(darwinEventWriteFD, &nullbyte, sizeof(nullbyte));
-}
-
-/* Convert from Appkit pointer input values to X input values:
- * Note: pointer_x and pointer_y are relative to the upper-left of primary
- *       display.
- */
-static void DarwinPrepareValuators(DeviceIntPtr pDev, int *valuators, ScreenPtr screen,
-                                   float pointer_x, float pointer_y, 
-                                   float pressure, float tilt_x, float tilt_y) {
-    /* Fix offset between darwin and X screens */
-    pointer_x -= darwinMainScreenX + dixScreenOrigins[screen->myNum].x;
-    pointer_y -= darwinMainScreenY + dixScreenOrigins[screen->myNum].y;
-
-    if(pointer_x < 0.0)
-        pointer_x = 0.0;
-
-    if(pointer_y < 0.0)
-        pointer_y = 0.0;
-    
-    if(pDev == darwinPointer) {
-        valuators[0] = pointer_x;
-        valuators[1] = pointer_y;
-        valuators[2] = 0;
-        valuators[3] = 0;
-        valuators[4] = 0;
-    } else {
-        /* Setup our array of values */
-        valuators[0] = XQUARTZ_VALUATOR_LIMIT * (pointer_x / (float)screenInfo.screens[0]->width);
-        valuators[1] = XQUARTZ_VALUATOR_LIMIT * (pointer_y / (float)screenInfo.screens[0]->height);
-        valuators[2] = XQUARTZ_VALUATOR_LIMIT * pressure;
-        valuators[3] = XQUARTZ_VALUATOR_LIMIT * tilt_x;
-        valuators[4] = XQUARTZ_VALUATOR_LIMIT * tilt_y;
-    }
-    //DEBUG_LOG("Pointer (%f, %f), Valuators: {%d,%d,%d,%d,%d}\n", pointer_x, pointer_y,
-    //          valuators[0], valuators[1], valuators[2], valuators[3], valuators[4]);
-}
-
-void DarwinSendPointerEvents(DeviceIntPtr pDev, int ev_type, int ev_button, float pointer_x, float pointer_y, 
-			     float pressure, float tilt_x, float tilt_y) {
-	static int darwinFakeMouseButtonDown = 0;
-	int i, num_events;
-    ScreenPtr screen;
-    int valuators[5];
-	
-    //DEBUG_LOG("x=%f, y=%f, p=%f, tx=%f, ty=%f\n", pointer_x, pointer_y, pressure, tilt_x, tilt_y);
-    
-	if(!darwinEvents) {
-		DEBUG_LOG("DarwinSendPointerEvents called before darwinEvents was initialized\n");
-		return;
-	}
-
-    screen = miPointerGetScreen(pDev);
-    if(!screen) {
-        DEBUG_LOG("DarwinSendPointerEvents called before screen was initialized\n");
-        return;
-    }
-
-    /* Handle fake click */
-	if (ev_type == ButtonPress && darwinFakeButtons && ev_button == 1) {
-        if(darwinFakeMouseButtonDown != 0) {
-            /* We're currently "down" with another button, so release it first */
-            DarwinSendPointerEvents(pDev, ButtonRelease, darwinFakeMouseButtonDown, pointer_x, pointer_y, pressure, tilt_x, tilt_y);
-            darwinFakeMouseButtonDown=0;
-        }
-		if (darwin_all_modifier_flags & darwinFakeMouse2Mask) {
-            ev_button = 2;
-			darwinFakeMouseButtonDown = 2;
-            DarwinUpdateModKeys(darwin_all_modifier_flags & ~darwinFakeMouse2Mask);
-		} else if (darwin_all_modifier_flags & darwinFakeMouse3Mask) {
-            ev_button = 3;
-			darwinFakeMouseButtonDown = 3;
-            DarwinUpdateModKeys(darwin_all_modifier_flags & ~darwinFakeMouse3Mask);
-		}
-	}
-
-	if (ev_type == ButtonRelease && ev_button == 1) {
-        if(darwinFakeMouseButtonDown) {
-            ev_button = darwinFakeMouseButtonDown;
-        }
-
-        if(darwinFakeMouseButtonDown == 2) {
-            DarwinUpdateModKeys(darwin_all_modifier_flags & ~darwinFakeMouse2Mask);
-        } else if(darwinFakeMouseButtonDown == 3) {
-            DarwinUpdateModKeys(darwin_all_modifier_flags & ~darwinFakeMouse3Mask);
-        }
-
-        darwinFakeMouseButtonDown = 0;
-	}
-
-    DarwinPrepareValuators(pDev, valuators, screen, pointer_x, pointer_y, pressure, tilt_x, tilt_y);
-    darwinEvents_lock(); {
-        num_events = GetPointerEvents(darwinEvents, pDev, ev_type, ev_button, 
-                                      POINTER_ABSOLUTE, 0, pDev==darwinTabletCurrent?5:2, valuators);
-        for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);
-        if(num_events > 0) DarwinPokeEQ();
-    } darwinEvents_unlock();
-}
-
-void DarwinSendKeyboardEvents(int ev_type, int keycode) {
-	int i, num_events;
-
-	if(!darwinEvents) {
-		DEBUG_LOG("DarwinSendKeyboardEvents called before darwinEvents was initialized\n");
-		return;
-	}
-
-    darwinEvents_lock(); {
-        num_events = GetKeyboardEvents(darwinEvents, darwinKeyboard, ev_type, keycode + MIN_KEYCODE);
-        for(i=0; i<num_events; i++) mieqEnqueue(darwinKeyboard, (InternalEvent*)darwinEvents[i].event);
-        if(num_events > 0) DarwinPokeEQ();
-    } darwinEvents_unlock();
-}
-
-void DarwinSendProximityEvents(int ev_type, float pointer_x, float pointer_y) {
-	int i, num_events;
-    ScreenPtr screen;
-    DeviceIntPtr pDev = darwinTabletCurrent;
-    int valuators[5];
-
-	DEBUG_LOG("DarwinSendProximityEvents(%d, %f, %f)\n", ev_type, pointer_x, pointer_y);
-
-	if(!darwinEvents) {
-		DEBUG_LOG("DarwinSendProximityEvents called before darwinEvents was initialized\n");
-		return;
-	}
-    
-    screen = miPointerGetScreen(pDev);
-    if(!screen) {
-        DEBUG_LOG("DarwinSendPointerEvents called before screen was initialized\n");
-        return;
-    }    
-
-    DarwinPrepareValuators(pDev, valuators, screen, pointer_x, pointer_y, 0.0f, 0.0f, 0.0f);
-    darwinEvents_lock(); {
-        num_events = GetProximityEvents(darwinEvents, pDev, ev_type,
-                                        0, 5, valuators);
-        for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);
-        if(num_events > 0) DarwinPokeEQ();
-    } darwinEvents_unlock();
-}
-
-
-/* Send the appropriate number of button clicks to emulate scroll wheel */
-void DarwinSendScrollEvents(float count_x, float count_y, 
-							float pointer_x, float pointer_y, 
-			    			float pressure, float tilt_x, float tilt_y) {
-	int sign_x, sign_y;
-	if(!darwinEvents) {
-		DEBUG_LOG("DarwinSendScrollEvents called before darwinEvents was initialized\n");
-		return;
-	}
-
-	sign_x = count_x > 0.0f ? SCROLLWHEELLEFTFAKE : SCROLLWHEELRIGHTFAKE;
-	sign_y = count_y > 0.0f ? SCROLLWHEELUPFAKE : SCROLLWHEELDOWNFAKE;
-	count_x = fabs(count_x);
-	count_y = fabs(count_y);
-	
-	while ((count_x > 0.0f) || (count_y > 0.0f)) {
-		if (count_x > 0.0f) {
-			DarwinSendPointerEvents(darwinPointer, ButtonPress, sign_x, pointer_x, pointer_y, pressure, tilt_x, tilt_y);
-			DarwinSendPointerEvents(darwinPointer, ButtonRelease, sign_x, pointer_x, pointer_y, pressure, tilt_x, tilt_y);
-			count_x = count_x - 1.0f;
-		}
-		if (count_y > 0.0f) {
-			DarwinSendPointerEvents(darwinPointer, ButtonPress, sign_y, pointer_x, pointer_y, pressure, tilt_x, tilt_y);
-			DarwinSendPointerEvents(darwinPointer, ButtonRelease, sign_y, pointer_x, pointer_y, pressure, tilt_x, tilt_y);
-			count_y = count_y - 1.0f;
-		}
-	}
-}
-
-/* Send the appropriate KeyPress/KeyRelease events to GetKeyboardEvents to
-   reflect changing modifier flags (alt, control, meta, etc) */
-void DarwinUpdateModKeys(int flags) {
-	DarwinUpdateModifiers(KeyRelease, darwin_all_modifier_flags & ~flags & darwin_x11_modifier_mask);
-	DarwinUpdateModifiers(KeyPress, ~darwin_all_modifier_flags & flags & darwin_x11_modifier_mask);
-	darwin_all_modifier_flags = flags;
-}
-
-/*
- * DarwinSendDDXEvent
- *  Send the X server thread a message by placing it on the event queue.
- */
-void DarwinSendDDXEvent(int type, int argc, ...) {
-    XQuartzEvent e;
-    int i;
-    va_list args;
-
-    memset(&e, 0, sizeof(e));
-    e.header = ET_Internal;
-    e.type = ET_XQuartz;
-    e.length = sizeof(e);
-    e.time = GetTimeInMillis();
-    e.subtype = type;
-
-    if (argc > 0 && argc < XQUARTZ_EVENT_MAXARGS) {
-        va_start (args, argc);
-        for (i = 0; i < argc; i++)
-            e.data[i] = (uint32_t) va_arg (args, uint32_t);
-        va_end (args);
-    }
-
-    darwinEvents_lock(); {
-        mieqEnqueue(NULL, (InternalEvent*)&e);
-        DarwinPokeEQ();
-    } darwinEvents_unlock();
-}
+/*

+Darwin event queue and event handling

+

+Copyright 2007-2008 Apple Inc.

+Copyright 2004 Kaleb S. KEITHLEY. All Rights Reserved.

+Copyright (c) 2002-2004 Torrey T. Lyons. All Rights Reserved.

+

+This file is based on mieq.c by Keith Packard,

+which contains the following copyright:

+Copyright 1990, 1998  The Open Group

+

+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.

+

+The above copyright notice and this permission notice shall be included in

+all copies or substantial portions of the Software.

+

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+

+Except as contained in this notice, the name of The Open Group shall not be

+used in advertising or otherwise to promote the sale, use or other dealings

+in this Software without prior written authorization from The Open Group.

+ */

+

+#include "sanitizedCarbon.h"

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include   <X11/X.h>

+#include   <X11/Xmd.h>

+#include   <X11/Xproto.h>

+#include   "misc.h"

+#include   "windowstr.h"

+#include   "pixmapstr.h"

+#include   "inputstr.h"

+#include   "eventstr.h"

+#include   "mi.h"

+#include   "scrnintstr.h"

+#include   "mipointer.h"

+#include   "os.h"

+

+#include "darwin.h"

+#include "quartz.h"

+#include "quartzKeyboard.h"

+#include "darwinEvents.h"

+

+#include <sys/types.h>

+#include <sys/uio.h>

+#include <unistd.h>

+#include <pthread.h>

+#include <errno.h>

+

+#include <IOKit/hidsystem/IOLLEvent.h>

+

+/* Fake button press/release for scroll wheel move. */

+#define SCROLLWHEELUPFAKE    4

+#define SCROLLWHEELDOWNFAKE  5

+#define SCROLLWHEELLEFTFAKE  6

+#define SCROLLWHEELRIGHTFAKE 7

+

+#include <X11/extensions/applewmconst.h>

+#include "applewmExt.h"

+

+/* FIXME: Abstract this better */

+extern Bool QuartzModeEventHandler(int screenNum, XQuartzEvent *e, DeviceIntPtr dev);

+

+int darwin_all_modifier_flags = 0;  // last known modifier state

+int darwin_all_modifier_mask = 0;

+int darwin_x11_modifier_mask = 0;

+

+#define FD_ADD_MAX 128

+static int fd_add[FD_ADD_MAX];

+int fd_add_count = 0;

+static pthread_mutex_t fd_add_lock = PTHREAD_MUTEX_INITIALIZER;

+static pthread_cond_t fd_add_ready_cond = PTHREAD_COND_INITIALIZER;

+static pthread_t fd_add_tid = NULL;

+

+static EventListPtr darwinEvents = NULL;

+

+static pthread_mutex_t mieq_lock = PTHREAD_MUTEX_INITIALIZER;

+static pthread_cond_t mieq_ready_cond = PTHREAD_COND_INITIALIZER;

+

+/*** Pthread Magics ***/

+static pthread_t create_thread(void *func, void *arg) {

+    pthread_attr_t attr;

+    pthread_t tid;

+

+    pthread_attr_init (&attr);

+    pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);

+    pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);

+    pthread_create (&tid, &attr, func, arg);

+    pthread_attr_destroy (&attr);

+

+    return tid;

+}

+

+void darwinEvents_lock(void);

+void darwinEvents_lock(void) {

+    int err;

+    if((err = pthread_mutex_lock(&mieq_lock))) {

+        ErrorF("%s:%s:%d: Failed to lock mieq_lock: %d\n",

+               __FILE__, __FUNCTION__, __LINE__, err);

+        spewCallStack();

+    }

+    if(darwinEvents == NULL) {

+        pthread_cond_wait(&mieq_ready_cond, &mieq_lock);

+    }

+}

+

+void darwinEvents_unlock(void);

+void darwinEvents_unlock(void) {

+    int err;

+    if((err = pthread_mutex_unlock(&mieq_lock))) {

+        ErrorF("%s:%s:%d: Failed to unlock mieq_lock: %d\n",

+               __FILE__, __FUNCTION__, __LINE__, err);

+        spewCallStack();

+    }

+}

+

+/*

+ * DarwinPressModifierKey

+ * Press or release the given modifier key (one of NX_MODIFIERKEY_* constants)

+ */

+static void DarwinPressModifierKey(int pressed, int key) {

+    int keycode = DarwinModifierNXKeyToNXKeycode(key, 0);

+

+    if (keycode == 0) {

+        ErrorF("DarwinPressModifierKey bad keycode: key=%d\n", key);

+        return;

+    }

+

+    DarwinSendKeyboardEvents(pressed, keycode);

+}

+

+/*

+ * DarwinUpdateModifiers

+ *  Send events to update the modifier state.

+ */

+

+static int darwin_x11_modifier_mask_list[] = {

+#ifdef NX_DEVICELCMDKEYMASK

+    NX_DEVICELCTLKEYMASK, NX_DEVICERCTLKEYMASK,

+    NX_DEVICELSHIFTKEYMASK, NX_DEVICERSHIFTKEYMASK,

+    NX_DEVICELCMDKEYMASK, NX_DEVICERCMDKEYMASK,

+    NX_DEVICELALTKEYMASK, NX_DEVICERALTKEYMASK,

+#else

+    NX_CONTROLMASK, NX_SHIFTMASK, NX_COMMANDMASK, NX_ALTERNATEMASK,

+#endif

+    NX_ALPHASHIFTMASK,

+    0

+};

+

+static int darwin_all_modifier_mask_additions[] = { NX_SECONDARYFNMASK, };

+

+static void DarwinUpdateModifiers(

+    int pressed,        // KeyPress or KeyRelease

+    int flags )         // modifier flags that have changed

+{

+    int *f;

+    int key;

+

+    /* Capslock is special.  This mask is the state of capslock (on/off),

+     * not the state of the button.  Hopefully we can find a better solution.

+     */

+    if(NX_ALPHASHIFTMASK & flags) {

+        DarwinPressModifierKey(KeyPress, NX_MODIFIERKEY_ALPHALOCK);

+        DarwinPressModifierKey(KeyRelease, NX_MODIFIERKEY_ALPHALOCK);

+    }

+    

+    for(f=darwin_x11_modifier_mask_list; *f; f++)

+        if(*f & flags && *f != NX_ALPHASHIFTMASK) {

+            key = DarwinModifierNXMaskToNXKey(*f);

+            if(key == -1)

+                ErrorF("DarwinUpdateModifiers: Unsupported NXMask: 0x%x\n", *f);

+            else

+                DarwinPressModifierKey(pressed, key);

+        }

+}

+

+/* Generic handler for Xquartz-specifc events.  When possible, these should

+   be moved into their own individual functions and set as handlers using

+   mieqSetHandler. */

+

+static void DarwinEventHandler(int screenNum, InternalEvent *ie, DeviceIntPtr dev) {

+    XQuartzEvent *e = &(ie->xquartz_event);

+

+    TA_SERVER();

+

+    switch(e->subtype) {

+        case kXquartzControllerNotify:

+            DEBUG_LOG("kXquartzControllerNotify\n");

+            AppleWMSendEvent(AppleWMControllerNotify,

+                             AppleWMControllerNotifyMask,

+                             e->data[0],

+                             e->data[1]);

+            break;

+            

+        case kXquartzPasteboardNotify:

+            DEBUG_LOG("kXquartzPasteboardNotify\n");

+            AppleWMSendEvent(AppleWMPasteboardNotify,

+                             AppleWMPasteboardNotifyMask,

+                             e->data[0],

+                             e->data[1]);

+            break;

+            

+        case kXquartzActivate:

+            DEBUG_LOG("kXquartzActivate\n");

+            QuartzShow();

+            AppleWMSendEvent(AppleWMActivationNotify,

+                             AppleWMActivationNotifyMask,

+                             AppleWMIsActive, 0);

+            break;

+            

+        case kXquartzDeactivate:

+            DEBUG_LOG("kXquartzDeactivate\n");

+            AppleWMSendEvent(AppleWMActivationNotify,

+                             AppleWMActivationNotifyMask,

+                             AppleWMIsInactive, 0);

+            QuartzHide();

+            break;

+

+        case kXquartzReloadPreferences:

+            DEBUG_LOG("kXquartzReloadPreferences\n");

+            AppleWMSendEvent(AppleWMActivationNotify,

+                             AppleWMActivationNotifyMask,

+                             AppleWMReloadPreferences, 0);

+            break;

+            

+        case kXquartzToggleFullscreen:

+            DEBUG_LOG("kXquartzToggleFullscreen\n");

+            if (quartzEnableRootless) 

+                QuartzSetFullscreen(!quartzHasRoot);

+            else if (quartzHasRoot)

+                QuartzHide();

+            else

+                QuartzShow();

+            break;

+            

+        case kXquartzSetRootless:

+            DEBUG_LOG("kXquartzSetRootless\n");

+            QuartzSetRootless(e->data[0]);

+            if (!quartzEnableRootless && !quartzHasRoot)

+                QuartzHide();

+            break;

+            

+        case kXquartzSetRootClip:

+            QuartzSetRootClip((Bool)e->data[0]);

+            break;

+            

+        case kXquartzQuit:

+            GiveUp(0);

+            break;

+            

+        case kXquartzSpaceChanged:

+            DEBUG_LOG("kXquartzSpaceChanged\n");

+            QuartzSpaceChanged(e->data[0]);

+            break;

+

+        case kXquartzListenOnOpenFD:

+            ErrorF("Calling ListenOnOpenFD() for new fd: %d\n", (int)e->data[0]);

+            ListenOnOpenFD((int)e->data[0], 1);

+            break;

+            

+        case kXquartzReloadKeymap:

+            DarwinKeyboardReloadHandler();

+            break;

+            

+        case kXquartzDisplayChanged:

+            QuartzUpdateScreens();

+            break;

+            

+        default:

+            if(!QuartzModeEventHandler(screenNum, e, dev))

+                ErrorF("Unknown application defined event type %d.\n", e->subtype);

+    }	

+}

+

+void DarwinListenOnOpenFD(int fd) {

+    ErrorF("DarwinListenOnOpenFD: %d\n", fd);

+    

+    pthread_mutex_lock(&fd_add_lock);

+    if(fd_add_count < FD_ADD_MAX)

+        fd_add[fd_add_count++] = fd;

+    else

+        ErrorF("FD Addition buffer at max.  Dropping fd addition request.\n");

+

+    pthread_cond_broadcast(&fd_add_ready_cond);

+    pthread_mutex_unlock(&fd_add_lock);

+}

+

+static void DarwinProcessFDAdditionQueue_thread(void *args) {

+    pthread_mutex_lock(&fd_add_lock);

+    while(true) {

+        while(fd_add_count) {

+            DarwinSendDDXEvent(kXquartzListenOnOpenFD, 1, fd_add[--fd_add_count]);

+        }

+        pthread_cond_wait(&fd_add_ready_cond, &fd_add_lock);

+    }

+}

+

+Bool DarwinEQInit(void) { 

+    int *p;

+

+    for(p=darwin_x11_modifier_mask_list, darwin_all_modifier_mask=0; *p; p++) {

+        darwin_x11_modifier_mask |= *p;

+    }

+    

+    for(p=darwin_all_modifier_mask_additions, darwin_all_modifier_mask= darwin_x11_modifier_mask; *p; p++) {

+        darwin_all_modifier_mask |= *p;

+    }

+    

+    mieqInit();

+    mieqSetHandler(ET_XQuartz, DarwinEventHandler);

+

+    /* Note that this *could* cause a potential async issue, since we're checking

+     * darwinEvents without holding the lock, but darwinEvents is only ever set

+     * here, so I don't bother.

+     */

+    if (!darwinEvents) {

+        darwinEvents = InitEventList(GetMaximumEventsNum());;

+        

+        if (!darwinEvents)

+            FatalError("Couldn't allocate event buffer\n");

+        

+        darwinEvents_lock();

+        pthread_cond_broadcast(&mieq_ready_cond);

+        darwinEvents_unlock();

+    }

+

+    if(!fd_add_tid)

+        fd_add_tid = create_thread(DarwinProcessFDAdditionQueue_thread, NULL);

+    

+    return TRUE;

+}

+

+/*

+ * ProcessInputEvents

+ *  Read and process events from the event queue until it is empty.

+ */

+void ProcessInputEvents(void) {

+    char nullbyte;

+	int x = sizeof(nullbyte);

+    

+    TA_SERVER();

+

+    mieqProcessInputEvents();

+

+    // Empty the signaling pipe

+    while (x == sizeof(nullbyte)) {

+      x = read(darwinEventReadFD, &nullbyte, sizeof(nullbyte));

+    }

+}

+

+/* Sends a null byte down darwinEventWriteFD, which will cause the

+   Dispatch() event loop to check out event queue */

+static void DarwinPokeEQ(void) {

+	char nullbyte=0;

+	//  <daniels> oh, i ... er ... christ.

+	write(darwinEventWriteFD, &nullbyte, sizeof(nullbyte));

+}

+

+/* Convert from Appkit pointer input values to X input values:

+ * Note: pointer_x and pointer_y are relative to the upper-left of primary

+ *       display.

+ */

+static void DarwinPrepareValuators(DeviceIntPtr pDev, int *valuators, ScreenPtr screen,

+                                   float pointer_x, float pointer_y, 

+                                   float pressure, float tilt_x, float tilt_y) {

+    /* Fix offset between darwin and X screens */

+    pointer_x -= darwinMainScreenX + screen->x;

+    pointer_y -= darwinMainScreenY + screen->y;

+

+    if(pointer_x < 0.0)

+        pointer_x = 0.0;

+

+    if(pointer_y < 0.0)

+        pointer_y = 0.0;

+    

+    if(pDev == darwinPointer) {

+        valuators[0] = pointer_x;

+        valuators[1] = pointer_y;

+        valuators[2] = 0;

+        valuators[3] = 0;

+        valuators[4] = 0;

+    } else {

+        /* Setup our array of values */

+        valuators[0] = XQUARTZ_VALUATOR_LIMIT * (pointer_x / (float)screenInfo.screens[0]->width);

+        valuators[1] = XQUARTZ_VALUATOR_LIMIT * (pointer_y / (float)screenInfo.screens[0]->height);

+        valuators[2] = XQUARTZ_VALUATOR_LIMIT * pressure;

+        valuators[3] = XQUARTZ_VALUATOR_LIMIT * tilt_x;

+        valuators[4] = XQUARTZ_VALUATOR_LIMIT * tilt_y;

+    }

+    //DEBUG_LOG("Pointer (%f, %f), Valuators: {%d,%d,%d,%d,%d}\n", pointer_x, pointer_y,

+    //          valuators[0], valuators[1], valuators[2], valuators[3], valuators[4]);

+}

+

+void DarwinSendPointerEvents(DeviceIntPtr pDev, int ev_type, int ev_button, float pointer_x, float pointer_y, 

+			     float pressure, float tilt_x, float tilt_y) {

+	static int darwinFakeMouseButtonDown = 0;

+	int i, num_events;

+    ScreenPtr screen;

+    int valuators[5];

+	

+    //DEBUG_LOG("x=%f, y=%f, p=%f, tx=%f, ty=%f\n", pointer_x, pointer_y, pressure, tilt_x, tilt_y);

+    

+	if(!darwinEvents) {

+		DEBUG_LOG("DarwinSendPointerEvents called before darwinEvents was initialized\n");

+		return;

+	}

+

+    screen = miPointerGetScreen(pDev);

+    if(!screen) {

+        DEBUG_LOG("DarwinSendPointerEvents called before screen was initialized\n");

+        return;

+    }

+

+    /* Handle fake click */

+	if (ev_type == ButtonPress && darwinFakeButtons && ev_button == 1) {

+        if(darwinFakeMouseButtonDown != 0) {

+            /* We're currently "down" with another button, so release it first */

+            DarwinSendPointerEvents(pDev, ButtonRelease, darwinFakeMouseButtonDown, pointer_x, pointer_y, pressure, tilt_x, tilt_y);

+            darwinFakeMouseButtonDown=0;

+        }

+		if (darwin_all_modifier_flags & darwinFakeMouse2Mask) {

+            ev_button = 2;

+			darwinFakeMouseButtonDown = 2;

+            DarwinUpdateModKeys(darwin_all_modifier_flags & ~darwinFakeMouse2Mask);

+		} else if (darwin_all_modifier_flags & darwinFakeMouse3Mask) {

+            ev_button = 3;

+			darwinFakeMouseButtonDown = 3;

+            DarwinUpdateModKeys(darwin_all_modifier_flags & ~darwinFakeMouse3Mask);

+		}

+	}

+

+	if (ev_type == ButtonRelease && ev_button == 1) {

+        if(darwinFakeMouseButtonDown) {

+            ev_button = darwinFakeMouseButtonDown;

+        }

+

+        if(darwinFakeMouseButtonDown == 2) {

+            DarwinUpdateModKeys(darwin_all_modifier_flags & ~darwinFakeMouse2Mask);

+        } else if(darwinFakeMouseButtonDown == 3) {

+            DarwinUpdateModKeys(darwin_all_modifier_flags & ~darwinFakeMouse3Mask);

+        }

+

+        darwinFakeMouseButtonDown = 0;

+	}

+

+    DarwinPrepareValuators(pDev, valuators, screen, pointer_x, pointer_y, pressure, tilt_x, tilt_y);

+    darwinEvents_lock(); {

+        num_events = GetPointerEvents(darwinEvents, pDev, ev_type, ev_button, 

+                                      POINTER_ABSOLUTE, 0, pDev==darwinTabletCurrent?5:2, valuators);

+        for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);

+        if(num_events > 0) DarwinPokeEQ();

+    } darwinEvents_unlock();

+}

+

+void DarwinSendKeyboardEvents(int ev_type, int keycode) {

+	int i, num_events;

+

+	if(!darwinEvents) {

+		DEBUG_LOG("DarwinSendKeyboardEvents called before darwinEvents was initialized\n");

+		return;

+	}

+

+    darwinEvents_lock(); {

+        num_events = GetKeyboardEvents(darwinEvents, darwinKeyboard, ev_type, keycode + MIN_KEYCODE);

+        for(i=0; i<num_events; i++) mieqEnqueue(darwinKeyboard, (InternalEvent*)darwinEvents[i].event);

+        if(num_events > 0) DarwinPokeEQ();

+    } darwinEvents_unlock();

+}

+

+void DarwinSendProximityEvents(int ev_type, float pointer_x, float pointer_y) {

+	int i, num_events;

+    ScreenPtr screen;

+    DeviceIntPtr pDev = darwinTabletCurrent;

+    int valuators[5];

+

+	DEBUG_LOG("DarwinSendProximityEvents(%d, %f, %f)\n", ev_type, pointer_x, pointer_y);

+

+	if(!darwinEvents) {

+		DEBUG_LOG("DarwinSendProximityEvents called before darwinEvents was initialized\n");

+		return;

+	}

+    

+    screen = miPointerGetScreen(pDev);

+    if(!screen) {

+        DEBUG_LOG("DarwinSendPointerEvents called before screen was initialized\n");

+        return;

+    }    

+

+    DarwinPrepareValuators(pDev, valuators, screen, pointer_x, pointer_y, 0.0f, 0.0f, 0.0f);

+    darwinEvents_lock(); {

+        num_events = GetProximityEvents(darwinEvents, pDev, ev_type,

+                                        0, 5, valuators);

+        for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);

+        if(num_events > 0) DarwinPokeEQ();

+    } darwinEvents_unlock();

+}

+

+

+/* Send the appropriate number of button clicks to emulate scroll wheel */

+void DarwinSendScrollEvents(float count_x, float count_y, 

+							float pointer_x, float pointer_y, 

+			    			float pressure, float tilt_x, float tilt_y) {

+	int sign_x, sign_y;

+	if(!darwinEvents) {

+		DEBUG_LOG("DarwinSendScrollEvents called before darwinEvents was initialized\n");

+		return;

+	}

+

+	sign_x = count_x > 0.0f ? SCROLLWHEELLEFTFAKE : SCROLLWHEELRIGHTFAKE;

+	sign_y = count_y > 0.0f ? SCROLLWHEELUPFAKE : SCROLLWHEELDOWNFAKE;

+	count_x = fabs(count_x);

+	count_y = fabs(count_y);

+	

+	while ((count_x > 0.0f) || (count_y > 0.0f)) {

+		if (count_x > 0.0f) {

+			DarwinSendPointerEvents(darwinPointer, ButtonPress, sign_x, pointer_x, pointer_y, pressure, tilt_x, tilt_y);

+			DarwinSendPointerEvents(darwinPointer, ButtonRelease, sign_x, pointer_x, pointer_y, pressure, tilt_x, tilt_y);

+			count_x = count_x - 1.0f;

+		}

+		if (count_y > 0.0f) {

+			DarwinSendPointerEvents(darwinPointer, ButtonPress, sign_y, pointer_x, pointer_y, pressure, tilt_x, tilt_y);

+			DarwinSendPointerEvents(darwinPointer, ButtonRelease, sign_y, pointer_x, pointer_y, pressure, tilt_x, tilt_y);

+			count_y = count_y - 1.0f;

+		}

+	}

+}

+

+/* Send the appropriate KeyPress/KeyRelease events to GetKeyboardEvents to

+   reflect changing modifier flags (alt, control, meta, etc) */

+void DarwinUpdateModKeys(int flags) {

+	DarwinUpdateModifiers(KeyRelease, darwin_all_modifier_flags & ~flags & darwin_x11_modifier_mask);

+	DarwinUpdateModifiers(KeyPress, ~darwin_all_modifier_flags & flags & darwin_x11_modifier_mask);

+	darwin_all_modifier_flags = flags;

+}

+

+/*

+ * DarwinSendDDXEvent

+ *  Send the X server thread a message by placing it on the event queue.

+ */

+void DarwinSendDDXEvent(int type, int argc, ...) {

+    XQuartzEvent e;

+    int i;

+    va_list args;

+

+    memset(&e, 0, sizeof(e));

+    e.header = ET_Internal;

+    e.type = ET_XQuartz;

+    e.length = sizeof(e);

+    e.time = GetTimeInMillis();

+    e.subtype = type;

+

+    if (argc > 0 && argc < XQUARTZ_EVENT_MAXARGS) {

+        va_start (args, argc);

+        for (i = 0; i < argc; i++)

+            e.data[i] = (uint32_t) va_arg (args, uint32_t);

+        va_end (args);

+    }

+

+    darwinEvents_lock(); {

+        mieqEnqueue(NULL, (InternalEvent*)&e);

+        DarwinPokeEQ();

+    } darwinEvents_unlock();

+}

diff --git a/xorg-server/hw/xquartz/darwinXinput.c b/xorg-server/hw/xquartz/darwinXinput.c
index 54ba2032a..958c7cdd4 100644
--- a/xorg-server/hw/xquartz/darwinXinput.c
+++ b/xorg-server/hw/xquartz/darwinXinput.c
@@ -210,14 +210,14 @@ ChangeDeviceControl(ClientPtr client, DeviceIntPtr dev,
   DEBUG_LOG("ChangeDeviceControl(%p, %p, %p)\n", client, dev, control);

     switch (control->control) {

     case DEVICE_RESOLUTION:

-	return (BadMatch);

+	return BadMatch;

     case DEVICE_ABS_CALIB:

     case DEVICE_ABS_AREA:

-        return (BadMatch);

+        return BadMatch;

     case DEVICE_CORE:

-        return (BadMatch);

+        return BadMatch;

     default:

-	return (BadMatch);

+	return BadMatch;

     }

 }

 

diff --git a/xorg-server/hw/xquartz/mach-startup/bundle-main.c b/xorg-server/hw/xquartz/mach-startup/bundle-main.c
index 63a185fc8..6dc7f9094 100644
--- a/xorg-server/hw/xquartz/mach-startup/bundle-main.c
+++ b/xorg-server/hw/xquartz/mach-startup/bundle-main.c
@@ -1,692 +1,692 @@
-/* main.c -- X application launcher
- 
- Copyright (c) 2007 Jeremy Huddleston
- Copyright (c) 2007 Apple Inc
- 
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation files
- (the "Software"), to deal in the Software without restriction,
- including without limitation the rights to use, copy, modify, merge,
- publish, distribute, sublicense, and/or sell copies of the Software,
- and to permit persons to whom the Software is furnished to do so,
- subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT.  IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT
- HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- DEALINGS IN THE SOFTWARE.
- 
- Except as contained in this notice, the name(s) of the above
- copyright holders shall not be used in advertising or otherwise to
- promote the sale, use or other dealings in this Software without
- prior written authorization. */
-
-#include <CoreFoundation/CoreFoundation.h>
-#include <AvailabilityMacros.h>
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <X11/Xlib.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <stdbool.h>
-#include <signal.h>
-
-#include <sys/socket.h>
-#include <sys/un.h>
-
-#include <sys/time.h>
-#include <fcntl.h>
-
-#include <mach/mach.h>
-#include <mach/mach_error.h>
-#include <servers/bootstrap.h>
-#include "mach_startup.h"
-#include "mach_startupServer.h"
-
-#include "launchd_fd.h"
-/* From darwinEvents.c ... but don't want to pull in all the server cruft */
-void DarwinListenOnOpenFD(int fd);
-
-extern int noPanoramiXExtension;
-
-#define DEFAULT_CLIENT X11BINDIR "/xterm"
-#define DEFAULT_STARTX X11BINDIR "/startx"
-#define DEFAULT_SHELL  "/bin/sh"
-
-#ifndef BUILD_DATE
-#define BUILD_DATE ""
-#endif
-#ifndef XSERVER_VERSION
-#define XSERVER_VERSION "?"
-#endif
-
-static char __crashreporter_info_buff__[4096] = {0};
-static const char *__crashreporter_info__ = &__crashreporter_info_buff__[0];
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
-// This is actually a toolchain requirement, but I'm not sure the correct check,
-// but it should be fine to just only include it for Leopard and later.  This line
-// just tells the linker to never strip this symbol (such as for space optimization)
-asm (".desc ___crashreporter_info__, 0x10");
-#endif
-
-static const char *__crashreporter_info__base = "X.Org X Server " XSERVER_VERSION " Build Date: " BUILD_DATE;
-
-static char *launchd_id_prefix = NULL;
-static char *server_bootstrap_name = NULL;
-
-#define DEBUG 1
-
-/* This is in quartzStartup.c */
-int server_main(int argc, char **argv, char **envp);
-
-static int execute(const char *command);
-static char *command_from_prefs(const char *key, const char *default_value);
-
-/*** Pthread Magics ***/
-static pthread_t create_thread(void *func, void *arg) {
-    pthread_attr_t attr;
-    pthread_t tid;
-	
-    pthread_attr_init (&attr);
-    pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
-    pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
-    pthread_create (&tid, &attr, func, arg);
-    pthread_attr_destroy (&attr);
-	
-    return tid;
-}
-
-/*** Mach-O IPC Stuffs ***/
-
-union MaxMsgSize {
-	union __RequestUnion__mach_startup_subsystem req;
-	union __ReplyUnion__mach_startup_subsystem rep; 
-};
-
-static mach_port_t checkin_or_register(char *bname) {
-    kern_return_t kr;
-    mach_port_t mp;
-
-    /* If we're started by launchd or the old mach_init */
-    kr = bootstrap_check_in(bootstrap_port, bname, &mp);
-    if (kr == KERN_SUCCESS)
-        return mp;
-
-    /* We probably were not started by launchd or the old mach_init */
-    kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &mp);
-    if (kr != KERN_SUCCESS) {
-        fprintf(stderr, "mach_port_allocate(): %s\n", mach_error_string(kr));
-        exit(EXIT_FAILURE);
-    }
-
-    kr = mach_port_insert_right(mach_task_self(), mp, mp, MACH_MSG_TYPE_MAKE_SEND);
-    if (kr != KERN_SUCCESS) {
-        fprintf(stderr, "mach_port_insert_right(): %s\n", mach_error_string(kr));
-        exit(EXIT_FAILURE);
-    }
-
-    kr = bootstrap_register(bootstrap_port, bname, mp);
-    if (kr != KERN_SUCCESS) {
-        fprintf(stderr, "bootstrap_register(): %s\n", mach_error_string(kr));
-        exit(EXIT_FAILURE);
-    }
-
-    return mp;
-}
-
-/*** $DISPLAY handoff ***/
-static int accept_fd_handoff(int connected_fd) {
-    int launchd_fd;
-    
-    char databuf[] = "display";
-    struct iovec iov[1];
-    
-    union {
-        struct cmsghdr hdr;
-        char bytes[CMSG_SPACE(sizeof(int))];
-    } buf;
-    
-    struct msghdr msg;
-    struct cmsghdr *cmsg;
-
-    iov[0].iov_base = databuf;
-    iov[0].iov_len  = sizeof(databuf);
-    
-    msg.msg_iov = iov;
-    msg.msg_iovlen = 1;
-    msg.msg_control = buf.bytes;
-    msg.msg_controllen = sizeof(buf);
-    msg.msg_name = 0;
-    msg.msg_namelen = 0;
-    msg.msg_flags = 0;
-    
-    cmsg = CMSG_FIRSTHDR (&msg);
-    cmsg->cmsg_level = SOL_SOCKET;
-    cmsg->cmsg_type = SCM_RIGHTS;
-    cmsg->cmsg_len = CMSG_LEN(sizeof(int));
-    
-    msg.msg_controllen = cmsg->cmsg_len;
-    
-    *((int*)CMSG_DATA(cmsg)) = -1;
-    
-    if(recvmsg(connected_fd, &msg, 0) < 0) {
-        fprintf(stderr, "X11.app: Error receiving $DISPLAY file descriptor.  recvmsg() error: %s\n", strerror(errno));
-        return -1;
-    }
-    
-    launchd_fd = *((int*)CMSG_DATA(cmsg));
-    
-    return launchd_fd;
-}
-
-typedef struct {
-    int fd;
-    string_t filename;
-} socket_handoff_t;
-
-/* This thread accepts an incoming connection and hands off the file
- * descriptor for the new connection to accept_fd_handoff()
- */
-static void socket_handoff_thread(void *arg) {
-    socket_handoff_t *handoff_data = (socket_handoff_t *)arg;
-    int launchd_fd = -1;
-    int connected_fd;
-    unsigned remain;
-
-    /* Now actually get the passed file descriptor from this connection
-     * If we encounter an error, keep listening.
-     */
-    while(launchd_fd == -1) {
-        connected_fd = accept(handoff_data->fd, NULL, NULL);
-        if(connected_fd == -1) {
-            fprintf(stderr, "X11.app: Failed to accept incoming connection on socket (fd=%d): %s\n", handoff_data->fd, strerror(errno));
-            sleep(2);
-            continue;
-        }
-
-        launchd_fd = accept_fd_handoff(connected_fd);
-        if(launchd_fd == -1)
-            fprintf(stderr, "X11.app: Error receiving $DISPLAY file descriptor, no descriptor received?  Waiting for another connection.\n");
-
-        close(connected_fd);
-    }
-
-    close(handoff_data->fd);
-    unlink(handoff_data->filename);
-    free(handoff_data);
-    
-    /* TODO: Clean up this race better... giving xinitrc time to run... need to wait for 1.5 branch:
-     *
-     * From ajax:
-     * There's already an internal callback chain for setting selection [in 1.5]
-     * ownership.  See the CallSelectionCallback at the bottom of
-     * ProcSetSelectionOwner, and xfixes/select.c for an example of how to hook
-     * into it.
-     */
-    
-    remain = 3000000;
-    fprintf(stderr, "X11.app: Received new $DISPLAY fd: %d ... sleeping to allow xinitrc to catchup.\n", launchd_fd);
-    while((remain = usleep(remain)) > 0);
-    
-    fprintf(stderr, "X11.app Handing off fd to server thread via DarwinListenOnOpenFD(%d)\n", launchd_fd);
-    DarwinListenOnOpenFD(launchd_fd);
-}
-
-static int create_socket(char *filename_out) {
-    struct sockaddr_un servaddr_un;
-    struct sockaddr *servaddr;
-    socklen_t servaddr_len;
-    int ret_fd;
-    size_t try, try_max;
-    
-    for(try=0, try_max=5; try < try_max; try++) {
-        tmpnam(filename_out);
-        
-        /* Setup servaddr_un */
-        memset (&servaddr_un, 0, sizeof (struct sockaddr_un));
-        servaddr_un.sun_family = AF_UNIX;
-        strlcpy(servaddr_un.sun_path, filename_out, sizeof(servaddr_un.sun_path));
-        
-        servaddr = (struct sockaddr *) &servaddr_un;
-        servaddr_len = sizeof(struct sockaddr_un) - sizeof(servaddr_un.sun_path) + strlen(filename_out);
-        
-        ret_fd = socket(PF_UNIX, SOCK_STREAM, 0);
-        if(ret_fd == -1) {
-            fprintf(stderr, "X11.app: Failed to create socket (try %d / %d): %s - %s\n", (int)try+1, (int)try_max, filename_out, strerror(errno));
-            continue;
-        }
-        
-        if(bind(ret_fd, servaddr, servaddr_len) != 0) {
-            fprintf(stderr, "X11.app: Failed to bind socket: %d - %s\n", errno, strerror(errno));
-            close(ret_fd);
-            return 0;
-        }
-        
-        if(listen(ret_fd, 10) != 0) {
-            fprintf(stderr, "X11.app: Failed to listen to socket: %s - %d - %s\n", filename_out, errno, strerror(errno));
-            close(ret_fd);
-            return 0;
-        }
-        
-#ifdef DEBUG
-        fprintf(stderr, "X11.app: Listening on socket for fd handoff:  (%d) %s\n", ret_fd, filename_out);
-#endif
-        
-        return ret_fd;
-    }
-    
-    return 0;
-}
-
-static int launchd_socket_handed_off = 0;
-
-kern_return_t do_request_fd_handoff_socket(mach_port_t port, string_t filename) {
-    socket_handoff_t *handoff_data;
-    
-    launchd_socket_handed_off = 1;
-
-    handoff_data = (socket_handoff_t *)calloc(1,sizeof(socket_handoff_t));
-    if(!handoff_data) {
-        fprintf(stderr, "X11.app: Error allocating memory for handoff_data\n");
-        return KERN_FAILURE;
-    }
-
-    handoff_data->fd = create_socket(handoff_data->filename);
-    if(!handoff_data->fd) {
-        free(handoff_data);
-        return KERN_FAILURE;
-    }
-
-    strlcpy(filename, handoff_data->filename, STRING_T_SIZE);
-    
-    create_thread(socket_handoff_thread, handoff_data);
-    
-#ifdef DEBUG
-    fprintf(stderr, "X11.app: Thread created for handoff.  Returning success to tell caller to connect and push the fd.\n");
-#endif
-
-    return KERN_SUCCESS;
-}
-
-kern_return_t do_request_pid(mach_port_t port, int *my_pid) {
-    *my_pid = getpid();
-    return KERN_SUCCESS;
-}
-
-/*** Server Startup ***/
-kern_return_t do_start_x11_server(mach_port_t port, string_array_t argv,
-                                  mach_msg_type_number_t argvCnt,
-                                  string_array_t envp,
-                                  mach_msg_type_number_t envpCnt) {
-    /* And now back to char ** */
-    char **_argv = alloca((argvCnt + 1) * sizeof(char *));
-    char **_envp = alloca((envpCnt + 1) * sizeof(char *));
-    size_t i;
-    
-    /* If we didn't get handed a launchd DISPLAY socket, we should
-     * unset DISPLAY or we can run into problems with pbproxy
-     */
-    if(!launchd_socket_handed_off) {
-        fprintf(stderr, "X11.app: No launchd socket handed off, unsetting DISPLAY\n");
-        unsetenv("DISPLAY");
-    }
-    
-    if(!_argv || !_envp) {
-        return KERN_FAILURE;
-    }
-
-    fprintf(stderr, "X11.app: do_start_x11_server(): argc=%d\n", argvCnt);
-    for(i=0; i < argvCnt; i++) {
-        _argv[i] = argv[i];
-        fprintf(stderr, "\targv[%u] = %s\n", (unsigned)i, argv[i]);
-    }
-    _argv[argvCnt] = NULL;
-    
-    for(i=0; i < envpCnt; i++) {
-        _envp[i] = envp[i];
-    }
-    _envp[envpCnt] = NULL;
-    
-    if(server_main(argvCnt, _argv, _envp) == 0)
-        return KERN_SUCCESS;
-    else
-        return KERN_FAILURE;
-}
-
-static int startup_trigger(int argc, char **argv, char **envp) {
-    Display *display;
-    const char *s;
-    
-    /* Take care of the case where we're called like a normal DDX */
-    if(argc > 1 && argv[1][0] == ':') {
-        size_t i;
-        kern_return_t kr;
-        mach_port_t mp;
-        string_array_t newenvp;
-        string_array_t newargv;
-
-        /* We need to count envp */
-        int envpc;
-        for(envpc=0; envp[envpc]; envpc++);
-
-        /* We have fixed-size string lengths due to limitations in IPC,
-         * so we need to copy our argv and envp.
-         */
-        newargv = (string_array_t)alloca(argc * sizeof(string_t));
-        newenvp = (string_array_t)alloca(envpc * sizeof(string_t));
-        
-        if(!newargv || !newenvp) {
-            fprintf(stderr, "Memory allocation failure\n");
-            exit(EXIT_FAILURE);
-        }
-        
-        for(i=0; i < argc; i++) {
-            strlcpy(newargv[i], argv[i], STRING_T_SIZE);
-        }
-        for(i=0; i < envpc; i++) {
-            strlcpy(newenvp[i], envp[i], STRING_T_SIZE);
-        }
-
-        kr = bootstrap_look_up(bootstrap_port, server_bootstrap_name, &mp);
-        if (kr != KERN_SUCCESS) {
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
-            fprintf(stderr, "bootstrap_look_up(%s): %s\n", server_bootstrap_name, bootstrap_strerror(kr));
-#else
-            fprintf(stderr, "bootstrap_look_up(%s): %ul\n", server_bootstrap_name, (unsigned long)kr);
-#endif
-            exit(EXIT_FAILURE);
-        }
-
-        kr = start_x11_server(mp, newargv, argc, newenvp, envpc);
-        if (kr != KERN_SUCCESS) {
-            fprintf(stderr, "start_x11_server: %s\n", mach_error_string(kr));
-            exit(EXIT_FAILURE);
-        }
-        exit(EXIT_SUCCESS);
-    }
-
-    /* If we have a process serial number and it's our only arg, act as if
-     * the user double clicked the app bundle: launch app_to_run if possible
-     */
-    if(argc == 1 || (argc == 2 && !strncmp(argv[1], "-psn_", 5))) {
-        /* Now, try to open a display, if so, run the launcher */
-        display = XOpenDisplay(NULL);
-        if(display) {
-            /* Could open the display, start the launcher */
-            XCloseDisplay(display);
-
-            return execute(command_from_prefs("app_to_run", DEFAULT_CLIENT));
-        }
-    }
-
-    /* Start the server */
-    if((s = getenv("DISPLAY"))) {
-        fprintf(stderr, "X11.app: Could not connect to server (DISPLAY=\"%s\", unsetting).  Starting X server.\n", s);
-        unsetenv("DISPLAY");
-    } else {
-        fprintf(stderr, "X11.app: Could not connect to server (DISPLAY is not set).  Starting X server.\n");
-    }
-    return execute(command_from_prefs("startx_script", DEFAULT_STARTX));
-}
-
-/** Setup the environment we want our child processes to inherit */
-static void ensure_path(const char *dir) {
-    char buf[1024], *temp;
-    
-    /* Make sure /usr/X11/bin is in the $PATH */
-    temp = getenv("PATH");
-    if(temp == NULL || temp[0] == 0) {
-        snprintf(buf, sizeof(buf), "/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:%s", dir);
-        setenv("PATH", buf, TRUE);
-    } else if(strnstr(temp, X11BINDIR, sizeof(temp)) == NULL) {
-        snprintf(buf, sizeof(buf), "%s:%s", temp, dir);
-        setenv("PATH", buf, TRUE);
-    }
-}
-
-static void setup_env(void) {
-    char *temp;
-    const char *pds = NULL;
-    const char *disp = getenv("DISPLAY");
-    size_t len;
-
-    /* Pass on our prefs domain to startx and its inheritors (mainly for
-     * quartz-wm and the Xquartz stub's MachIPC)
-     */
-    CFBundleRef bundle = CFBundleGetMainBundle();
-    if(bundle) {
-        CFStringRef pd = CFBundleGetIdentifier(bundle);
-        if(pd) {
-            pds = CFStringGetCStringPtr(pd, 0);
-        }
-    }
-
-    /* fallback to hardcoded value if we can't discover it */
-    if(!pds) {
-        pds = LAUNCHD_ID_PREFIX".X11";
-    }
-
-    server_bootstrap_name = malloc(sizeof(char) * (strlen(pds) + 1));
-    if(!server_bootstrap_name) {
-        fprintf(stderr, "X11.app: Memory allocation error.\n");
-        exit(1);
-    }
-    strcpy(server_bootstrap_name, pds);
-    setenv("X11_PREFS_DOMAIN", server_bootstrap_name, 1);
-    
-    len = strlen(server_bootstrap_name);
-    launchd_id_prefix = malloc(sizeof(char) * (len - 3));
-    if(!launchd_id_prefix) {
-        fprintf(stderr, "X11.app: Memory allocation error.\n");
-        exit(1);
-    }
-    strlcpy(launchd_id_prefix, server_bootstrap_name, len - 3);
-    
-    /* We need to unset DISPLAY if it is not our socket */
-    if(disp) {
-        /* s = basename(disp) */
-        const char *d, *s;
-	    for(s = NULL, d = disp; *d; d++) {
-            if(*d == '/')
-                s = d + 1;
-        }
-
-        if(s && *s) {
-            if(strcmp(launchd_id_prefix, "org.x") == 0 && strcmp(s, ":0") == 0) {
-                fprintf(stderr, "X11.app: Detected old style launchd DISPLAY, please update xinit.\n");
-            } else {
-                temp = (char *)malloc(sizeof(char) * len);
-                if(!temp) {
-                    fprintf(stderr, "X11.app: Memory allocation error creating space for socket name test.\n");
-                    exit(1);
-                }
-                strlcpy(temp, launchd_id_prefix, len);
-                strlcat(temp, ":0", len);
-            
-                if(strcmp(temp, s) != 0) {
-                    /* If we don't have a match, unset it. */
-                    fprintf(stderr, "X11.app: DISPLAY (\"%s\") does not match our id (\"%s\"), unsetting.\n", disp, launchd_id_prefix);
-                    unsetenv("DISPLAY");
-                }
-                free(temp);
-            }
-        } else {
-            /* The DISPLAY environment variable is not formatted like a launchd socket, so reset. */
-            fprintf(stderr, "X11.app: DISPLAY does not look like a launchd set variable, unsetting.\n");
-            unsetenv("DISPLAY");
-        }
-    }
-
-    /* Make sure PATH is right */
-    ensure_path(X11BINDIR);
-    
-    /* cd $HOME */
-    temp = getenv("HOME");
-    if(temp != NULL && temp[0] != '\0')
-        chdir(temp);
-}
-
-/*** Main ***/
-int main(int argc, char **argv, char **envp) {
-    Bool listenOnly = FALSE;
-    int i;
-    mach_msg_size_t mxmsgsz = sizeof(union MaxMsgSize) + MAX_TRAILER_SIZE;
-    mach_port_t mp;
-    kern_return_t kr;
-
-    /* Setup our environment for our children */
-    setup_env();
-    
-    /* The server must not run the PanoramiX operations. */
-    noPanoramiXExtension = TRUE;
-
-    /* Setup the initial crasherporter info */
-    strlcpy(__crashreporter_info_buff__, __crashreporter_info__base, sizeof(__crashreporter_info_buff__));
-    
-    fprintf(stderr, "X11.app: main(): argc=%d\n", argc);
-    for(i=0; i < argc; i++) {
-        fprintf(stderr, "\targv[%u] = %s\n", (unsigned)i, argv[i]);
-        if(!strcmp(argv[i], "--listenonly")) {
-            listenOnly = TRUE;
-        }
-    }
-
-    mp = checkin_or_register(server_bootstrap_name);
-    if(mp == MACH_PORT_NULL) {
-        fprintf(stderr, "NULL mach service: %s", server_bootstrap_name);
-        return EXIT_FAILURE;
-    }
-    
-    /* Check if we need to do something other than listen, and make another
-     * thread handle it.
-     */
-    if(!listenOnly) {
-        pid_t child1, child2;
-        int status;
-
-        /* Do the fork-twice trick to avoid having to reap zombies */
-        child1 = fork();
-        switch (child1) {
-            case -1:                                /* error */
-                break;
-
-            case 0:                                 /* child1 */
-                child2 = fork();
-
-                switch (child2) {
-                    int max_files, i;
-
-                    case -1:                            /* error */
-                        break;
-
-                    case 0:                             /* child2 */
-                        /* close all open files except for standard streams */
-                        max_files = sysconf(_SC_OPEN_MAX);
-                        for(i = 3; i < max_files; i++)
-                            close(i);
-
-                        /* ensure stdin is on /dev/null */
-                        close(0);
-                        open("/dev/null", O_RDONLY);
-
-                        return startup_trigger(argc, argv, envp);
-
-                    default:                            /* parent (child1) */
-                        _exit(0);
-                }
-                break;
-
-            default:                                /* parent */
-              waitpid(child1, &status, 0);
-        }
-    }
-    
-    /* Main event loop */
-    fprintf(stderr, "Waiting for startup parameters via Mach IPC.\n");
-    kr = mach_msg_server(mach_startup_server, mxmsgsz, mp, 0);
-    if (kr != KERN_SUCCESS) {
-        fprintf(stderr, "%s.X11(mp): %s\n", LAUNCHD_ID_PREFIX, mach_error_string(kr));
-        return EXIT_FAILURE;
-    }
-    
-    return EXIT_SUCCESS;
-}
-
-static int execute(const char *command) {
-    const char *newargv[4];
-    const char **p;
-    
-    newargv[0] = command_from_prefs("login_shell", DEFAULT_SHELL);
-    newargv[1] = "-c";
-    newargv[2] = command;
-    newargv[3] = NULL;
-    
-    fprintf(stderr, "X11.app: Launching %s:\n", command);
-    for(p=newargv; *p; p++) {
-        fprintf(stderr, "\targv[%ld] = %s\n", (long int)(p - newargv), *p);
-    }
-
-    execvp (newargv[0], (char * const *) newargv);
-    perror ("X11.app: Couldn't exec.");
-    return(1);
-}
-
-static char *command_from_prefs(const char *key, const char *default_value) {
-    char *command = NULL;
-    
-    CFStringRef cfKey;
-    CFPropertyListRef PlistRef;
-
-    if(!key)
-        return NULL;
-
-    cfKey = CFStringCreateWithCString(NULL, key, kCFStringEncodingASCII);
-
-    if(!cfKey)
-        return NULL;
-
-    PlistRef = CFPreferencesCopyAppValue(cfKey, kCFPreferencesCurrentApplication);
-    
-    if ((PlistRef == NULL) || (CFGetTypeID(PlistRef) != CFStringGetTypeID())) {
-        CFStringRef cfDefaultValue = CFStringCreateWithCString(NULL, default_value, kCFStringEncodingASCII);
-        int len = strlen(default_value) + 1;
-
-        if(!cfDefaultValue)
-            goto command_from_prefs_out;
-
-        CFPreferencesSetAppValue(cfKey, cfDefaultValue, kCFPreferencesCurrentApplication);
-        CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);
-        CFRelease(cfDefaultValue);
-        
-        command = (char *)malloc(len * sizeof(char));
-        if(!command)
-            goto command_from_prefs_out;
-        strcpy(command, default_value);
-    } else {
-        int len = CFStringGetLength((CFStringRef)PlistRef) + 1;
-        command = (char *)malloc(len * sizeof(char));
-        if(!command)
-            goto command_from_prefs_out;
-        CFStringGetCString((CFStringRef)PlistRef, command, len,  kCFStringEncodingASCII);
-    }
-
-command_from_prefs_out:
-    if (PlistRef)
-        CFRelease(PlistRef);
-    if(cfKey)
-        CFRelease(cfKey);
-    return command;
-}
+/* main.c -- X application launcher

+ 

+ Copyright (c) 2007 Jeremy Huddleston

+ Copyright (c) 2007 Apple Inc

+ 

+ Permission is hereby granted, free of charge, to any person

+ obtaining a copy of this software and associated documentation files

+ (the "Software"), to deal in the Software without restriction,

+ including without limitation the rights to use, copy, modify, merge,

+ publish, distribute, sublicense, and/or sell copies of the Software,

+ and to permit persons to whom the Software is furnished to do so,

+ subject to the following conditions:

+ 

+ The above copyright notice and this permission notice shall be

+ included in all copies or substantial portions of the Software.

+ 

+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ NONINFRINGEMENT.  IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT

+ HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

+ DEALINGS IN THE SOFTWARE.

+ 

+ Except as contained in this notice, the name(s) of the above

+ copyright holders shall not be used in advertising or otherwise to

+ promote the sale, use or other dealings in this Software without

+ prior written authorization. */

+

+#include <CoreFoundation/CoreFoundation.h>

+#include <AvailabilityMacros.h>

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include <X11/Xlib.h>

+#include <unistd.h>

+#include <stdio.h>

+#include <string.h>

+#include <stdlib.h>

+#include <pthread.h>

+#include <stdbool.h>

+#include <signal.h>

+

+#include <sys/socket.h>

+#include <sys/un.h>

+

+#include <sys/time.h>

+#include <fcntl.h>

+

+#include <mach/mach.h>

+#include <mach/mach_error.h>

+#include <servers/bootstrap.h>

+#include "mach_startup.h"

+#include "mach_startupServer.h"

+

+#include "launchd_fd.h"

+/* From darwinEvents.c ... but don't want to pull in all the server cruft */

+void DarwinListenOnOpenFD(int fd);

+

+extern int noPanoramiXExtension;

+

+#define DEFAULT_CLIENT X11BINDIR "/xterm"

+#define DEFAULT_STARTX X11BINDIR "/startx"

+#define DEFAULT_SHELL  "/bin/sh"

+

+#ifndef BUILD_DATE

+#define BUILD_DATE ""

+#endif

+#ifndef XSERVER_VERSION

+#define XSERVER_VERSION "?"

+#endif

+

+static char __crashreporter_info_buff__[4096] = {0};

+static const char *__crashreporter_info__ = &__crashreporter_info_buff__[0];

+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050

+// This is actually a toolchain requirement, but I'm not sure the correct check,

+// but it should be fine to just only include it for Leopard and later.  This line

+// just tells the linker to never strip this symbol (such as for space optimization)

+asm (".desc ___crashreporter_info__, 0x10");

+#endif

+

+static const char *__crashreporter_info__base = "X.Org X Server " XSERVER_VERSION " Build Date: " BUILD_DATE;

+

+static char *launchd_id_prefix = NULL;

+static char *server_bootstrap_name = NULL;

+

+#define DEBUG 1

+

+/* This is in quartzStartup.c */

+int server_main(int argc, char **argv, char **envp);

+

+static int execute(const char *command);

+static char *command_from_prefs(const char *key, const char *default_value);

+

+/*** Pthread Magics ***/

+static pthread_t create_thread(void *func, void *arg) {

+    pthread_attr_t attr;

+    pthread_t tid;

+	

+    pthread_attr_init (&attr);

+    pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);

+    pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);

+    pthread_create (&tid, &attr, func, arg);

+    pthread_attr_destroy (&attr);

+	

+    return tid;

+}

+

+/*** Mach-O IPC Stuffs ***/

+

+union MaxMsgSize {

+	union __RequestUnion__mach_startup_subsystem req;

+	union __ReplyUnion__mach_startup_subsystem rep; 

+};

+

+static mach_port_t checkin_or_register(char *bname) {

+    kern_return_t kr;

+    mach_port_t mp;

+

+    /* If we're started by launchd or the old mach_init */

+    kr = bootstrap_check_in(bootstrap_port, bname, &mp);

+    if (kr == KERN_SUCCESS)

+        return mp;

+

+    /* We probably were not started by launchd or the old mach_init */

+    kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &mp);

+    if (kr != KERN_SUCCESS) {

+        fprintf(stderr, "mach_port_allocate(): %s\n", mach_error_string(kr));

+        exit(EXIT_FAILURE);

+    }

+

+    kr = mach_port_insert_right(mach_task_self(), mp, mp, MACH_MSG_TYPE_MAKE_SEND);

+    if (kr != KERN_SUCCESS) {

+        fprintf(stderr, "mach_port_insert_right(): %s\n", mach_error_string(kr));

+        exit(EXIT_FAILURE);

+    }

+

+    kr = bootstrap_register(bootstrap_port, bname, mp);

+    if (kr != KERN_SUCCESS) {

+        fprintf(stderr, "bootstrap_register(): %s\n", mach_error_string(kr));

+        exit(EXIT_FAILURE);

+    }

+

+    return mp;

+}

+

+/*** $DISPLAY handoff ***/

+static int accept_fd_handoff(int connected_fd) {

+    int launchd_fd;

+    

+    char databuf[] = "display";

+    struct iovec iov[1];

+    

+    union {

+        struct cmsghdr hdr;

+        char bytes[CMSG_SPACE(sizeof(int))];

+    } buf;

+    

+    struct msghdr msg;

+    struct cmsghdr *cmsg;

+

+    iov[0].iov_base = databuf;

+    iov[0].iov_len  = sizeof(databuf);

+    

+    msg.msg_iov = iov;

+    msg.msg_iovlen = 1;

+    msg.msg_control = buf.bytes;

+    msg.msg_controllen = sizeof(buf);

+    msg.msg_name = 0;

+    msg.msg_namelen = 0;

+    msg.msg_flags = 0;

+    

+    cmsg = CMSG_FIRSTHDR (&msg);

+    cmsg->cmsg_level = SOL_SOCKET;

+    cmsg->cmsg_type = SCM_RIGHTS;

+    cmsg->cmsg_len = CMSG_LEN(sizeof(int));

+    

+    msg.msg_controllen = cmsg->cmsg_len;

+    

+    *((int*)CMSG_DATA(cmsg)) = -1;

+    

+    if(recvmsg(connected_fd, &msg, 0) < 0) {

+        fprintf(stderr, "X11.app: Error receiving $DISPLAY file descriptor.  recvmsg() error: %s\n", strerror(errno));

+        return -1;

+    }

+    

+    launchd_fd = *((int*)CMSG_DATA(cmsg));

+    

+    return launchd_fd;

+}

+

+typedef struct {

+    int fd;

+    string_t filename;

+} socket_handoff_t;

+

+/* This thread accepts an incoming connection and hands off the file

+ * descriptor for the new connection to accept_fd_handoff()

+ */

+static void socket_handoff_thread(void *arg) {

+    socket_handoff_t *handoff_data = (socket_handoff_t *)arg;

+    int launchd_fd = -1;

+    int connected_fd;

+    unsigned remain;

+

+    /* Now actually get the passed file descriptor from this connection

+     * If we encounter an error, keep listening.

+     */

+    while(launchd_fd == -1) {

+        connected_fd = accept(handoff_data->fd, NULL, NULL);

+        if(connected_fd == -1) {

+            fprintf(stderr, "X11.app: Failed to accept incoming connection on socket (fd=%d): %s\n", handoff_data->fd, strerror(errno));

+            sleep(2);

+            continue;

+        }

+

+        launchd_fd = accept_fd_handoff(connected_fd);

+        if(launchd_fd == -1)

+            fprintf(stderr, "X11.app: Error receiving $DISPLAY file descriptor, no descriptor received?  Waiting for another connection.\n");

+

+        close(connected_fd);

+    }

+

+    close(handoff_data->fd);

+    unlink(handoff_data->filename);

+    free(handoff_data);

+    

+    /* TODO: Clean up this race better... giving xinitrc time to run... need to wait for 1.5 branch:

+     *

+     * From ajax:

+     * There's already an internal callback chain for setting selection [in 1.5]

+     * ownership.  See the CallSelectionCallback at the bottom of

+     * ProcSetSelectionOwner, and xfixes/select.c for an example of how to hook

+     * into it.

+     */

+    

+    remain = 3000000;

+    fprintf(stderr, "X11.app: Received new $DISPLAY fd: %d ... sleeping to allow xinitrc to catchup.\n", launchd_fd);

+    while((remain = usleep(remain)) > 0);

+    

+    fprintf(stderr, "X11.app Handing off fd to server thread via DarwinListenOnOpenFD(%d)\n", launchd_fd);

+    DarwinListenOnOpenFD(launchd_fd);

+}

+

+static int create_socket(char *filename_out) {

+    struct sockaddr_un servaddr_un;

+    struct sockaddr *servaddr;

+    socklen_t servaddr_len;

+    int ret_fd;

+    size_t try, try_max;

+    

+    for(try=0, try_max=5; try < try_max; try++) {

+        tmpnam(filename_out);

+        

+        /* Setup servaddr_un */

+        memset (&servaddr_un, 0, sizeof (struct sockaddr_un));

+        servaddr_un.sun_family = AF_UNIX;

+        strlcpy(servaddr_un.sun_path, filename_out, sizeof(servaddr_un.sun_path));

+        

+        servaddr = (struct sockaddr *) &servaddr_un;

+        servaddr_len = sizeof(struct sockaddr_un) - sizeof(servaddr_un.sun_path) + strlen(filename_out);

+        

+        ret_fd = socket(PF_UNIX, SOCK_STREAM, 0);

+        if(ret_fd == -1) {

+            fprintf(stderr, "X11.app: Failed to create socket (try %d / %d): %s - %s\n", (int)try+1, (int)try_max, filename_out, strerror(errno));

+            continue;

+        }

+        

+        if(bind(ret_fd, servaddr, servaddr_len) != 0) {

+            fprintf(stderr, "X11.app: Failed to bind socket: %d - %s\n", errno, strerror(errno));

+            close(ret_fd);

+            return 0;

+        }

+        

+        if(listen(ret_fd, 10) != 0) {

+            fprintf(stderr, "X11.app: Failed to listen to socket: %s - %d - %s\n", filename_out, errno, strerror(errno));

+            close(ret_fd);

+            return 0;

+        }

+        

+#ifdef DEBUG

+        fprintf(stderr, "X11.app: Listening on socket for fd handoff:  (%d) %s\n", ret_fd, filename_out);

+#endif

+        

+        return ret_fd;

+    }

+    

+    return 0;

+}

+

+static int launchd_socket_handed_off = 0;

+

+kern_return_t do_request_fd_handoff_socket(mach_port_t port, string_t filename) {

+    socket_handoff_t *handoff_data;

+    

+    launchd_socket_handed_off = 1;

+

+    handoff_data = (socket_handoff_t *)calloc(1,sizeof(socket_handoff_t));

+    if(!handoff_data) {

+        fprintf(stderr, "X11.app: Error allocating memory for handoff_data\n");

+        return KERN_FAILURE;

+    }

+

+    handoff_data->fd = create_socket(handoff_data->filename);

+    if(!handoff_data->fd) {

+        free(handoff_data);

+        return KERN_FAILURE;

+    }

+

+    strlcpy(filename, handoff_data->filename, STRING_T_SIZE);

+    

+    create_thread(socket_handoff_thread, handoff_data);

+    

+#ifdef DEBUG

+    fprintf(stderr, "X11.app: Thread created for handoff.  Returning success to tell caller to connect and push the fd.\n");

+#endif

+

+    return KERN_SUCCESS;

+}

+

+kern_return_t do_request_pid(mach_port_t port, int *my_pid) {

+    *my_pid = getpid();

+    return KERN_SUCCESS;

+}

+

+/*** Server Startup ***/

+kern_return_t do_start_x11_server(mach_port_t port, string_array_t argv,

+                                  mach_msg_type_number_t argvCnt,

+                                  string_array_t envp,

+                                  mach_msg_type_number_t envpCnt) {

+    /* And now back to char ** */

+    char **_argv = alloca((argvCnt + 1) * sizeof(char *));

+    char **_envp = alloca((envpCnt + 1) * sizeof(char *));

+    size_t i;

+    

+    /* If we didn't get handed a launchd DISPLAY socket, we should

+     * unset DISPLAY or we can run into problems with pbproxy

+     */

+    if(!launchd_socket_handed_off) {

+        fprintf(stderr, "X11.app: No launchd socket handed off, unsetting DISPLAY\n");

+        unsetenv("DISPLAY");

+    }

+    

+    if(!_argv || !_envp) {

+        return KERN_FAILURE;

+    }

+

+    fprintf(stderr, "X11.app: do_start_x11_server(): argc=%d\n", argvCnt);

+    for(i=0; i < argvCnt; i++) {

+        _argv[i] = argv[i];

+        fprintf(stderr, "\targv[%u] = %s\n", (unsigned)i, argv[i]);

+    }

+    _argv[argvCnt] = NULL;

+    

+    for(i=0; i < envpCnt; i++) {

+        _envp[i] = envp[i];

+    }

+    _envp[envpCnt] = NULL;

+    

+    if(server_main(argvCnt, _argv, _envp) == 0)

+        return KERN_SUCCESS;

+    else

+        return KERN_FAILURE;

+}

+

+static int startup_trigger(int argc, char **argv, char **envp) {

+    Display *display;

+    const char *s;

+    

+    /* Take care of the case where we're called like a normal DDX */

+    if(argc > 1 && argv[1][0] == ':') {

+        size_t i;

+        kern_return_t kr;

+        mach_port_t mp;

+        string_array_t newenvp;

+        string_array_t newargv;

+

+        /* We need to count envp */

+        int envpc;

+        for(envpc=0; envp[envpc]; envpc++);

+

+        /* We have fixed-size string lengths due to limitations in IPC,

+         * so we need to copy our argv and envp.

+         */

+        newargv = (string_array_t)alloca(argc * sizeof(string_t));

+        newenvp = (string_array_t)alloca(envpc * sizeof(string_t));

+        

+        if(!newargv || !newenvp) {

+            fprintf(stderr, "Memory allocation failure\n");

+            exit(EXIT_FAILURE);

+        }

+        

+        for(i=0; i < argc; i++) {

+            strlcpy(newargv[i], argv[i], STRING_T_SIZE);

+        }

+        for(i=0; i < envpc; i++) {

+            strlcpy(newenvp[i], envp[i], STRING_T_SIZE);

+        }

+

+        kr = bootstrap_look_up(bootstrap_port, server_bootstrap_name, &mp);

+        if (kr != KERN_SUCCESS) {

+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050

+            fprintf(stderr, "bootstrap_look_up(%s): %s\n", server_bootstrap_name, bootstrap_strerror(kr));

+#else

+            fprintf(stderr, "bootstrap_look_up(%s): %ul\n", server_bootstrap_name, (unsigned long)kr);

+#endif

+            exit(EXIT_FAILURE);

+        }

+

+        kr = start_x11_server(mp, newargv, argc, newenvp, envpc);

+        if (kr != KERN_SUCCESS) {

+            fprintf(stderr, "start_x11_server: %s\n", mach_error_string(kr));

+            exit(EXIT_FAILURE);

+        }

+        exit(EXIT_SUCCESS);

+    }

+

+    /* If we have a process serial number and it's our only arg, act as if

+     * the user double clicked the app bundle: launch app_to_run if possible

+     */

+    if(argc == 1 || (argc == 2 && !strncmp(argv[1], "-psn_", 5))) {

+        /* Now, try to open a display, if so, run the launcher */

+        display = XOpenDisplay(NULL);

+        if(display) {

+            /* Could open the display, start the launcher */

+            XCloseDisplay(display);

+

+            return execute(command_from_prefs("app_to_run", DEFAULT_CLIENT));

+        }

+    }

+

+    /* Start the server */

+    if((s = getenv("DISPLAY"))) {

+        fprintf(stderr, "X11.app: Could not connect to server (DISPLAY=\"%s\", unsetting).  Starting X server.\n", s);

+        unsetenv("DISPLAY");

+    } else {

+        fprintf(stderr, "X11.app: Could not connect to server (DISPLAY is not set).  Starting X server.\n");

+    }

+    return execute(command_from_prefs("startx_script", DEFAULT_STARTX));

+}

+

+/** Setup the environment we want our child processes to inherit */

+static void ensure_path(const char *dir) {

+    char buf[1024], *temp;

+    

+    /* Make sure /usr/X11/bin is in the $PATH */

+    temp = getenv("PATH");

+    if(temp == NULL || temp[0] == 0) {

+        snprintf(buf, sizeof(buf), "/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:%s", dir);

+        setenv("PATH", buf, TRUE);

+    } else if(strnstr(temp, X11BINDIR, sizeof(temp)) == NULL) {

+        snprintf(buf, sizeof(buf), "%s:%s", temp, dir);

+        setenv("PATH", buf, TRUE);

+    }

+}

+

+static void setup_env(void) {

+    char *temp;

+    const char *pds = NULL;

+    const char *disp = getenv("DISPLAY");

+    size_t len;

+

+    /* Pass on our prefs domain to startx and its inheritors (mainly for

+     * quartz-wm and the Xquartz stub's MachIPC)

+     */

+    CFBundleRef bundle = CFBundleGetMainBundle();

+    if(bundle) {

+        CFStringRef pd = CFBundleGetIdentifier(bundle);

+        if(pd) {

+            pds = CFStringGetCStringPtr(pd, 0);

+        }

+    }

+

+    /* fallback to hardcoded value if we can't discover it */

+    if(!pds) {

+        pds = LAUNCHD_ID_PREFIX".X11";

+    }

+

+    server_bootstrap_name = malloc(sizeof(char) * (strlen(pds) + 1));

+    if(!server_bootstrap_name) {

+        fprintf(stderr, "X11.app: Memory allocation error.\n");

+        exit(1);

+    }

+    strcpy(server_bootstrap_name, pds);

+    setenv("X11_PREFS_DOMAIN", server_bootstrap_name, 1);

+    

+    len = strlen(server_bootstrap_name);

+    launchd_id_prefix = malloc(sizeof(char) * (len - 3));

+    if(!launchd_id_prefix) {

+        fprintf(stderr, "X11.app: Memory allocation error.\n");

+        exit(1);

+    }

+    strlcpy(launchd_id_prefix, server_bootstrap_name, len - 3);

+    

+    /* We need to unset DISPLAY if it is not our socket */

+    if(disp) {

+        /* s = basename(disp) */

+        const char *d, *s;

+	    for(s = NULL, d = disp; *d; d++) {

+            if(*d == '/')

+                s = d + 1;

+        }

+

+        if(s && *s) {

+            if(strcmp(launchd_id_prefix, "org.x") == 0 && strcmp(s, ":0") == 0) {

+                fprintf(stderr, "X11.app: Detected old style launchd DISPLAY, please update xinit.\n");

+            } else {

+                temp = (char *)malloc(sizeof(char) * len);

+                if(!temp) {

+                    fprintf(stderr, "X11.app: Memory allocation error creating space for socket name test.\n");

+                    exit(1);

+                }

+                strlcpy(temp, launchd_id_prefix, len);

+                strlcat(temp, ":0", len);

+            

+                if(strcmp(temp, s) != 0) {

+                    /* If we don't have a match, unset it. */

+                    fprintf(stderr, "X11.app: DISPLAY (\"%s\") does not match our id (\"%s\"), unsetting.\n", disp, launchd_id_prefix);

+                    unsetenv("DISPLAY");

+                }

+                free(temp);

+            }

+        } else {

+            /* The DISPLAY environment variable is not formatted like a launchd socket, so reset. */

+            fprintf(stderr, "X11.app: DISPLAY does not look like a launchd set variable, unsetting.\n");

+            unsetenv("DISPLAY");

+        }

+    }

+

+    /* Make sure PATH is right */

+    ensure_path(X11BINDIR);

+    

+    /* cd $HOME */

+    temp = getenv("HOME");

+    if(temp != NULL && temp[0] != '\0')

+        chdir(temp);

+}

+

+/*** Main ***/

+int main(int argc, char **argv, char **envp) {

+    Bool listenOnly = FALSE;

+    int i;

+    mach_msg_size_t mxmsgsz = sizeof(union MaxMsgSize) + MAX_TRAILER_SIZE;

+    mach_port_t mp;

+    kern_return_t kr;

+

+    /* Setup our environment for our children */

+    setup_env();

+    

+    /* The server must not run the PanoramiX operations. */

+    noPanoramiXExtension = TRUE;

+

+    /* Setup the initial crasherporter info */

+    strlcpy(__crashreporter_info_buff__, __crashreporter_info__base, sizeof(__crashreporter_info_buff__));

+    

+    fprintf(stderr, "X11.app: main(): argc=%d\n", argc);

+    for(i=0; i < argc; i++) {

+        fprintf(stderr, "\targv[%u] = %s\n", (unsigned)i, argv[i]);

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

+            listenOnly = TRUE;

+        }

+    }

+

+    mp = checkin_or_register(server_bootstrap_name);

+    if(mp == MACH_PORT_NULL) {

+        fprintf(stderr, "NULL mach service: %s", server_bootstrap_name);

+        return EXIT_FAILURE;

+    }

+    

+    /* Check if we need to do something other than listen, and make another

+     * thread handle it.

+     */

+    if(!listenOnly) {

+        pid_t child1, child2;

+        int status;

+

+        /* Do the fork-twice trick to avoid having to reap zombies */

+        child1 = fork();

+        switch (child1) {

+            case -1:                                /* error */

+                break;

+

+            case 0:                                 /* child1 */

+                child2 = fork();

+

+                switch (child2) {

+                    int max_files, i;

+

+                    case -1:                            /* error */

+                        break;

+

+                    case 0:                             /* child2 */

+                        /* close all open files except for standard streams */

+                        max_files = sysconf(_SC_OPEN_MAX);

+                        for(i = 3; i < max_files; i++)

+                            close(i);

+

+                        /* ensure stdin is on /dev/null */

+                        close(0);

+                        open("/dev/null", O_RDONLY);

+

+                        return startup_trigger(argc, argv, envp);

+

+                    default:                            /* parent (child1) */

+                        _exit(0);

+                }

+                break;

+

+            default:                                /* parent */

+              waitpid(child1, &status, 0);

+        }

+    }

+    

+    /* Main event loop */

+    fprintf(stderr, "Waiting for startup parameters via Mach IPC.\n");

+    kr = mach_msg_server(mach_startup_server, mxmsgsz, mp, 0);

+    if (kr != KERN_SUCCESS) {

+        fprintf(stderr, "%s.X11(mp): %s\n", LAUNCHD_ID_PREFIX, mach_error_string(kr));

+        return EXIT_FAILURE;

+    }

+    

+    return EXIT_SUCCESS;

+}

+

+static int execute(const char *command) {

+    const char *newargv[4];

+    const char **p;

+    

+    newargv[0] = command_from_prefs("login_shell", DEFAULT_SHELL);

+    newargv[1] = "-c";

+    newargv[2] = command;

+    newargv[3] = NULL;

+    

+    fprintf(stderr, "X11.app: Launching %s:\n", command);

+    for(p=newargv; *p; p++) {

+        fprintf(stderr, "\targv[%ld] = %s\n", (long int)(p - newargv), *p);

+    }

+

+    execvp (newargv[0], (char * const *) newargv);

+    perror ("X11.app: Couldn't exec.");

+    return 1;

+}

+

+static char *command_from_prefs(const char *key, const char *default_value) {

+    char *command = NULL;

+    

+    CFStringRef cfKey;

+    CFPropertyListRef PlistRef;

+

+    if(!key)

+        return NULL;

+

+    cfKey = CFStringCreateWithCString(NULL, key, kCFStringEncodingASCII);

+

+    if(!cfKey)

+        return NULL;

+

+    PlistRef = CFPreferencesCopyAppValue(cfKey, kCFPreferencesCurrentApplication);

+    

+    if ((PlistRef == NULL) || (CFGetTypeID(PlistRef) != CFStringGetTypeID())) {

+        CFStringRef cfDefaultValue = CFStringCreateWithCString(NULL, default_value, kCFStringEncodingASCII);

+        int len = strlen(default_value) + 1;

+

+        if(!cfDefaultValue)

+            goto command_from_prefs_out;

+

+        CFPreferencesSetAppValue(cfKey, cfDefaultValue, kCFPreferencesCurrentApplication);

+        CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);

+        CFRelease(cfDefaultValue);

+        

+        command = (char *)malloc(len * sizeof(char));

+        if(!command)

+            goto command_from_prefs_out;

+        strcpy(command, default_value);

+    } else {

+        int len = CFStringGetLength((CFStringRef)PlistRef) + 1;

+        command = (char *)malloc(len * sizeof(char));

+        if(!command)

+            goto command_from_prefs_out;

+        CFStringGetCString((CFStringRef)PlistRef, command, len,  kCFStringEncodingASCII);

+    }

+

+command_from_prefs_out:

+    if (PlistRef)

+        CFRelease(PlistRef);

+    if(cfKey)

+        CFRelease(cfKey);

+    return command;

+}

diff --git a/xorg-server/hw/xquartz/pseudoramiX.c b/xorg-server/hw/xquartz/pseudoramiX.c
index 1a357528c..ded242d07 100644
--- a/xorg-server/hw/xquartz/pseudoramiX.c
+++ b/xorg-server/hw/xquartz/pseudoramiX.c
@@ -255,9 +255,9 @@ static int ProcPseudoramiXGetScreenSize(ClientPtr client)
     rep.sequenceNumber = client->sequence;

     /* screen dimensions */

     rep.width  = pseudoramiXScreens[stuff->screen].w;

-    // was panoramiXdataPtr[stuff->screen].width;

+    // was screenInfo.screens[stuff->screen]->width;

     rep.height = pseudoramiXScreens[stuff->screen].h;

-    // was panoramiXdataPtr[stuff->screen].height;

+    // was screenInfo.screens[stuff->screen]->height;

     if (client->swapped) {

         swaps (&rep.sequenceNumber, n);

         swapl (&rep.length, n);

diff --git a/xorg-server/hw/xquartz/quartz.c b/xorg-server/hw/xquartz/quartz.c
index e073b0586..c7a4d018a 100644
--- a/xorg-server/hw/xquartz/quartz.c
+++ b/xorg-server/hw/xquartz/quartz.c
@@ -73,8 +73,7 @@ int                     quartzUseAGL = 1;
 int                     quartzEnableKeyEquivalents = 1;

 int                     quartzServerVisible = FALSE;

 int                     quartzServerQuitting = FALSE;

-static int              quartzScreenKeyIndex;

-DevPrivateKey           quartzScreenKey = &quartzScreenKeyIndex;

+DevPrivateKeyRec        quartzScreenKeyRec;

 int                     aquaMenuBarHeight = 0;

 QuartzModeProcsPtr      quartzProcs = NULL;

 const char             *quartzOpenGLBundle = NULL;

@@ -167,6 +166,9 @@ void QuartzInitOutput(
         FatalError("Could not register block and wakeup handlers.");

     }

 

+    if (!dixRegisterPrivateKey(&quartzScreenKeyRec, PRIVATE_SCREEN, 0))

+	FatalError("Failed to alloc quartz screen private.\n");

+

 #if defined(RANDR) && !defined(FAKE_RANDR)

     if(!QuartzRandRInit(pScreen))

         FatalError("Failed to init RandR extension.\n");

@@ -259,8 +261,8 @@ void QuartzUpdateScreens(void) {
     PseudoramiXResetScreens();

     quartzProcs->AddPseudoramiXScreens(&x, &y, &width, &height);

     

-    dixScreenOrigins[pScreen->myNum].x = x;

-    dixScreenOrigins[pScreen->myNum].y = y;

+    pScreen->x = x;

+    pScreen->y = y;

     pScreen->mmWidth = pScreen->mmWidth * ((double) width / pScreen->width);

     pScreen->mmHeight = pScreen->mmHeight * ((double) height / pScreen->height);

     pScreen->width = width;

@@ -269,14 +271,14 @@ void QuartzUpdateScreens(void) {
     DarwinAdjustScreenOrigins(&screenInfo);

     quartzProcs->UpdateScreen(pScreen);

     

-    /* DarwinAdjustScreenOrigins or UpdateScreen may change dixScreenOrigins,

+    /* DarwinAdjustScreenOrigins or UpdateScreen may change pScreen->x/y,

      * so use it rather than x/y

      */

-    sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;

-    sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;

+    sx = pScreen->x + darwinMainScreenX;

+    sy = pScreen->y + darwinMainScreenY;

     

     /* Adjust the root window. */

-    pRoot = WindowTable[pScreen->myNum];

+    pRoot = pScreen->root;

     AppleWMSetScreenOrigin(pRoot);

     pScreen->ResizeWindow(pRoot, x - sx, y - sy, width, height, NULL);

     miPaintWindow(pRoot, &pRoot->borderClip,  PW_BACKGROUND);

@@ -292,7 +294,7 @@ void QuartzUpdateScreens(void) {
     inputInfo.pointer->spriteInfo->sprite->physLimits = bounds;

     inputInfo.pointer->spriteInfo->sprite->hotLimits = bounds;

 

-    DEBUG_LOG("Root Window: %dx%d @ (%d, %d) darwinMainScreen (%d, %d) xy (%d, %d) dixScreenOrigins (%d, %d)\n", width, height, x - sx, y - sy, darwinMainScreenX, darwinMainScreenY, x, y, dixScreenOrigins[pScreen->myNum].x, dixScreenOrigins[pScreen->myNum].y);

+    DEBUG_LOG("Root Window: %dx%d @ (%d, %d) darwinMainScreen (%d, %d) xy (%d, %d) dixScreenOrigins (%d, %d)\n", width, height, x - sx, y - sy, darwinMainScreenX, darwinMainScreenY, x, y, pScreen->x, pScreen->y);

 

     /* Send an event for the root reconfigure */

     e.u.u.type = ConfigureNotify;

diff --git a/xorg-server/hw/xquartz/quartzCommon.h b/xorg-server/hw/xquartz/quartzCommon.h
index 8ab70f22a..12ed4057e 100644
--- a/xorg-server/hw/xquartz/quartzCommon.h
+++ b/xorg-server/hw/xquartz/quartzCommon.h
@@ -1,85 +1,86 @@
-/*
- * quartzCommon.h
- *
- * Common definitions used internally by all Quartz modes
- *
- * This file should be included before any X11 or IOKit headers
- * so that it can avoid symbol conflicts.
- *
- * Copyright (c) 2001-2004 Torrey T. Lyons and Greg Parker.
- *                 All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name(s) of the above copyright
- * holders shall not be used in advertising or otherwise to promote the sale,
- * use or other dealings in this Software without prior written authorization.
- */
-
-#ifndef _QUARTZCOMMON_H
-#define _QUARTZCOMMON_H
-
-#include <X11/Xdefs.h>
-#include "privates.h"
-
-// Quartz specific per screen storage structure
-typedef struct {
-    // List of CoreGraphics displays that this X11 screen covers.
-    // This is more than one CG display for video mirroring and
-    // rootless PseudoramiX mode.
-    // No CG display will be covered by more than one X11 screen.
-    int displayCount;
-    CGDirectDisplayID *displayIDs;
-} QuartzScreenRec, *QuartzScreenPtr;
-
-#define QUARTZ_PRIV(pScreen) \
-    ((QuartzScreenPtr)dixLookupPrivate(&pScreen->devPrivates, quartzScreenKey))
-
-// Data stored at startup for Cocoa front end
-extern int              quartzEventWriteFD;
-
-// User preferences used by Quartz modes
-extern int              quartzUseSysBeep;
-extern int              focusOnNewWindow;
-extern int              quartzUseAGL;
-extern int              quartzEnableKeyEquivalents;
-extern int              quartzFullscreenDisableHotkeys;
-extern int              quartzOptionSendsAlt;
-
-// Other shared data
-extern int              quartzServerVisible;
-extern int              quartzServerQuitting;
-extern DevPrivateKey    quartzScreenKey;
-extern int              aquaMenuBarHeight;
-
-// Name of GLX bundle for native OpenGL
-extern const char      *quartzOpenGLBundle;
-
-void QuartzReadPreferences(void);
-void QuartzMessageMainThread(unsigned msg, void *data, unsigned length);
-void QuartzMessageServerThread(int type, int argc, ...);
-void QuartzSetWindowMenu(int nitems, const char **items,
-                         const char *shortcuts);
-void QuartzFSCapture(void);
-void QuartzFSRelease(void);
-int  QuartzFSUseQDCursor(int depth);
-void QuartzBlockHandler(pointer blockData, OSTimePtr pTimeout, pointer pReadmask);
-void QuartzWakeupHandler(pointer blockData, int result, pointer pReadmask);
-
-#endif  /* _QUARTZCOMMON_H */
+/*

+ * quartzCommon.h

+ *

+ * Common definitions used internally by all Quartz modes

+ *

+ * This file should be included before any X11 or IOKit headers

+ * so that it can avoid symbol conflicts.

+ *

+ * Copyright (c) 2001-2004 Torrey T. Lyons and Greg Parker.

+ *                 All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

+ * DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name(s) of the above copyright

+ * holders shall not be used in advertising or otherwise to promote the sale,

+ * use or other dealings in this Software without prior written authorization.

+ */

+

+#ifndef _QUARTZCOMMON_H

+#define _QUARTZCOMMON_H

+

+#include <X11/Xdefs.h>

+#include "privates.h"

+

+// Quartz specific per screen storage structure

+typedef struct {

+    // List of CoreGraphics displays that this X11 screen covers.

+    // This is more than one CG display for video mirroring and

+    // rootless PseudoramiX mode.

+    // No CG display will be covered by more than one X11 screen.

+    int displayCount;

+    CGDirectDisplayID *displayIDs;

+} QuartzScreenRec, *QuartzScreenPtr;

+

+#define QUARTZ_PRIV(pScreen) \

+    ((QuartzScreenPtr)dixLookupPrivate(&pScreen->devPrivates, quartzScreenKey))

+

+// Data stored at startup for Cocoa front end

+extern int              quartzEventWriteFD;

+

+// User preferences used by Quartz modes

+extern int              quartzUseSysBeep;

+extern int              focusOnNewWindow;

+extern int              quartzUseAGL;

+extern int              quartzEnableKeyEquivalents;

+extern int              quartzFullscreenDisableHotkeys;

+extern int              quartzOptionSendsAlt;

+

+// Other shared data

+extern int              quartzServerVisible;

+extern int              quartzServerQuitting;

+extern DevPrivateKeyRec quartzScreenKeyRec;

+#define quartzScreenKey (&quartzScreenKeyRec)

+extern int              aquaMenuBarHeight;

+

+// Name of GLX bundle for native OpenGL

+extern const char      *quartzOpenGLBundle;

+

+void QuartzReadPreferences(void);

+void QuartzMessageMainThread(unsigned msg, void *data, unsigned length);

+void QuartzMessageServerThread(int type, int argc, ...);

+void QuartzSetWindowMenu(int nitems, const char **items,

+                         const char *shortcuts);

+void QuartzFSCapture(void);

+void QuartzFSRelease(void);

+int  QuartzFSUseQDCursor(int depth);

+void QuartzBlockHandler(pointer blockData, OSTimePtr pTimeout, pointer pReadmask);

+void QuartzWakeupHandler(pointer blockData, int result, pointer pReadmask);

+

+#endif  /* _QUARTZCOMMON_H */

diff --git a/xorg-server/hw/xquartz/quartzKeyboard.c b/xorg-server/hw/xquartz/quartzKeyboard.c
index 745333f03..8ea198cd5 100644
--- a/xorg-server/hw/xquartz/quartzKeyboard.c
+++ b/xorg-server/hw/xquartz/quartzKeyboard.c
@@ -1,850 +1,858 @@
-/*
-   quartzKeyboard.c: Keyboard support for Xquartz
-
-   Copyright (c) 2003-2008 Apple Inc.
-   Copyright (c) 2001-2004 Torrey T. Lyons. All Rights Reserved.
-   Copyright 2004 Kaleb S. KEITHLEY. All Rights Reserved.
-
-   Copyright (C) 1999,2000 by Eric Sunshine <sunshine@sunshineco.com>
-   All rights reserved.
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-
-     1. Redistributions of source code must retain the above copyright
-        notice, this list of conditions and the following disclaimer.
-     2. Redistributions in binary form must reproduce the above copyright
-        notice, this list of conditions and the following disclaimer in the
-        documentation and/or other materials provided with the distribution.
-     3. The name of the author may not be used to endorse or promote products
-        derived from this software without specific prior written permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
-   NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include "sanitizedCarbon.h"
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#define HACK_MISSING 1
-#define HACK_KEYPAD 1
-#define HACK_BLACKLIST 1
-
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <AvailabilityMacros.h>
-
-#include "quartzCommon.h"
-#include "darwin.h"
-#include "darwinEvents.h"
-
-#include "quartzKeyboard.h"
-#include "quartzAudio.h"
-
-#include "X11Application.h"
-
-#include "threadSafety.h"
-
-#ifdef NDEBUG
-#undef NDEBUG
-#include <assert.h>
-#define NDEBUG 1
-#else
-#include <assert.h>
-#endif
-#include <pthread.h>
-
-#include "xkbsrv.h"
-#include "exevents.h"
-#include "X11/keysym.h"
-#include "keysym2ucs.h"
-
-extern void
-CopyKeyClass(DeviceIntPtr device, DeviceIntPtr master);
-
-enum {
-    MOD_COMMAND = 256,
-    MOD_SHIFT = 512,
-    MOD_OPTION = 2048,
-    MOD_CONTROL = 4096,
-};
-
-#define UKEYSYM(u) ((u) | 0x01000000)
-
-#if HACK_MISSING
-/* Table of keycode->keysym mappings we use to fallback on for important
-   keys that are often not in the Unicode mapping. */
-
-const static struct {
-    unsigned short keycode;
-    KeySym keysym;
-} known_keys[] = {
-    {55,  XK_Meta_L},
-    {56,  XK_Shift_L},
-    {57,  XK_Caps_Lock},
-    {58,  XK_Alt_L},
-    {59,  XK_Control_L},
-
-    {60,  XK_Shift_R},
-    {61,  XK_Alt_R},
-    {62,  XK_Control_R},
-    {63,  XK_Meta_R},
-
-    {122, XK_F1},
-    {120, XK_F2},
-    {99,  XK_F3},
-    {118, XK_F4},
-    {96,  XK_F5},
-    {97,  XK_F6},
-    {98,  XK_F7},
-    {100, XK_F8},
-    {101, XK_F9},
-    {109, XK_F10},
-    {103, XK_F11},
-    {111, XK_F12},
-    {105, XK_F13},
-    {107, XK_F14},
-    {113, XK_F15},
-};
-#endif
-
-#if HACK_KEYPAD
-/* Table of keycode->old,new-keysym mappings we use to fixup the numeric
-   keypad entries. */
-
-const static struct {
-    unsigned short keycode;
-    KeySym normal, keypad;
-} known_numeric_keys[] = {
-    {65, XK_period, XK_KP_Decimal},
-    {67, XK_asterisk, XK_KP_Multiply},
-    {69, XK_plus, XK_KP_Add},
-    {75, XK_slash, XK_KP_Divide},
-    {76, 0x01000003, XK_KP_Enter},
-    {78, XK_minus, XK_KP_Subtract},
-    {81, XK_equal, XK_KP_Equal},
-    {82, XK_0, XK_KP_0},
-    {83, XK_1, XK_KP_1},
-    {84, XK_2, XK_KP_2},
-    {85, XK_3, XK_KP_3},
-    {86, XK_4, XK_KP_4},
-    {87, XK_5, XK_KP_5},
-    {88, XK_6, XK_KP_6},
-    {89, XK_7, XK_KP_7},
-    {91, XK_8, XK_KP_8},
-    {92, XK_9, XK_KP_9},
-};
-#endif
-
-#if HACK_BLACKLIST
-/* <rdar://problem/7824370> wine notepad produces wrong characters on shift+arrow
- * http://xquartz.macosforge.org/trac/ticket/295
- * http://developer.apple.com/legacy/mac/library/documentation/mac/Text/Text-579.html
- *
- * legacy Mac keycodes for arrow keys that shift-modify to math symbols
- */
-const static unsigned short keycode_blacklist[] = {66, 70, 72, 77};
-#endif
-
-/* Table mapping normal keysyms to their dead equivalents.
-   FIXME: all the unicode keysyms (apart from circumflex) were guessed. */
-
-const static struct {
-    KeySym normal, dead;
-} dead_keys[] = {
-    {XK_grave, XK_dead_grave},
-    {XK_apostrophe, XK_dead_acute},             /* US:"=" on a Czech keyboard */
-    {XK_acute, XK_dead_acute},
-    {UKEYSYM (0x384), XK_dead_acute},           /* US:";" on a Greek keyboard */
-//    {XK_Greek_accentdieresis, XK_dead_diaeresis},   /* US:"opt+;" on a Greek keyboard ... replace with dead_accentdieresis if there is one */
-    {XK_asciicircum, XK_dead_circumflex},
-    {UKEYSYM (0x2c6), XK_dead_circumflex},	/* MODIFIER LETTER CIRCUMFLEX ACCENT */
-    {XK_asciitilde, XK_dead_tilde},
-    {UKEYSYM (0x2dc), XK_dead_tilde},		/* SMALL TILDE */
-    {XK_macron, XK_dead_macron},
-    {XK_breve, XK_dead_breve},
-    {XK_abovedot, XK_dead_abovedot},
-    {XK_diaeresis, XK_dead_diaeresis},
-    {UKEYSYM (0x2da), XK_dead_abovering},	/* DOT ABOVE */
-    {XK_doubleacute, XK_dead_doubleacute},
-    {XK_caron, XK_dead_caron},
-    {XK_cedilla, XK_dead_cedilla},
-    {XK_ogonek, XK_dead_ogonek},
-    {UKEYSYM (0x269), XK_dead_iota},		/* LATIN SMALL LETTER IOTA */
-    {UKEYSYM (0x2ec), XK_dead_voiced_sound},	/* MODIFIER LETTER VOICING */
-/*  {XK_semivoiced_sound, XK_dead_semivoiced_sound}, */
-    {UKEYSYM (0x323), XK_dead_belowdot},	/* COMBINING DOT BELOW */
-    {UKEYSYM (0x309), XK_dead_hook}, 		/* COMBINING HOOK ABOVE */
-    {UKEYSYM (0x31b), XK_dead_horn},		/* COMBINING HORN */
-};
-
-typedef struct darwinKeyboardInfo_struct {
-    CARD8 modMap[MAP_LENGTH];
-    KeySym keyMap[MAP_LENGTH * GLYPHS_PER_KEY];
-    unsigned char modifierKeycodes[32][2];
-} darwinKeyboardInfo;
-
-darwinKeyboardInfo keyInfo;
-pthread_mutex_t keyInfo_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-static void DarwinChangeKeyboardControl(DeviceIntPtr device, KeybdCtrl *ctrl) {
-    // FIXME: to be implemented
-    // keyclick, bell volume / pitch, autorepead, LED's
-}
-
-//-----------------------------------------------------------------------------
-// Utility functions to help parse Darwin keymap
-//-----------------------------------------------------------------------------
-
-/*
- * DarwinBuildModifierMaps
- *      Use the keyMap field of keyboard info structure to populate
- *      the modMap and modifierKeycodes fields.
- */
-static void DarwinBuildModifierMaps(darwinKeyboardInfo *info) {
-    int i;
-    KeySym *k;
-
-    memset(info->modMap, NoSymbol, sizeof(info->modMap));
-    memset(info->modifierKeycodes, 0, sizeof(info->modifierKeycodes));
-
-    for (i = 0; i < NUM_KEYCODES; i++) {
-        k = info->keyMap + i * GLYPHS_PER_KEY;
-
-        switch (*k) {
-            case XK_Shift_L:
-                info->modifierKeycodes[NX_MODIFIERKEY_SHIFT][0] = i;
-                info->modMap[MIN_KEYCODE + i] = ShiftMask;
-                break;
-
-            case XK_Shift_R:
-#ifdef NX_MODIFIERKEY_RSHIFT
-                info->modifierKeycodes[NX_MODIFIERKEY_RSHIFT][0] = i;
-#else
-                info->modifierKeycodes[NX_MODIFIERKEY_SHIFT][0] = i;
-#endif
-                info->modMap[MIN_KEYCODE + i] = ShiftMask;
-                break;
-
-            case XK_Control_L:
-                info->modifierKeycodes[NX_MODIFIERKEY_CONTROL][0] = i;
-                info->modMap[MIN_KEYCODE + i] = ControlMask;
-                break;
-
-            case XK_Control_R:
-#ifdef NX_MODIFIERKEY_RCONTROL
-                info->modifierKeycodes[NX_MODIFIERKEY_RCONTROL][0] = i;
-#else
-                info->modifierKeycodes[NX_MODIFIERKEY_CONTROL][0] = i;
-#endif
-                info->modMap[MIN_KEYCODE + i] = ControlMask;
-                break;
-
-            case XK_Caps_Lock:
-                info->modifierKeycodes[NX_MODIFIERKEY_ALPHALOCK][0] = i;
-                info->modMap[MIN_KEYCODE + i] = LockMask;
-                break;
-
-            case XK_Alt_L:
-                info->modifierKeycodes[NX_MODIFIERKEY_ALTERNATE][0] = i;
-                info->modMap[MIN_KEYCODE + i] = Mod1Mask;
-                if(!quartzOptionSendsAlt)
-                    *k = XK_Mode_switch; // Yes, this is ugly.  This needs to be cleaned up when we integrate quartzKeyboard with this code and refactor.
-                break;
-
-            case XK_Alt_R:
-#ifdef NX_MODIFIERKEY_RALTERNATE
-                info->modifierKeycodes[NX_MODIFIERKEY_RALTERNATE][0] = i;
-#else
-                info->modifierKeycodes[NX_MODIFIERKEY_ALTERNATE][0] = i;
-#endif
-                if(!quartzOptionSendsAlt)
-                    *k = XK_Mode_switch; // Yes, this is ugly.  This needs to be cleaned up when we integrate quartzKeyboard with this code and refactor.
-                info->modMap[MIN_KEYCODE + i] = Mod1Mask;
-                break;
-
-            case XK_Mode_switch:
-                ErrorF("DarwinBuildModifierMaps: XK_Mode_switch encountered, unable to determine side.\n");
-                info->modifierKeycodes[NX_MODIFIERKEY_ALTERNATE][0] = i;
-#ifdef NX_MODIFIERKEY_RALTERNATE
-                info->modifierKeycodes[NX_MODIFIERKEY_RALTERNATE][0] = i;
-#endif
-                info->modMap[MIN_KEYCODE + i] = Mod1Mask;
-                break;
-
-            case XK_Meta_L:
-                info->modifierKeycodes[NX_MODIFIERKEY_COMMAND][0] = i;
-                info->modMap[MIN_KEYCODE + i] = Mod2Mask;
-                break;
-
-            case XK_Meta_R:
-#ifdef NX_MODIFIERKEY_RCOMMAND
-                info->modifierKeycodes[NX_MODIFIERKEY_RCOMMAND][0] = i;
-#else
-                info->modifierKeycodes[NX_MODIFIERKEY_COMMAND][0] = i;
-#endif
-                info->modMap[MIN_KEYCODE + i] = Mod2Mask;
-                break;
-
-            case XK_Num_Lock:
-                info->modMap[MIN_KEYCODE + i] = Mod3Mask;
-                break;
-        }
-    }
-}
-
-/*
- * DarwinKeyboardInit
- *      Get the Darwin keyboard map and compute an equivalent
- *      X keyboard map and modifier map. Set the new keyboard
- *      device structure.
- */
-void DarwinKeyboardInit(DeviceIntPtr pDev) {
-    // Open a shared connection to the HID System.
-    // Note that the Event Status Driver is really just a wrapper
-    // for a kIOHIDParamConnectType connection.
-    assert(darwinParamConnect = NXOpenEventStatus());
-
-    InitKeyboardDeviceStruct(pDev, NULL, NULL, DarwinChangeKeyboardControl);
-
-    DarwinKeyboardReloadHandler();
-
-    CopyKeyClass(pDev, inputInfo.keyboard);
-}
-
-/* Set the repeat rates based on global preferences and keycodes for modifiers.
- * Precondition: Has the keyInfo_mutex lock.
- */
-static void DarwinKeyboardSetRepeat(DeviceIntPtr pDev, int initialKeyRepeatValue, int keyRepeatValue) {
-    if(initialKeyRepeatValue == 300000) { // off
-        /* Turn off repeats globally */
-        XkbSetRepeatKeys(pDev, -1, AutoRepeatModeOff);
-    } else {
-        int i;
-        XkbControlsPtr      ctrl;
-        XkbControlsRec      old;
-
-        /* Turn on repeats globally */
-        XkbSetRepeatKeys(pDev, -1, AutoRepeatModeOn);
-        
-        /* Setup the bit mask for individual key repeats */
-        ctrl = pDev->key->xkbInfo->desc->ctrls;
-        old= *ctrl;
-        
-        ctrl->repeat_delay = initialKeyRepeatValue * 15;
-        ctrl->repeat_interval = keyRepeatValue * 15;
-
-        /* Turn off key-repeat for modifier keys, on for others */
-        /* First set them all on */
-        for(i=0; i < XkbPerKeyBitArraySize; i++)
-            ctrl->per_key_repeat[i] = -1;
-
-        /* Now turn off the modifiers */
-        for(i=0; i < 32; i++) {
-            unsigned char keycode;
-            
-            keycode = keyInfo.modifierKeycodes[i][0];
-            if(keycode)
-                ClearBit(ctrl->per_key_repeat, keycode + MIN_KEYCODE);
-
-            keycode = keyInfo.modifierKeycodes[i][1];
-            if(keycode)
-                ClearBit(ctrl->per_key_repeat, keycode + MIN_KEYCODE);
-        }
-
-        /* Hurray for data duplication */
-        if (pDev->kbdfeed)
-            memcpy(pDev->kbdfeed->ctrl.autoRepeats, ctrl->per_key_repeat, XkbPerKeyBitArraySize);
-
-        //fprintf(stderr, "per_key_repeat =\n");
-        //for(i=0; i < XkbPerKeyBitArraySize; i++)
-        //    fprintf(stderr, "%02x%s", ctrl->per_key_repeat[i], (i + 1) & 7 ? "" : "\n");
-
-        /* And now we notify the puppies about the changes */
-        XkbDDXChangeControls(pDev, &old, ctrl);
-    }
-}
-
-void DarwinKeyboardReloadHandler(void) {
-    KeySymsRec keySyms;
-    CFIndex initialKeyRepeatValue, keyRepeatValue;
-    BOOL ok;
-    DeviceIntPtr pDev;
-    const char *xmodmap = PROJECTROOT "/bin/xmodmap";
-    const char *sysmodmap = PROJECTROOT "/lib/X11/xinit/.Xmodmap";
-    const char *homedir = getenv("HOME");
-    char usermodmap[PATH_MAX], cmd[PATH_MAX];
-
-    DEBUG_LOG("DarwinKeyboardReloadHandler\n");
-
-    /* Get our key repeat settings from GlobalPreferences */
-    (void)CFPreferencesAppSynchronize(CFSTR(".GlobalPreferences"));
-    
-    initialKeyRepeatValue = CFPreferencesGetAppIntegerValue(CFSTR("InitialKeyRepeat"), CFSTR(".GlobalPreferences"), &ok);
-    if(!ok)
-        initialKeyRepeatValue = 35;
-    
-    keyRepeatValue = CFPreferencesGetAppIntegerValue(CFSTR("KeyRepeat"), CFSTR(".GlobalPreferences"), &ok);
-    if(!ok)
-        keyRepeatValue = 6;
-    
-    pthread_mutex_lock(&keyInfo_mutex); {
-        /* Initialize our keySyms */
-        keySyms.map = keyInfo.keyMap;
-        keySyms.mapWidth   = GLYPHS_PER_KEY;
-        keySyms.minKeyCode = MIN_KEYCODE;
-        keySyms.maxKeyCode = MAX_KEYCODE;
-
-	// TODO: We should build the entire XkbDescRec and use XkbCopyKeymap
-        /* Apply the mappings to darwinKeyboard */
-        XkbApplyMappingChange(darwinKeyboard, &keySyms, keySyms.minKeyCode,
-                              keySyms.maxKeyCode - keySyms.minKeyCode + 1,
-                              keyInfo.modMap, serverClient);
-        DarwinKeyboardSetRepeat(darwinKeyboard, initialKeyRepeatValue, keyRepeatValue);
-
-        /* Apply the mappings to the core keyboard */
-        for (pDev = inputInfo.devices; pDev; pDev = pDev->next) {
-            if ((pDev->coreEvents || pDev == inputInfo.keyboard) && pDev->key) {
-                XkbApplyMappingChange(pDev, &keySyms, keySyms.minKeyCode,
-                                      keySyms.maxKeyCode - keySyms.minKeyCode + 1,
-                                      keyInfo.modMap, serverClient);
-                DarwinKeyboardSetRepeat(pDev, initialKeyRepeatValue, keyRepeatValue);    
-            }
-        }
-    } pthread_mutex_unlock(&keyInfo_mutex);
-
-    /* Check for system .Xmodmap */
-    if (access(xmodmap, F_OK) == 0) {
-        if (access(sysmodmap, F_OK) == 0) {
-            snprintf (cmd, sizeof(cmd), "%s %s", xmodmap, sysmodmap);
-            X11ApplicationLaunchClient(cmd);
-        }
-    }
-        
-    /* Check for user's local .Xmodmap */
-    if (homedir != NULL) {
-        snprintf (usermodmap, sizeof(usermodmap), "%s/.Xmodmap", homedir);
-        if (access(usermodmap, F_OK) == 0) {
-            snprintf (cmd, sizeof(cmd), "%s %s", xmodmap, usermodmap);
-            X11ApplicationLaunchClient(cmd);
-        }
-    }
-}
-
-//-----------------------------------------------------------------------------
-// Modifier translation functions
-//
-// There are three different ways to specify a Mac modifier key:
-// keycode - specifies hardware key, read from keymapping
-// key     - NX_MODIFIERKEY_*, really an index
-// mask    - NX_*MASK, mask for modifier flags in event record
-// Left and right side have different keycodes but the same key and mask.
-//-----------------------------------------------------------------------------
-
-/*
- * DarwinModifierNXKeyToNXKeycode
- *      Return the keycode for an NX_MODIFIERKEY_* modifier.
- *      side = 0 for left or 1 for right.
- *      Returns 0 if key+side is not a known modifier.
- */
-int DarwinModifierNXKeyToNXKeycode(int key, int side) {
-    int retval;
-    pthread_mutex_lock(&keyInfo_mutex);
-    retval = keyInfo.modifierKeycodes[key][side];
-    pthread_mutex_unlock(&keyInfo_mutex);
-
-    return retval;
-}
-
-/*
- * DarwinModifierNXKeycodeToNXKey
- *      Returns -1 if keycode+side is not a modifier key
- *      outSide may be NULL, else it gets 0 for left and 1 for right.
- */
-int DarwinModifierNXKeycodeToNXKey(unsigned char keycode, int *outSide) {
-    int key, side;
-
-    keycode += MIN_KEYCODE;
-
-    // search modifierKeycodes for this keycode+side
-    pthread_mutex_lock(&keyInfo_mutex);
-    for (key = 0; key < NX_NUMMODIFIERS; key++) {
-        for (side = 0; side <= 1; side++) {
-            if (keyInfo.modifierKeycodes[key][side] == keycode) break;
-        }
-    }
-    pthread_mutex_unlock(&keyInfo_mutex);
-
-    if (key == NX_NUMMODIFIERS) {
-        return -1;
-    }
-    if (outSide) *outSide = side;
-
-    return key;
-}
-
-/*
- * DarwinModifierNXMaskToNXKey
- *      Returns -1 if mask is not a known modifier mask.
- */
-int DarwinModifierNXMaskToNXKey(int mask) {
-    switch (mask) {
-        case NX_ALPHASHIFTMASK:       return NX_MODIFIERKEY_ALPHALOCK;
-        case NX_SHIFTMASK:            return NX_MODIFIERKEY_SHIFT;
-#ifdef NX_DEVICELSHIFTKEYMASK
-        case NX_DEVICELSHIFTKEYMASK:  return NX_MODIFIERKEY_SHIFT;
-        case NX_DEVICERSHIFTKEYMASK:  return NX_MODIFIERKEY_RSHIFT;
-#endif
-        case NX_CONTROLMASK:          return NX_MODIFIERKEY_CONTROL;
-#ifdef NX_DEVICELCTLKEYMASK
-        case NX_DEVICELCTLKEYMASK:    return NX_MODIFIERKEY_CONTROL;
-        case NX_DEVICERCTLKEYMASK:    return NX_MODIFIERKEY_RCONTROL;
-#endif
-        case NX_ALTERNATEMASK:        return NX_MODIFIERKEY_ALTERNATE;
-#ifdef NX_DEVICELALTKEYMASK
-        case NX_DEVICELALTKEYMASK:    return NX_MODIFIERKEY_ALTERNATE;
-        case NX_DEVICERALTKEYMASK:    return NX_MODIFIERKEY_RALTERNATE;
-#endif
-        case NX_COMMANDMASK:          return NX_MODIFIERKEY_COMMAND;
-#ifdef NX_DEVICELCMDKEYMASK
-        case NX_DEVICELCMDKEYMASK:    return NX_MODIFIERKEY_COMMAND;
-        case NX_DEVICERCMDKEYMASK:    return NX_MODIFIERKEY_RCOMMAND;
-#endif
-        case NX_NUMERICPADMASK:       return NX_MODIFIERKEY_NUMERICPAD;
-        case NX_HELPMASK:             return NX_MODIFIERKEY_HELP;
-        case NX_SECONDARYFNMASK:      return NX_MODIFIERKEY_SECONDARYFN;
-    }
-    return -1;
-}
-
-/*
- * DarwinModifierNXKeyToNXMask
- *      Returns 0 if key is not a known modifier key.
- */
-int DarwinModifierNXKeyToNXMask(int key) {
-    switch (key) {
-        case NX_MODIFIERKEY_ALPHALOCK:   return NX_ALPHASHIFTMASK;
-#ifdef NX_DEVICELSHIFTKEYMASK
-        case NX_MODIFIERKEY_SHIFT:       return NX_DEVICELSHIFTKEYMASK;
-        case NX_MODIFIERKEY_RSHIFT:      return NX_DEVICERSHIFTKEYMASK;
-        case NX_MODIFIERKEY_CONTROL:     return NX_DEVICELCTLKEYMASK;
-        case NX_MODIFIERKEY_RCONTROL:    return NX_DEVICERCTLKEYMASK;
-        case NX_MODIFIERKEY_ALTERNATE:   return NX_DEVICELALTKEYMASK;
-        case NX_MODIFIERKEY_RALTERNATE:  return NX_DEVICERALTKEYMASK;
-        case NX_MODIFIERKEY_COMMAND:     return NX_DEVICELCMDKEYMASK;
-        case NX_MODIFIERKEY_RCOMMAND:    return NX_DEVICERCMDKEYMASK;
-#else
-        case NX_MODIFIERKEY_SHIFT:       return NX_SHIFTMASK;
-        case NX_MODIFIERKEY_CONTROL:     return NX_CONTROLMASK;
-        case NX_MODIFIERKEY_ALTERNATE:   return NX_ALTERNATEMASK;
-        case NX_MODIFIERKEY_COMMAND:     return NX_COMMANDMASK;
-#endif
-        case NX_MODIFIERKEY_NUMERICPAD:  return NX_NUMERICPADMASK;
-        case NX_MODIFIERKEY_HELP:        return NX_HELPMASK;
-        case NX_MODIFIERKEY_SECONDARYFN: return NX_SECONDARYFNMASK;
-    }
-    return 0;
-}
-
-/*
- * DarwinModifierStringToNXMask
- *      Returns 0 if string is not a known modifier.
- */
-int DarwinModifierStringToNXMask(const char *str, int separatelr) {
-#ifdef NX_DEVICELSHIFTKEYMASK
-    if(separatelr) {
-        if (!strcasecmp(str, "shift"))    return NX_DEVICELSHIFTKEYMASK | NX_DEVICERSHIFTKEYMASK;
-        if (!strcasecmp(str, "control"))  return NX_DEVICELCTLKEYMASK | NX_DEVICERCTLKEYMASK;
-        if (!strcasecmp(str, "option"))   return NX_DEVICELALTKEYMASK | NX_DEVICERALTKEYMASK;
-        if (!strcasecmp(str, "alt"))   return NX_DEVICELALTKEYMASK | NX_DEVICERALTKEYMASK;
-        if (!strcasecmp(str, "command"))  return NX_DEVICELCMDKEYMASK | NX_DEVICERCMDKEYMASK;
-        if (!strcasecmp(str, "lshift"))   return NX_DEVICELSHIFTKEYMASK;
-        if (!strcasecmp(str, "rshift"))   return NX_DEVICERSHIFTKEYMASK;
-        if (!strcasecmp(str, "lcontrol")) return NX_DEVICELCTLKEYMASK;
-        if (!strcasecmp(str, "rcontrol")) return NX_DEVICERCTLKEYMASK;
-        if (!strcasecmp(str, "loption"))  return NX_DEVICELALTKEYMASK;
-        if (!strcasecmp(str, "roption"))  return NX_DEVICERALTKEYMASK;
-        if (!strcasecmp(str, "lalt"))  return NX_DEVICELALTKEYMASK;
-        if (!strcasecmp(str, "ralt"))  return NX_DEVICERALTKEYMASK;
-        if (!strcasecmp(str, "lcommand")) return NX_DEVICELCMDKEYMASK;
-        if (!strcasecmp(str, "rcommand")) return NX_DEVICERCMDKEYMASK;
-    } else {
-#endif
-        if (!strcasecmp(str, "shift"))    return NX_SHIFTMASK;
-        if (!strcasecmp(str, "control"))  return NX_CONTROLMASK;
-        if (!strcasecmp(str, "option"))   return NX_ALTERNATEMASK;
-        if (!strcasecmp(str, "alt"))   return NX_ALTERNATEMASK;
-        if (!strcasecmp(str, "command"))  return NX_COMMANDMASK;
-        if (!strcasecmp(str, "lshift"))   return NX_SHIFTMASK;
-        if (!strcasecmp(str, "rshift"))   return NX_SHIFTMASK;
-        if (!strcasecmp(str, "lcontrol")) return NX_CONTROLMASK;
-        if (!strcasecmp(str, "rcontrol")) return NX_CONTROLMASK;
-        if (!strcasecmp(str, "loption"))  return NX_ALTERNATEMASK;
-        if (!strcasecmp(str, "roption"))  return NX_ALTERNATEMASK;
-        if (!strcasecmp(str, "lalt"))  return NX_ALTERNATEMASK;
-        if (!strcasecmp(str, "ralt"))  return NX_ALTERNATEMASK;
-        if (!strcasecmp(str, "lcommand")) return NX_COMMANDMASK;
-        if (!strcasecmp(str, "rcommand")) return NX_COMMANDMASK;
-#ifdef NX_DEVICELSHIFTKEYMASK
-    }
-#endif
-    if (!strcasecmp(str, "lock"))     return NX_ALPHASHIFTMASK;
-    if (!strcasecmp(str, "fn"))       return NX_SECONDARYFNMASK;
-    if (!strcasecmp(str, "help"))     return NX_HELPMASK;
-    if (!strcasecmp(str, "numlock"))  return NX_NUMERICPADMASK;
-    return 0;
-}
-
-/*
- * LegalModifier
- *      This allows the ddx layer to prevent some keys from being remapped
- *      as modifier keys.
- */
-Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
-{
-    return 1;
-}
-
-static inline UniChar macroman2ucs(unsigned char c) {
-    /* Precalculated table mapping MacRoman-128 to Unicode. Generated
-       by creating single element CFStringRefs then extracting the
-       first character. */
-
-    static const unsigned short table[128] = {
-        0xc4, 0xc5, 0xc7, 0xc9, 0xd1, 0xd6, 0xdc, 0xe1,
-        0xe0, 0xe2, 0xe4, 0xe3, 0xe5, 0xe7, 0xe9, 0xe8,
-        0xea, 0xeb, 0xed, 0xec, 0xee, 0xef, 0xf1, 0xf3,
-        0xf2, 0xf4, 0xf6, 0xf5, 0xfa, 0xf9, 0xfb, 0xfc,
-        0x2020, 0xb0, 0xa2, 0xa3, 0xa7, 0x2022, 0xb6, 0xdf,
-        0xae, 0xa9, 0x2122, 0xb4, 0xa8, 0x2260, 0xc6, 0xd8,
-        0x221e, 0xb1, 0x2264, 0x2265, 0xa5, 0xb5, 0x2202, 0x2211,
-        0x220f, 0x3c0, 0x222b, 0xaa, 0xba, 0x3a9, 0xe6, 0xf8,
-        0xbf, 0xa1, 0xac, 0x221a, 0x192, 0x2248, 0x2206, 0xab,
-        0xbb, 0x2026, 0xa0, 0xc0, 0xc3, 0xd5, 0x152, 0x153,
-        0x2013, 0x2014, 0x201c, 0x201d, 0x2018, 0x2019, 0xf7, 0x25ca,
-        0xff, 0x178, 0x2044, 0x20ac, 0x2039, 0x203a, 0xfb01, 0xfb02,
-        0x2021, 0xb7, 0x201a, 0x201e, 0x2030, 0xc2, 0xca, 0xc1,
-        0xcb, 0xc8, 0xcd, 0xce, 0xcf, 0xcc, 0xd3, 0xd4,
-        0xf8ff, 0xd2, 0xda, 0xdb, 0xd9, 0x131, 0x2c6, 0x2dc,
-        0xaf, 0x2d8, 0x2d9, 0x2da, 0xb8, 0x2dd, 0x2db, 0x2c7,
-    };
-
-    if (c < 128) return c;
-    else         return table[c - 128];
-}
-
-static KeySym make_dead_key(KeySym in) {
-    int i;
-
-    for (i = 0; i < sizeof (dead_keys) / sizeof (dead_keys[0]); i++)
-        if (dead_keys[i].normal == in) return dead_keys[i].dead;
-
-    return in;
-}
-
-static Bool QuartzReadSystemKeymap(darwinKeyboardInfo *info) {
-#if !defined(__LP64__) || MAC_OS_X_VERSION_MIN_REQUIRED < 1050
-    KeyboardLayoutRef key_layout;
-    int is_uchr = 1;
-#endif
-    const void *chr_data = NULL;
-    int num_keycodes = NUM_KEYCODES;
-    UInt32 keyboard_type = LMGetKbdType();
-    int i, j;
-    OSStatus err;
-    KeySym *k;
-    CFDataRef currentKeyLayoutDataRef = NULL;
-
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
-    TISInputSourceRef currentKeyLayoutRef = TISCopyCurrentKeyboardLayoutInputSource();
-
-    if (currentKeyLayoutRef) {
-      currentKeyLayoutDataRef = (CFDataRef )TISGetInputSourceProperty(currentKeyLayoutRef, kTISPropertyUnicodeKeyLayoutData);
-      if (currentKeyLayoutDataRef)
-          chr_data = CFDataGetBytePtr(currentKeyLayoutDataRef);
-    }
-#endif
-
-#if !defined(__LP64__) || MAC_OS_X_VERSION_MIN_REQUIRED < 1050
-    if (chr_data == NULL) {
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
-        ErrorF("X11.app: Error detected in determining keyboard layout.  If you are using an Apple-provided keyboard layout, please report this error at http://xquartz.macosforge.org and http://bugreport.apple.com\n");
-        ErrorF("X11.app: Debug Info: keyboard_type=%u, currentKeyLayoutRef=%p, currentKeyLayoutDataRef=%p, chr_data=%p\n",
-               (unsigned)keyboard_type, currentKeyLayoutRef, currentKeyLayoutDataRef, chr_data);
-#endif
-
-        KLGetCurrentKeyboardLayout (&key_layout);
-        KLGetKeyboardLayoutProperty (key_layout, kKLuchrData, &chr_data);
-
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
-        if(chr_data != NULL) {
-            ErrorF("X11.app: Fallback succeeded, but this is still a bug.  Please report the above information.\n");
-        }
-#endif
-    }
-
-    if (chr_data == NULL) {
-        ErrorF("X11.app: Debug Info: kKLuchrData failed, trying kKLKCHRData.\n");
-        ErrorF("If you are using a 3rd party keyboard layout, please see http://xquartz.macosforge.org/trac/ticket/154\n");
-        KLGetKeyboardLayoutProperty (key_layout, kKLKCHRData, &chr_data);
-        is_uchr = 0;
-        num_keycodes = 128;
-        
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
-        if(chr_data != NULL) {
-            ErrorF("X11.app: Fallback succeeded, but this is still a bug.  Please report the above information.\n");
-        }
-#endif
-    }
-#endif
-
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
-    if(currentKeyLayoutRef)
-        CFRelease(currentKeyLayoutRef);
-#endif
-    
-    if (chr_data == NULL) {
-      ErrorF ( "Couldn't get uchr or kchr resource\n");
-      return FALSE;
-    }
-    
-    /* Scan the keycode range for the Unicode character that each
-       key produces in the four shift states. Then convert that to
-       an X11 keysym (which may just the bit that says "this is
-       Unicode" if it can't find the real symbol.) */
-       
-    /* KeyTranslate is not available on 64-bit platforms; UCKeyTranslate
-       must be used instead. */
-
-    for (i = 0; i < num_keycodes; i++) {
-        static const int mods[4] = {0, MOD_SHIFT, MOD_OPTION,
-                                    MOD_OPTION | MOD_SHIFT};
-
-        k = info->keyMap + i * GLYPHS_PER_KEY;
-
-        for (j = 0; j < 4; j++) {
-#if !defined(__LP64__) || MAC_OS_X_VERSION_MIN_REQUIRED < 1050
-            if (is_uchr)  {
-#endif
-                UniChar s[8];
-                UniCharCount len;
-                UInt32 dead_key_state = 0, extra_dead = 0;
-
-                err = UCKeyTranslate (chr_data, i, kUCKeyActionDown,
-                                      mods[j] >> 8, keyboard_type, 0,
-                                      &dead_key_state, 8, &len, s);
-                if (err != noErr) continue;
-
-                if (len == 0 && dead_key_state != 0) {
-                    /* Found a dead key. Work out which one it is, but
-                       remembering that it's dead. */
-                    err = UCKeyTranslate (chr_data, i, kUCKeyActionDown,
-                                          mods[j] >> 8, keyboard_type,
-                                          kUCKeyTranslateNoDeadKeysMask,
-                                          &extra_dead, 8, &len, s);
-                    if (err != noErr) continue;
-                }
-
-                /* Not sure why 0x0010 is there.
-                 * 0x0000 - <rdar://problem/7793566> 'Unicode Hex Input' ...
-                 */
-                if (len > 0 && s[0] != 0x0010 && s[0] != 0x0000) {
-                    k[j] = ucs2keysym (s[0]);
-                    if (dead_key_state != 0) k[j] = make_dead_key (k[j]);
-                }
-#if !defined(__LP64__) || MAC_OS_X_VERSION_MIN_REQUIRED < 1050
-            } else { // kchr
-	      UInt32 c, state = 0, state2 = 0;
-                UInt16 code;
-
-                code = i | mods[j];
-                c = KeyTranslate (chr_data, code, &state);
-
-                /* Dead keys are only processed on key-down, so ask
-                   to translate those events. When we find a dead key,
-                   translating the matching key up event will give
-                   us the actual dead character. */
-
-                if (state != 0)
-                    c = KeyTranslate (chr_data, code | 128, &state2);
-
-                /* Characters seem to be in MacRoman encoding. */
-
-                if (c != 0 && c != 0x0010) {
-                    k[j] = ucs2keysym (macroman2ucs (c & 255));
-
-                    if (state != 0) k[j] = make_dead_key (k[j]);
-                }
-            }
-#endif
-        }
-
-        if (k[3] == k[2]) k[3] = NoSymbol;
-        if (k[1] == k[0]) k[1] = NoSymbol;
-        if (k[0] == k[2] && k[1] == k[3]) k[2] = k[3] = NoSymbol;
-        if (k[3] == k[0] && k[2] == k[1] && k[2] == NoSymbol) k[3] = NoSymbol;
-    }
-
-#if HACK_MISSING
-    /* Fix up some things that are normally missing.. */
-    
-    for (i = 0; i < sizeof (known_keys) / sizeof (known_keys[0]); i++) {
-        k = info->keyMap + known_keys[i].keycode * GLYPHS_PER_KEY;
-        
-        if (   k[0] == NoSymbol && k[1] == NoSymbol
-            && k[2] == NoSymbol && k[3] == NoSymbol)
-            k[0] = known_keys[i].keysym;
-    }
-#endif
-    
-#if HACK_KEYPAD
-    /* And some more things. We find the right symbols for the numeric
-     keypad, but not the KP_ keysyms. So try to convert known keycodes. */
-    for (i = 0; i < sizeof (known_numeric_keys) / sizeof (known_numeric_keys[0]); i++) {
-        k = info->keyMap + known_numeric_keys[i].keycode * GLYPHS_PER_KEY;
-        
-        if (k[0] == known_numeric_keys[i].normal)
-            k[0] = known_numeric_keys[i].keypad;
-    }
-#endif
-    
-#if HACK_BLACKLIST
-    for (i = 0; i < sizeof (keycode_blacklist) / sizeof (keycode_blacklist[0]); i++) {
-        k = info->keyMap + keycode_blacklist[i] * GLYPHS_PER_KEY;
-        k[0] = k[1] = k[2] = k[3] = NoSymbol;
-    }
-#endif
-
-    DarwinBuildModifierMaps(info);
-
-    return TRUE;
-}
-
-Bool QuartsResyncKeymap(Bool sendDDXEvent) {
-    Bool retval;
-    /* Update keyInfo */
-    pthread_mutex_lock(&keyInfo_mutex);
-    memset(keyInfo.keyMap, 0, sizeof(keyInfo.keyMap));
-    retval = QuartzReadSystemKeymap(&keyInfo);
-    pthread_mutex_unlock(&keyInfo_mutex);
-
-    /* Tell server thread to deal with new keyInfo */
-    if(sendDDXEvent)
-        DarwinSendDDXEvent(kXquartzReloadKeymap, 0);
-
-    return retval;
-}
+/*

+   quartzKeyboard.c: Keyboard support for Xquartz

+

+   Copyright (c) 2003-2008 Apple Inc.

+   Copyright (c) 2001-2004 Torrey T. Lyons. All Rights Reserved.

+   Copyright 2004 Kaleb S. KEITHLEY. All Rights Reserved.

+

+   Copyright (C) 1999,2000 by Eric Sunshine <sunshine@sunshineco.com>

+   All rights reserved.

+

+   Redistribution and use in source and binary forms, with or without

+   modification, are permitted provided that the following conditions are met:

+

+     1. Redistributions of source code must retain the above copyright

+        notice, this list of conditions and the following disclaimer.

+     2. Redistributions in binary form must reproduce the above copyright

+        notice, this list of conditions and the following disclaimer in the

+        documentation and/or other materials provided with the distribution.

+     3. The name of the author may not be used to endorse or promote products

+        derived from this software without specific prior written permission.

+

+   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

+   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

+   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN

+   NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

+   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+*/

+

+#include "sanitizedCarbon.h"

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#define HACK_MISSING 1

+#define HACK_KEYPAD 1

+#define HACK_BLACKLIST 1

+

+#include <unistd.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <errno.h>

+#include <sys/stat.h>

+#include <AvailabilityMacros.h>

+

+#include "quartzCommon.h"

+#include "darwin.h"

+#include "darwinEvents.h"

+

+#include "quartzKeyboard.h"

+#include "quartzAudio.h"

+

+#include "X11Application.h"

+

+#include "threadSafety.h"

+

+#ifdef NDEBUG

+#undef NDEBUG

+#include <assert.h>

+#define NDEBUG 1

+#else

+#include <assert.h>

+#endif

+#include <pthread.h>

+

+#include "xkbsrv.h"

+#include "exevents.h"

+#include "X11/keysym.h"

+#include "keysym2ucs.h"

+

+extern void

+CopyKeyClass(DeviceIntPtr device, DeviceIntPtr master);

+

+enum {

+    MOD_COMMAND = 256,

+    MOD_SHIFT = 512,

+    MOD_OPTION = 2048,

+    MOD_CONTROL = 4096,

+};

+

+#define UKEYSYM(u) ((u) | 0x01000000)

+

+#if HACK_MISSING

+/* Table of keycode->keysym mappings we use to fallback on for important

+   keys that are often not in the Unicode mapping. */

+

+const static struct {

+    unsigned short keycode;

+    KeySym keysym;

+} known_keys[] = {

+    {55,  XK_Meta_L},

+    {56,  XK_Shift_L},

+    {57,  XK_Caps_Lock},

+    {58,  XK_Alt_L},

+    {59,  XK_Control_L},

+

+    {60,  XK_Shift_R},

+    {61,  XK_Alt_R},

+    {62,  XK_Control_R},

+    {63,  XK_Meta_R},

+

+    {122, XK_F1},

+    {120, XK_F2},

+    {99,  XK_F3},

+    {118, XK_F4},

+    {96,  XK_F5},

+    {97,  XK_F6},

+    {98,  XK_F7},

+    {100, XK_F8},

+    {101, XK_F9},

+    {109, XK_F10},

+    {103, XK_F11},

+    {111, XK_F12},

+    {105, XK_F13},

+    {107, XK_F14},

+    {113, XK_F15},

+};

+#endif

+

+#if HACK_KEYPAD

+/* Table of keycode->old,new-keysym mappings we use to fixup the numeric

+   keypad entries. */

+

+const static struct {

+    unsigned short keycode;

+    KeySym normal, keypad;

+} known_numeric_keys[] = {

+    {65, XK_period, XK_KP_Decimal},

+    {67, XK_asterisk, XK_KP_Multiply},

+    {69, XK_plus, XK_KP_Add},

+    {75, XK_slash, XK_KP_Divide},

+    {76, 0x01000003, XK_KP_Enter},

+    {78, XK_minus, XK_KP_Subtract},

+    {81, XK_equal, XK_KP_Equal},

+    {82, XK_0, XK_KP_0},

+    {83, XK_1, XK_KP_1},

+    {84, XK_2, XK_KP_2},

+    {85, XK_3, XK_KP_3},

+    {86, XK_4, XK_KP_4},

+    {87, XK_5, XK_KP_5},

+    {88, XK_6, XK_KP_6},

+    {89, XK_7, XK_KP_7},

+    {91, XK_8, XK_KP_8},

+    {92, XK_9, XK_KP_9},

+};

+#endif

+

+#if HACK_BLACKLIST

+/* <rdar://problem/7824370> wine notepad produces wrong characters on shift+arrow

+ * http://xquartz.macosforge.org/trac/ticket/295

+ * http://developer.apple.com/legacy/mac/library/documentation/mac/Text/Text-579.html

+ *

+ * legacy Mac keycodes for arrow keys that shift-modify to math symbols

+ */

+const static unsigned short keycode_blacklist[] = {66, 70, 72, 77};

+#endif

+

+/* Table mapping normal keysyms to their dead equivalents.

+   FIXME: all the unicode keysyms (apart from circumflex) were guessed. */

+

+const static struct {

+    KeySym normal, dead;

+} dead_keys[] = {

+    {XK_grave, XK_dead_grave},

+    {XK_apostrophe, XK_dead_acute},             /* US:"=" on a Czech keyboard */

+    {XK_acute, XK_dead_acute},

+    {UKEYSYM (0x384), XK_dead_acute},           /* US:";" on a Greek keyboard */

+//    {XK_Greek_accentdieresis, XK_dead_diaeresis},   /* US:"opt+;" on a Greek keyboard ... replace with dead_accentdieresis if there is one */

+    {XK_asciicircum, XK_dead_circumflex},

+    {UKEYSYM (0x2c6), XK_dead_circumflex},	/* MODIFIER LETTER CIRCUMFLEX ACCENT */

+    {XK_asciitilde, XK_dead_tilde},

+    {UKEYSYM (0x2dc), XK_dead_tilde},		/* SMALL TILDE */

+    {XK_macron, XK_dead_macron},

+    {XK_breve, XK_dead_breve},

+    {XK_abovedot, XK_dead_abovedot},

+    {XK_diaeresis, XK_dead_diaeresis},

+    {UKEYSYM (0x2da), XK_dead_abovering},	/* DOT ABOVE */

+    {XK_doubleacute, XK_dead_doubleacute},

+    {XK_caron, XK_dead_caron},

+    {XK_cedilla, XK_dead_cedilla},

+    {XK_ogonek, XK_dead_ogonek},

+    {UKEYSYM (0x269), XK_dead_iota},		/* LATIN SMALL LETTER IOTA */

+    {UKEYSYM (0x2ec), XK_dead_voiced_sound},	/* MODIFIER LETTER VOICING */

+/*  {XK_semivoiced_sound, XK_dead_semivoiced_sound}, */

+    {UKEYSYM (0x323), XK_dead_belowdot},	/* COMBINING DOT BELOW */

+    {UKEYSYM (0x309), XK_dead_hook}, 		/* COMBINING HOOK ABOVE */

+    {UKEYSYM (0x31b), XK_dead_horn},		/* COMBINING HORN */

+};

+

+typedef struct darwinKeyboardInfo_struct {

+    CARD8 modMap[MAP_LENGTH];

+    KeySym keyMap[MAP_LENGTH * GLYPHS_PER_KEY];

+    unsigned char modifierKeycodes[32][2];

+} darwinKeyboardInfo;

+

+darwinKeyboardInfo keyInfo;

+pthread_mutex_t keyInfo_mutex = PTHREAD_MUTEX_INITIALIZER;

+

+static void DarwinChangeKeyboardControl(DeviceIntPtr device, KeybdCtrl *ctrl) {

+    // FIXME: to be implemented

+    // keyclick, bell volume / pitch, autorepead, LED's

+}

+

+//-----------------------------------------------------------------------------

+// Utility functions to help parse Darwin keymap

+//-----------------------------------------------------------------------------

+

+/*

+ * DarwinBuildModifierMaps

+ *      Use the keyMap field of keyboard info structure to populate

+ *      the modMap and modifierKeycodes fields.

+ */

+static void DarwinBuildModifierMaps(darwinKeyboardInfo *info) {

+    int i;

+    KeySym *k;

+

+    memset(info->modMap, NoSymbol, sizeof(info->modMap));

+    memset(info->modifierKeycodes, 0, sizeof(info->modifierKeycodes));

+

+    for (i = 0; i < NUM_KEYCODES; i++) {

+        k = info->keyMap + i * GLYPHS_PER_KEY;

+

+        switch (*k) {

+            case XK_Shift_L:

+                info->modifierKeycodes[NX_MODIFIERKEY_SHIFT][0] = i;

+                info->modMap[MIN_KEYCODE + i] = ShiftMask;

+                break;

+

+            case XK_Shift_R:

+#ifdef NX_MODIFIERKEY_RSHIFT

+                info->modifierKeycodes[NX_MODIFIERKEY_RSHIFT][0] = i;

+#else

+                info->modifierKeycodes[NX_MODIFIERKEY_SHIFT][0] = i;

+#endif

+                info->modMap[MIN_KEYCODE + i] = ShiftMask;

+                break;

+

+            case XK_Control_L:

+                info->modifierKeycodes[NX_MODIFIERKEY_CONTROL][0] = i;

+                info->modMap[MIN_KEYCODE + i] = ControlMask;

+                break;

+

+            case XK_Control_R:

+#ifdef NX_MODIFIERKEY_RCONTROL

+                info->modifierKeycodes[NX_MODIFIERKEY_RCONTROL][0] = i;

+#else

+                info->modifierKeycodes[NX_MODIFIERKEY_CONTROL][0] = i;

+#endif

+                info->modMap[MIN_KEYCODE + i] = ControlMask;

+                break;

+

+            case XK_Caps_Lock:

+                info->modifierKeycodes[NX_MODIFIERKEY_ALPHALOCK][0] = i;

+                info->modMap[MIN_KEYCODE + i] = LockMask;

+                break;

+

+            case XK_Alt_L:

+                info->modifierKeycodes[NX_MODIFIERKEY_ALTERNATE][0] = i;

+                info->modMap[MIN_KEYCODE + i] = Mod1Mask;

+                if(!quartzOptionSendsAlt)

+                    *k = XK_Mode_switch; // Yes, this is ugly.  This needs to be cleaned up when we integrate quartzKeyboard with this code and refactor.

+                break;

+

+            case XK_Alt_R:

+#ifdef NX_MODIFIERKEY_RALTERNATE

+                info->modifierKeycodes[NX_MODIFIERKEY_RALTERNATE][0] = i;

+#else

+                info->modifierKeycodes[NX_MODIFIERKEY_ALTERNATE][0] = i;

+#endif

+                if(!quartzOptionSendsAlt)

+                    *k = XK_Mode_switch; // Yes, this is ugly.  This needs to be cleaned up when we integrate quartzKeyboard with this code and refactor.

+                info->modMap[MIN_KEYCODE + i] = Mod1Mask;

+                break;

+

+            case XK_Mode_switch:

+                ErrorF("DarwinBuildModifierMaps: XK_Mode_switch encountered, unable to determine side.\n");

+                info->modifierKeycodes[NX_MODIFIERKEY_ALTERNATE][0] = i;

+#ifdef NX_MODIFIERKEY_RALTERNATE

+                info->modifierKeycodes[NX_MODIFIERKEY_RALTERNATE][0] = i;

+#endif

+                info->modMap[MIN_KEYCODE + i] = Mod1Mask;

+                break;

+

+            case XK_Meta_L:

+                info->modifierKeycodes[NX_MODIFIERKEY_COMMAND][0] = i;

+                info->modMap[MIN_KEYCODE + i] = Mod2Mask;

+                break;

+

+            case XK_Meta_R:

+#ifdef NX_MODIFIERKEY_RCOMMAND

+                info->modifierKeycodes[NX_MODIFIERKEY_RCOMMAND][0] = i;

+#else

+                info->modifierKeycodes[NX_MODIFIERKEY_COMMAND][0] = i;

+#endif

+                info->modMap[MIN_KEYCODE + i] = Mod2Mask;

+                break;

+

+            case XK_Num_Lock:

+                info->modMap[MIN_KEYCODE + i] = Mod3Mask;

+                break;

+        }

+    }

+}

+

+/*

+ * DarwinKeyboardInit

+ *      Get the Darwin keyboard map and compute an equivalent

+ *      X keyboard map and modifier map. Set the new keyboard

+ *      device structure.

+ */

+void DarwinKeyboardInit(DeviceIntPtr pDev) {

+    // Open a shared connection to the HID System.

+    // Note that the Event Status Driver is really just a wrapper

+    // for a kIOHIDParamConnectType connection.

+    assert(darwinParamConnect = NXOpenEventStatus());

+

+    InitKeyboardDeviceStruct(pDev, NULL, NULL, DarwinChangeKeyboardControl);

+

+    DarwinKeyboardReloadHandler();

+

+    CopyKeyClass(pDev, inputInfo.keyboard);

+}

+

+/* Set the repeat rates based on global preferences and keycodes for modifiers.

+ * Precondition: Has the keyInfo_mutex lock.

+ */

+static void DarwinKeyboardSetRepeat(DeviceIntPtr pDev, int initialKeyRepeatValue, int keyRepeatValue) {

+    if(initialKeyRepeatValue == 300000) { // off

+        /* Turn off repeats globally */

+        XkbSetRepeatKeys(pDev, -1, AutoRepeatModeOff);

+    } else {

+        int i;

+        XkbControlsPtr      ctrl;

+        XkbControlsRec      old;

+

+        /* Turn on repeats globally */

+        XkbSetRepeatKeys(pDev, -1, AutoRepeatModeOn);

+        

+        /* Setup the bit mask for individual key repeats */

+        ctrl = pDev->key->xkbInfo->desc->ctrls;

+        old= *ctrl;

+        

+        ctrl->repeat_delay = initialKeyRepeatValue * 15;

+        ctrl->repeat_interval = keyRepeatValue * 15;

+

+        /* Turn off key-repeat for modifier keys, on for others */

+        /* First set them all on */

+        for(i=0; i < XkbPerKeyBitArraySize; i++)

+            ctrl->per_key_repeat[i] = -1;

+

+        /* Now turn off the modifiers */

+        for(i=0; i < 32; i++) {

+            unsigned char keycode;

+            

+            keycode = keyInfo.modifierKeycodes[i][0];

+            if(keycode)

+                ClearBit(ctrl->per_key_repeat, keycode + MIN_KEYCODE);

+

+            keycode = keyInfo.modifierKeycodes[i][1];

+            if(keycode)

+                ClearBit(ctrl->per_key_repeat, keycode + MIN_KEYCODE);

+        }

+

+        /* Hurray for data duplication */

+        if (pDev->kbdfeed)

+            memcpy(pDev->kbdfeed->ctrl.autoRepeats, ctrl->per_key_repeat, XkbPerKeyBitArraySize);

+

+        //fprintf(stderr, "per_key_repeat =\n");

+        //for(i=0; i < XkbPerKeyBitArraySize; i++)

+        //    fprintf(stderr, "%02x%s", ctrl->per_key_repeat[i], (i + 1) & 7 ? "" : "\n");

+

+        /* And now we notify the puppies about the changes */

+        XkbDDXChangeControls(pDev, &old, ctrl);

+    }

+}

+

+void DarwinKeyboardReloadHandler(void) {

+    KeySymsRec keySyms;

+    CFIndex initialKeyRepeatValue, keyRepeatValue;

+    BOOL ok;

+    DeviceIntPtr pDev;

+    const char *xmodmap = PROJECTROOT "/bin/xmodmap";

+    const char *sysmodmap = PROJECTROOT "/lib/X11/xinit/.Xmodmap";

+    const char *homedir = getenv("HOME");

+    char usermodmap[PATH_MAX], cmd[PATH_MAX];

+

+    DEBUG_LOG("DarwinKeyboardReloadHandler\n");

+

+    /* Get our key repeat settings from GlobalPreferences */

+    (void)CFPreferencesAppSynchronize(CFSTR(".GlobalPreferences"));

+    

+    initialKeyRepeatValue = CFPreferencesGetAppIntegerValue(CFSTR("InitialKeyRepeat"), CFSTR(".GlobalPreferences"), &ok);

+    if(!ok)

+        initialKeyRepeatValue = 35;

+    

+    keyRepeatValue = CFPreferencesGetAppIntegerValue(CFSTR("KeyRepeat"), CFSTR(".GlobalPreferences"), &ok);

+    if(!ok)

+        keyRepeatValue = 6;

+    

+    pthread_mutex_lock(&keyInfo_mutex); {

+        /* Initialize our keySyms */

+        keySyms.map = keyInfo.keyMap;

+        keySyms.mapWidth   = GLYPHS_PER_KEY;

+        keySyms.minKeyCode = MIN_KEYCODE;

+        keySyms.maxKeyCode = MAX_KEYCODE;

+

+	// TODO: We should build the entire XkbDescRec and use XkbCopyKeymap

+        /* Apply the mappings to darwinKeyboard */

+        XkbApplyMappingChange(darwinKeyboard, &keySyms, keySyms.minKeyCode,

+                              keySyms.maxKeyCode - keySyms.minKeyCode + 1,

+                              keyInfo.modMap, serverClient);

+        DarwinKeyboardSetRepeat(darwinKeyboard, initialKeyRepeatValue, keyRepeatValue);

+

+        /* Apply the mappings to the core keyboard */

+        for (pDev = inputInfo.devices; pDev; pDev = pDev->next) {

+            if ((pDev->coreEvents || pDev == inputInfo.keyboard) && pDev->key) {

+                XkbApplyMappingChange(pDev, &keySyms, keySyms.minKeyCode,

+                                      keySyms.maxKeyCode - keySyms.minKeyCode + 1,

+                                      keyInfo.modMap, serverClient);

+                DarwinKeyboardSetRepeat(pDev, initialKeyRepeatValue, keyRepeatValue);    

+            }

+        }

+    } pthread_mutex_unlock(&keyInfo_mutex);

+

+    /* Modify with xmodmap */

+    if (access(xmodmap, F_OK) == 0) {

+        /* Check for system .Xmodmap */

+        if (access(sysmodmap, F_OK) == 0) {

+            if(snprintf (cmd, sizeof(cmd), "%s %s", xmodmap, sysmodmap) < sizeof(cmd)) {

+                X11ApplicationLaunchClient(cmd);

+            } else {

+                ErrorF("X11.app: Unable to create / execute xmodmap command line");

+            }

+        }

+

+        /* Check for user's local .Xmodmap */

+        if ((homedir != NULL) && (snprintf (usermodmap, sizeof(usermodmap), "%s/.Xmodmap", homedir) < sizeof(usermodmap))) {

+            if (access(usermodmap, F_OK) == 0) {

+                if(snprintf (cmd, sizeof(cmd), "%s %s", xmodmap, usermodmap) < sizeof(cmd)) {

+                    X11ApplicationLaunchClient(cmd);

+                } else {

+                    ErrorF("X11.app: Unable to create / execute xmodmap command line");

+                }

+            }

+        } else {

+            ErrorF("X11.app: Unable to determine path to user's .Xmodmap");

+        }

+    }

+}

+

+//-----------------------------------------------------------------------------

+// Modifier translation functions

+//

+// There are three different ways to specify a Mac modifier key:

+// keycode - specifies hardware key, read from keymapping

+// key     - NX_MODIFIERKEY_*, really an index

+// mask    - NX_*MASK, mask for modifier flags in event record

+// Left and right side have different keycodes but the same key and mask.

+//-----------------------------------------------------------------------------

+

+/*

+ * DarwinModifierNXKeyToNXKeycode

+ *      Return the keycode for an NX_MODIFIERKEY_* modifier.

+ *      side = 0 for left or 1 for right.

+ *      Returns 0 if key+side is not a known modifier.

+ */

+int DarwinModifierNXKeyToNXKeycode(int key, int side) {

+    int retval;

+    pthread_mutex_lock(&keyInfo_mutex);

+    retval = keyInfo.modifierKeycodes[key][side];

+    pthread_mutex_unlock(&keyInfo_mutex);

+

+    return retval;

+}

+

+/*

+ * DarwinModifierNXKeycodeToNXKey

+ *      Returns -1 if keycode+side is not a modifier key

+ *      outSide may be NULL, else it gets 0 for left and 1 for right.

+ */

+int DarwinModifierNXKeycodeToNXKey(unsigned char keycode, int *outSide) {

+    int key, side;

+

+    keycode += MIN_KEYCODE;

+

+    // search modifierKeycodes for this keycode+side

+    pthread_mutex_lock(&keyInfo_mutex);

+    for (key = 0; key < NX_NUMMODIFIERS; key++) {

+        for (side = 0; side <= 1; side++) {

+            if (keyInfo.modifierKeycodes[key][side] == keycode) break;

+        }

+    }

+    pthread_mutex_unlock(&keyInfo_mutex);

+

+    if (key == NX_NUMMODIFIERS) {

+        return -1;

+    }

+    if (outSide) *outSide = side;

+

+    return key;

+}

+

+/*

+ * DarwinModifierNXMaskToNXKey

+ *      Returns -1 if mask is not a known modifier mask.

+ */

+int DarwinModifierNXMaskToNXKey(int mask) {

+    switch (mask) {

+        case NX_ALPHASHIFTMASK:       return NX_MODIFIERKEY_ALPHALOCK;

+        case NX_SHIFTMASK:            return NX_MODIFIERKEY_SHIFT;

+#ifdef NX_DEVICELSHIFTKEYMASK

+        case NX_DEVICELSHIFTKEYMASK:  return NX_MODIFIERKEY_SHIFT;

+        case NX_DEVICERSHIFTKEYMASK:  return NX_MODIFIERKEY_RSHIFT;

+#endif

+        case NX_CONTROLMASK:          return NX_MODIFIERKEY_CONTROL;

+#ifdef NX_DEVICELCTLKEYMASK

+        case NX_DEVICELCTLKEYMASK:    return NX_MODIFIERKEY_CONTROL;

+        case NX_DEVICERCTLKEYMASK:    return NX_MODIFIERKEY_RCONTROL;

+#endif

+        case NX_ALTERNATEMASK:        return NX_MODIFIERKEY_ALTERNATE;

+#ifdef NX_DEVICELALTKEYMASK

+        case NX_DEVICELALTKEYMASK:    return NX_MODIFIERKEY_ALTERNATE;

+        case NX_DEVICERALTKEYMASK:    return NX_MODIFIERKEY_RALTERNATE;

+#endif

+        case NX_COMMANDMASK:          return NX_MODIFIERKEY_COMMAND;

+#ifdef NX_DEVICELCMDKEYMASK

+        case NX_DEVICELCMDKEYMASK:    return NX_MODIFIERKEY_COMMAND;

+        case NX_DEVICERCMDKEYMASK:    return NX_MODIFIERKEY_RCOMMAND;

+#endif

+        case NX_NUMERICPADMASK:       return NX_MODIFIERKEY_NUMERICPAD;

+        case NX_HELPMASK:             return NX_MODIFIERKEY_HELP;

+        case NX_SECONDARYFNMASK:      return NX_MODIFIERKEY_SECONDARYFN;

+    }

+    return -1;

+}

+

+/*

+ * DarwinModifierNXKeyToNXMask

+ *      Returns 0 if key is not a known modifier key.

+ */

+int DarwinModifierNXKeyToNXMask(int key) {

+    switch (key) {

+        case NX_MODIFIERKEY_ALPHALOCK:   return NX_ALPHASHIFTMASK;

+#ifdef NX_DEVICELSHIFTKEYMASK

+        case NX_MODIFIERKEY_SHIFT:       return NX_DEVICELSHIFTKEYMASK;

+        case NX_MODIFIERKEY_RSHIFT:      return NX_DEVICERSHIFTKEYMASK;

+        case NX_MODIFIERKEY_CONTROL:     return NX_DEVICELCTLKEYMASK;

+        case NX_MODIFIERKEY_RCONTROL:    return NX_DEVICERCTLKEYMASK;

+        case NX_MODIFIERKEY_ALTERNATE:   return NX_DEVICELALTKEYMASK;

+        case NX_MODIFIERKEY_RALTERNATE:  return NX_DEVICERALTKEYMASK;

+        case NX_MODIFIERKEY_COMMAND:     return NX_DEVICELCMDKEYMASK;

+        case NX_MODIFIERKEY_RCOMMAND:    return NX_DEVICERCMDKEYMASK;

+#else

+        case NX_MODIFIERKEY_SHIFT:       return NX_SHIFTMASK;

+        case NX_MODIFIERKEY_CONTROL:     return NX_CONTROLMASK;

+        case NX_MODIFIERKEY_ALTERNATE:   return NX_ALTERNATEMASK;

+        case NX_MODIFIERKEY_COMMAND:     return NX_COMMANDMASK;

+#endif

+        case NX_MODIFIERKEY_NUMERICPAD:  return NX_NUMERICPADMASK;

+        case NX_MODIFIERKEY_HELP:        return NX_HELPMASK;

+        case NX_MODIFIERKEY_SECONDARYFN: return NX_SECONDARYFNMASK;

+    }

+    return 0;

+}

+

+/*

+ * DarwinModifierStringToNXMask

+ *      Returns 0 if string is not a known modifier.

+ */

+int DarwinModifierStringToNXMask(const char *str, int separatelr) {

+#ifdef NX_DEVICELSHIFTKEYMASK

+    if(separatelr) {

+        if (!strcasecmp(str, "shift"))    return NX_DEVICELSHIFTKEYMASK | NX_DEVICERSHIFTKEYMASK;

+        if (!strcasecmp(str, "control"))  return NX_DEVICELCTLKEYMASK | NX_DEVICERCTLKEYMASK;

+        if (!strcasecmp(str, "option"))   return NX_DEVICELALTKEYMASK | NX_DEVICERALTKEYMASK;

+        if (!strcasecmp(str, "alt"))   return NX_DEVICELALTKEYMASK | NX_DEVICERALTKEYMASK;

+        if (!strcasecmp(str, "command"))  return NX_DEVICELCMDKEYMASK | NX_DEVICERCMDKEYMASK;

+        if (!strcasecmp(str, "lshift"))   return NX_DEVICELSHIFTKEYMASK;

+        if (!strcasecmp(str, "rshift"))   return NX_DEVICERSHIFTKEYMASK;

+        if (!strcasecmp(str, "lcontrol")) return NX_DEVICELCTLKEYMASK;

+        if (!strcasecmp(str, "rcontrol")) return NX_DEVICERCTLKEYMASK;

+        if (!strcasecmp(str, "loption"))  return NX_DEVICELALTKEYMASK;

+        if (!strcasecmp(str, "roption"))  return NX_DEVICERALTKEYMASK;

+        if (!strcasecmp(str, "lalt"))  return NX_DEVICELALTKEYMASK;

+        if (!strcasecmp(str, "ralt"))  return NX_DEVICERALTKEYMASK;

+        if (!strcasecmp(str, "lcommand")) return NX_DEVICELCMDKEYMASK;

+        if (!strcasecmp(str, "rcommand")) return NX_DEVICERCMDKEYMASK;

+    } else {

+#endif

+        if (!strcasecmp(str, "shift"))    return NX_SHIFTMASK;

+        if (!strcasecmp(str, "control"))  return NX_CONTROLMASK;

+        if (!strcasecmp(str, "option"))   return NX_ALTERNATEMASK;

+        if (!strcasecmp(str, "alt"))   return NX_ALTERNATEMASK;

+        if (!strcasecmp(str, "command"))  return NX_COMMANDMASK;

+        if (!strcasecmp(str, "lshift"))   return NX_SHIFTMASK;

+        if (!strcasecmp(str, "rshift"))   return NX_SHIFTMASK;

+        if (!strcasecmp(str, "lcontrol")) return NX_CONTROLMASK;

+        if (!strcasecmp(str, "rcontrol")) return NX_CONTROLMASK;

+        if (!strcasecmp(str, "loption"))  return NX_ALTERNATEMASK;

+        if (!strcasecmp(str, "roption"))  return NX_ALTERNATEMASK;

+        if (!strcasecmp(str, "lalt"))  return NX_ALTERNATEMASK;

+        if (!strcasecmp(str, "ralt"))  return NX_ALTERNATEMASK;

+        if (!strcasecmp(str, "lcommand")) return NX_COMMANDMASK;

+        if (!strcasecmp(str, "rcommand")) return NX_COMMANDMASK;

+#ifdef NX_DEVICELSHIFTKEYMASK

+    }

+#endif

+    if (!strcasecmp(str, "lock"))     return NX_ALPHASHIFTMASK;

+    if (!strcasecmp(str, "fn"))       return NX_SECONDARYFNMASK;

+    if (!strcasecmp(str, "help"))     return NX_HELPMASK;

+    if (!strcasecmp(str, "numlock"))  return NX_NUMERICPADMASK;

+    return 0;

+}

+

+/*

+ * LegalModifier

+ *      This allows the ddx layer to prevent some keys from being remapped

+ *      as modifier keys.

+ */

+Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)

+{

+    return 1;

+}

+

+static inline UniChar macroman2ucs(unsigned char c) {

+    /* Precalculated table mapping MacRoman-128 to Unicode. Generated

+       by creating single element CFStringRefs then extracting the

+       first character. */

+

+    static const unsigned short table[128] = {

+        0xc4, 0xc5, 0xc7, 0xc9, 0xd1, 0xd6, 0xdc, 0xe1,

+        0xe0, 0xe2, 0xe4, 0xe3, 0xe5, 0xe7, 0xe9, 0xe8,

+        0xea, 0xeb, 0xed, 0xec, 0xee, 0xef, 0xf1, 0xf3,

+        0xf2, 0xf4, 0xf6, 0xf5, 0xfa, 0xf9, 0xfb, 0xfc,

+        0x2020, 0xb0, 0xa2, 0xa3, 0xa7, 0x2022, 0xb6, 0xdf,

+        0xae, 0xa9, 0x2122, 0xb4, 0xa8, 0x2260, 0xc6, 0xd8,

+        0x221e, 0xb1, 0x2264, 0x2265, 0xa5, 0xb5, 0x2202, 0x2211,

+        0x220f, 0x3c0, 0x222b, 0xaa, 0xba, 0x3a9, 0xe6, 0xf8,

+        0xbf, 0xa1, 0xac, 0x221a, 0x192, 0x2248, 0x2206, 0xab,

+        0xbb, 0x2026, 0xa0, 0xc0, 0xc3, 0xd5, 0x152, 0x153,

+        0x2013, 0x2014, 0x201c, 0x201d, 0x2018, 0x2019, 0xf7, 0x25ca,

+        0xff, 0x178, 0x2044, 0x20ac, 0x2039, 0x203a, 0xfb01, 0xfb02,

+        0x2021, 0xb7, 0x201a, 0x201e, 0x2030, 0xc2, 0xca, 0xc1,

+        0xcb, 0xc8, 0xcd, 0xce, 0xcf, 0xcc, 0xd3, 0xd4,

+        0xf8ff, 0xd2, 0xda, 0xdb, 0xd9, 0x131, 0x2c6, 0x2dc,

+        0xaf, 0x2d8, 0x2d9, 0x2da, 0xb8, 0x2dd, 0x2db, 0x2c7,

+    };

+

+    if (c < 128) return c;

+    else         return table[c - 128];

+}

+

+static KeySym make_dead_key(KeySym in) {

+    int i;

+

+    for (i = 0; i < sizeof (dead_keys) / sizeof (dead_keys[0]); i++)

+        if (dead_keys[i].normal == in) return dead_keys[i].dead;

+

+    return in;

+}

+

+static Bool QuartzReadSystemKeymap(darwinKeyboardInfo *info) {

+#if !defined(__LP64__) || MAC_OS_X_VERSION_MIN_REQUIRED < 1050

+    KeyboardLayoutRef key_layout;

+    int is_uchr = 1;

+#endif

+    const void *chr_data = NULL;

+    int num_keycodes = NUM_KEYCODES;

+    UInt32 keyboard_type = LMGetKbdType();

+    int i, j;

+    OSStatus err;

+    KeySym *k;

+    CFDataRef currentKeyLayoutDataRef = NULL;

+

+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050

+    TISInputSourceRef currentKeyLayoutRef = TISCopyCurrentKeyboardLayoutInputSource();

+

+    if (currentKeyLayoutRef) {

+      currentKeyLayoutDataRef = (CFDataRef )TISGetInputSourceProperty(currentKeyLayoutRef, kTISPropertyUnicodeKeyLayoutData);

+      if (currentKeyLayoutDataRef)

+          chr_data = CFDataGetBytePtr(currentKeyLayoutDataRef);

+    }

+#endif

+

+#if !defined(__LP64__) || MAC_OS_X_VERSION_MIN_REQUIRED < 1050

+    if (chr_data == NULL) {

+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050

+        ErrorF("X11.app: Error detected in determining keyboard layout.  If you are using an Apple-provided keyboard layout, please report this error at http://xquartz.macosforge.org and http://bugreport.apple.com\n");

+        ErrorF("X11.app: Debug Info: keyboard_type=%u, currentKeyLayoutRef=%p, currentKeyLayoutDataRef=%p, chr_data=%p\n",

+               (unsigned)keyboard_type, currentKeyLayoutRef, currentKeyLayoutDataRef, chr_data);

+#endif

+

+        KLGetCurrentKeyboardLayout (&key_layout);

+        KLGetKeyboardLayoutProperty (key_layout, kKLuchrData, &chr_data);

+

+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050

+        if(chr_data != NULL) {

+            ErrorF("X11.app: Fallback succeeded, but this is still a bug.  Please report the above information.\n");

+        }

+#endif

+    }

+

+    if (chr_data == NULL) {

+        ErrorF("X11.app: Debug Info: kKLuchrData failed, trying kKLKCHRData.\n");

+        ErrorF("If you are using a 3rd party keyboard layout, please see http://xquartz.macosforge.org/trac/ticket/154\n");

+        KLGetKeyboardLayoutProperty (key_layout, kKLKCHRData, &chr_data);

+        is_uchr = 0;

+        num_keycodes = 128;

+        

+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050

+        if(chr_data != NULL) {

+            ErrorF("X11.app: Fallback succeeded, but this is still a bug.  Please report the above information.\n");

+        }

+#endif

+    }

+#endif

+

+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050

+    if(currentKeyLayoutRef)

+        CFRelease(currentKeyLayoutRef);

+#endif

+    

+    if (chr_data == NULL) {

+      ErrorF ( "Couldn't get uchr or kchr resource\n");

+      return FALSE;

+    }

+    

+    /* Scan the keycode range for the Unicode character that each

+       key produces in the four shift states. Then convert that to

+       an X11 keysym (which may just the bit that says "this is

+       Unicode" if it can't find the real symbol.) */

+       

+    /* KeyTranslate is not available on 64-bit platforms; UCKeyTranslate

+       must be used instead. */

+

+    for (i = 0; i < num_keycodes; i++) {

+        static const int mods[4] = {0, MOD_SHIFT, MOD_OPTION,

+                                    MOD_OPTION | MOD_SHIFT};

+

+        k = info->keyMap + i * GLYPHS_PER_KEY;

+

+        for (j = 0; j < 4; j++) {

+#if !defined(__LP64__) || MAC_OS_X_VERSION_MIN_REQUIRED < 1050

+            if (is_uchr)  {

+#endif

+                UniChar s[8];

+                UniCharCount len;

+                UInt32 dead_key_state = 0, extra_dead = 0;

+

+                err = UCKeyTranslate (chr_data, i, kUCKeyActionDown,

+                                      mods[j] >> 8, keyboard_type, 0,

+                                      &dead_key_state, 8, &len, s);

+                if (err != noErr) continue;

+

+                if (len == 0 && dead_key_state != 0) {

+                    /* Found a dead key. Work out which one it is, but

+                       remembering that it's dead. */

+                    err = UCKeyTranslate (chr_data, i, kUCKeyActionDown,

+                                          mods[j] >> 8, keyboard_type,

+                                          kUCKeyTranslateNoDeadKeysMask,

+                                          &extra_dead, 8, &len, s);

+                    if (err != noErr) continue;

+                }

+

+                /* Not sure why 0x0010 is there.

+                 * 0x0000 - <rdar://problem/7793566> 'Unicode Hex Input' ...

+                 */

+                if (len > 0 && s[0] != 0x0010 && s[0] != 0x0000) {

+                    k[j] = ucs2keysym (s[0]);

+                    if (dead_key_state != 0) k[j] = make_dead_key (k[j]);

+                }

+#if !defined(__LP64__) || MAC_OS_X_VERSION_MIN_REQUIRED < 1050

+            } else { // kchr

+	      UInt32 c, state = 0, state2 = 0;

+                UInt16 code;

+

+                code = i | mods[j];

+                c = KeyTranslate (chr_data, code, &state);

+

+                /* Dead keys are only processed on key-down, so ask

+                   to translate those events. When we find a dead key,

+                   translating the matching key up event will give

+                   us the actual dead character. */

+

+                if (state != 0)

+                    c = KeyTranslate (chr_data, code | 128, &state2);

+

+                /* Characters seem to be in MacRoman encoding. */

+

+                if (c != 0 && c != 0x0010) {

+                    k[j] = ucs2keysym (macroman2ucs (c & 255));

+

+                    if (state != 0) k[j] = make_dead_key (k[j]);

+                }

+            }

+#endif

+        }

+

+        if (k[3] == k[2]) k[3] = NoSymbol;

+        if (k[1] == k[0]) k[1] = NoSymbol;

+        if (k[0] == k[2] && k[1] == k[3]) k[2] = k[3] = NoSymbol;

+        if (k[3] == k[0] && k[2] == k[1] && k[2] == NoSymbol) k[3] = NoSymbol;

+    }

+

+#if HACK_MISSING

+    /* Fix up some things that are normally missing.. */

+    

+    for (i = 0; i < sizeof (known_keys) / sizeof (known_keys[0]); i++) {

+        k = info->keyMap + known_keys[i].keycode * GLYPHS_PER_KEY;

+        

+        if (   k[0] == NoSymbol && k[1] == NoSymbol

+            && k[2] == NoSymbol && k[3] == NoSymbol)

+            k[0] = known_keys[i].keysym;

+    }

+#endif

+    

+#if HACK_KEYPAD

+    /* And some more things. We find the right symbols for the numeric

+     keypad, but not the KP_ keysyms. So try to convert known keycodes. */

+    for (i = 0; i < sizeof (known_numeric_keys) / sizeof (known_numeric_keys[0]); i++) {

+        k = info->keyMap + known_numeric_keys[i].keycode * GLYPHS_PER_KEY;

+        

+        if (k[0] == known_numeric_keys[i].normal)

+            k[0] = known_numeric_keys[i].keypad;

+    }

+#endif

+    

+#if HACK_BLACKLIST

+    for (i = 0; i < sizeof (keycode_blacklist) / sizeof (keycode_blacklist[0]); i++) {

+        k = info->keyMap + keycode_blacklist[i] * GLYPHS_PER_KEY;

+        k[0] = k[1] = k[2] = k[3] = NoSymbol;

+    }

+#endif

+

+    DarwinBuildModifierMaps(info);

+

+    return TRUE;

+}

+

+Bool QuartsResyncKeymap(Bool sendDDXEvent) {

+    Bool retval;

+    /* Update keyInfo */

+    pthread_mutex_lock(&keyInfo_mutex);

+    memset(keyInfo.keyMap, 0, sizeof(keyInfo.keyMap));

+    retval = QuartzReadSystemKeymap(&keyInfo);

+    pthread_mutex_unlock(&keyInfo_mutex);

+

+    /* Tell server thread to deal with new keyInfo */

+    if(sendDDXEvent)

+        DarwinSendDDXEvent(kXquartzReloadKeymap, 0);

+

+    return retval;

+}

diff --git a/xorg-server/hw/xquartz/xpr/dri.c b/xorg-server/hw/xquartz/xpr/dri.c
index 363809d0d..252c2bb4c 100644
--- a/xorg-server/hw/xquartz/xpr/dri.c
+++ b/xorg-server/hw/xquartz/xpr/dri.c
@@ -74,14 +74,14 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 

 #include <AvailabilityMacros.h>

 

-static int DRIScreenPrivKeyIndex;

-static DevPrivateKey DRIScreenPrivKey = &DRIScreenPrivKeyIndex;

-static int DRIWindowPrivKeyIndex;

-static DevPrivateKey DRIWindowPrivKey = &DRIWindowPrivKeyIndex;

-static int DRIPixmapPrivKeyIndex;

-static DevPrivateKey DRIPixmapPrivKey = &DRIPixmapPrivKeyIndex;

-static int DRIPixmapBufferPrivKeyIndex;

-static DevPrivateKey DRIPixmapBufferPrivKey = &DRIPixmapBufferPrivKeyIndex;

+static DevPrivateKeyRec DRIScreenPrivKeyRec;

+#define DRIScreenPrivKey (&DRIScreenPrivKeyRec)

+static DevPrivateKeyRec DRIWindowPrivKeyRec;

+#define DRIWindowPrivKey (&DRIWindowPrivKeyRec)

+static DevPrivateKeyRec DRIPixmapPrivKeyRec;

+#define DRIPixmapPrivKey (&DRIPixmapPrivKeyRec)

+static DevPrivateKeyRec DRIPixmapBufferPrivKeyRec;

+#define DRIPixmapBufferPrivKey (&DRIPixmapBufferPrivKeyRec)

 

 static RESTYPE DRIDrawablePrivResType;

 

@@ -205,6 +205,15 @@ DRIScreenInit(ScreenPtr pScreen)
     DRIScreenPrivPtr    pDRIPriv;

     int                 i;

 

+    if (!dixRegisterPrivateKey(&DRIScreenPrivKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+    if (!dixRegisterPrivateKey(&DRIWindowPrivKeyRec, PRIVATE_WINDOW, 0))

+	return FALSE;

+    if (!dixRegisterPrivateKey(&DRIPixmapPrivKeyRec, PRIVATE_PIXMAP, 0))

+	return FALSE;

+    if (!dixRegisterPrivateKey(&DRIPixmapBufferPrivKeyRec, PRIVATE_PIXMAP, 0))

+	return FALSE;

+

     pDRIPriv = (DRIScreenPrivPtr) calloc(1, sizeof(DRIScreenPrivRec));

     if (!pDRIPriv) {

 	dixSetPrivate(&pScreen->devPrivates, DRIScreenPrivKey, NULL);

@@ -280,7 +289,7 @@ DRIExtensionInit(void)
     DRIDrawablePrivResType = CreateNewResourceType(DRIDrawablePrivDelete,

 						   "DRIDrawable");

 

-    return (DRIDrawablePrivResType != 0);

+    return DRIDrawablePrivResType != 0;

 }

 

 void

@@ -347,8 +356,8 @@ DRIUpdateSurface(DRIDrawablePrivPtr pDRIDrawablePriv, DrawablePtr pDraw)
         wc.height = pWin->drawable.height + 2 * pWin->borderWidth;

         wc.bit_gravity = XP_GRAVITY_NONE;

 

-        wc.shape_nrects = REGION_NUM_RECTS(&pWin->clipList);

-        wc.shape_rects = REGION_RECTS(&pWin->clipList);

+        wc.shape_nrects = RegionNumRects(&pWin->clipList);

+        wc.shape_rects = RegionRects(&pWin->clipList);

         wc.shape_tx = - (pTopWin->drawable.x - pTopWin->borderWidth);

         wc.shape_ty = - (pTopWin->drawable.y - pTopWin->borderWidth);

 

diff --git a/xorg-server/hw/xquartz/xpr/driWrap.c b/xorg-server/hw/xquartz/xpr/driWrap.c
index 2e23cbbf5..37cb8cf5a 100644
--- a/xorg-server/hw/xquartz/xpr/driWrap.c
+++ b/xorg-server/hw/xquartz/xpr/driWrap.c
@@ -55,11 +55,11 @@ typedef struct {
     DevUnion devPrivate;

 } DRISavedDrawableState;

 

-static int driGCKeyIndex;

-static DevPrivateKey driGCKey = &driGCKeyIndex;

+static DevPrivateKeyRec driGCKeyRec;

+#define driGCKey (&driGCKeyRec)

 

-static int driWrapScreenKeyIndex;

-static DevPrivateKey driWrapScreenKey = &driWrapScreenKeyIndex;

+static DevPrivateKeyRec driWrapScreenKeyRec;

+#define driWrapScreenKey (&driWrapScreenKeyRec)

 

 static GCOps driGCOps;

 

@@ -527,21 +527,15 @@ Bool
 DRIWrapInit(ScreenPtr pScreen) {

     DRIWrapScreenRec *pScreenPriv;

 

-    if(!dixRequestPrivate(driGCKey, sizeof(DRIGCRec)))

+    if(!dixRegisterPrivateKey(&driGCKeyRec, PRIVATE_GC, sizeof(DRIGCRec)))

 	return FALSE;

 

-    if(!dixRequestPrivate(driWrapScreenKey, sizeof(DRIWrapScreenRec)))

-	return FALSE;

-    

-    pScreenPriv = malloc(sizeof(*pScreenPriv));

-

-    if(NULL == pScreenPriv)

+    if(!dixRegisterPrivateKey(&driWrapScreenKeyRec, PRIVATE_SCREEN, sizeof(DRIWrapScreenRec)))

 	return FALSE;

 

+    pScreenPriv = dixGetPrivateAddr(&pScreen->devPrivates, &driWrapScreenKeyRec);

     pScreenPriv->CreateGC = pScreen->CreateGC;

     pScreen->CreateGC = DRICreateGC;

     

-    dixSetPrivate(&pScreen->devPrivates, driWrapScreenKey, pScreenPriv);

-        

     return TRUE;

 }

diff --git a/xorg-server/hw/xquartz/xpr/xprCursor.c b/xorg-server/hw/xquartz/xpr/xprCursor.c
index df9eef95e..9c7890647 100644
--- a/xorg-server/hw/xquartz/xpr/xprCursor.c
+++ b/xorg-server/hw/xquartz/xpr/xprCursor.c
@@ -57,13 +57,12 @@ typedef struct {
     miPointerSpriteFuncPtr  spriteFuncs;

 } QuartzCursorScreenRec, *QuartzCursorScreenPtr;

 

-static int darwinCursorScreenKeyIndex;

-static DevPrivateKey darwinCursorScreenKey = &darwinCursorScreenKeyIndex;

+static DevPrivateKeyRec darwinCursorScreenKeyRec;

+#define darwinCursorScreenKey (&darwinCursorScreenKeyRec)

 

 #define CURSOR_PRIV(pScreen) ((QuartzCursorScreenPtr) \

     dixLookupPrivate(&pScreen->devPrivates, darwinCursorScreenKey))

 

-

 static Bool

 load_cursor(CursorPtr src, int screen)

 {

@@ -296,8 +295,8 @@ QuartzWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
     {

         int sx, sy;

 

-        sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;

-        sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;

+        sx = pScreen->x + darwinMainScreenX;

+        sy = pScreen->y + darwinMainScreenY;

 

         CGWarpMouseCursorPosition(CGPointMake(sx + x, sy + y));

     }

@@ -360,6 +359,9 @@ QuartzInitCursor(ScreenPtr pScreen)
     if (!miDCInitialize(pScreen, &quartzScreenFuncsRec))

         return FALSE;

 

+    if (!dixRegisterPrivateKey(&darwinCursorScreenKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+

     ScreenPriv = calloc(1, sizeof(QuartzCursorScreenRec));

     if (ScreenPriv == NULL)

         return FALSE;

diff --git a/xorg-server/hw/xquartz/xpr/xprFrame.c b/xorg-server/hw/xquartz/xpr/xprFrame.c
index 53dde7acc..52925339f 100644
--- a/xorg-server/hw/xquartz/xpr/xprFrame.c
+++ b/xorg-server/hw/xquartz/xpr/xprFrame.c
@@ -1,640 +1,640 @@
-/*
- * Xplugin rootless implementation frame functions
- *
- * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
- * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name(s) of the above copyright
- * holders shall not be used in advertising or otherwise to promote the sale,
- * use or other dealings in this Software without prior written authorization.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "xpr.h"
-#include "rootlessCommon.h"
-#include <Xplugin.h>
-#include "x-hash.h"
-#include "x-list.h"
-#include "applewmExt.h"
-
-#include "propertyst.h"
-#include "dix.h"
-#include <X11/Xatom.h>
-#include "windowstr.h"
-#include "quartz.h"
-
-#include "threadSafety.h"
-
-#include <pthread.h>
-
-#define DEFINE_ATOM_HELPER(func,atom_name)                      \
-static Atom func (void) {                                       \
-    static int generation;                                      \
-    static Atom atom;                                           \
-    if (generation != serverGeneration) {                       \
-        generation = serverGeneration;                          \
-        atom = MakeAtom (atom_name, strlen (atom_name), TRUE);  \
-    }                                                           \
-    return atom;                                                \
-}
-
-DEFINE_ATOM_HELPER(xa_native_window_id, "_NATIVE_WINDOW_ID")
-
-/* Maps xp_window_id -> RootlessWindowRec */
-static x_hash_table *window_hash;
-static pthread_mutex_t window_hash_mutex;
-
-/* Prototypes for static functions */
-static Bool xprCreateFrame(RootlessWindowPtr pFrame, ScreenPtr pScreen,
-               int newX, int newY, RegionPtr pShape);
-static void xprDestroyFrame(RootlessFrameID wid);
-static void xprMoveFrame(RootlessFrameID wid, ScreenPtr pScreen, int newX, int newY);
-static void xprResizeFrame(RootlessFrameID wid, ScreenPtr pScreen,
-               int newX, int newY, unsigned int newW, unsigned int newH,
-               unsigned int gravity);
-static void xprRestackFrame(RootlessFrameID wid, RootlessFrameID nextWid);
-static void xprReshapeFrame(RootlessFrameID wid, RegionPtr pShape);
-static void xprUnmapFrame(RootlessFrameID wid);
-static void xprStartDrawing(RootlessFrameID wid, char **pixelData, int *bytesPerRow);
-static void xprStopDrawing(RootlessFrameID wid, Bool flush);
-static void xprUpdateRegion(RootlessFrameID wid, RegionPtr pDamage);
-static void xprDamageRects(RootlessFrameID wid, int nrects, const BoxRec *rects,
-               int shift_x, int shift_y);
-static void xprSwitchWindow(RootlessWindowPtr pFrame, WindowPtr oldWin);
-static Bool xprDoReorderWindow(RootlessWindowPtr pFrame);
-static void xprHideWindow(RootlessFrameID wid);
-static void xprUpdateColormap(RootlessFrameID wid, ScreenPtr pScreen);
-static void xprCopyWindow(RootlessFrameID wid, int dstNrects, const BoxRec *dstRects,
-              int dx, int dy);
-
-
-static inline xp_error
-xprConfigureWindow(xp_window_id id, unsigned int mask,
-                   const xp_window_changes *values)
-{
-    TA_SERVER();
-
-    return xp_configure_window(id, mask, values);
-}
-
-
-static void
-xprSetNativeProperty(RootlessWindowPtr pFrame)
-{
-    xp_error err;
-    unsigned int native_id;
-    long data;
-
-    TA_SERVER();
-    
-    err = xp_get_native_window(x_cvt_vptr_to_uint(pFrame->wid), &native_id);
-    if (err == Success)
-    {
-        /* FIXME: move this to AppleWM extension */
-
-        data = native_id;
-        dixChangeWindowProperty(serverClient, pFrame->win, xa_native_window_id(),
-				XA_INTEGER, 32, PropModeReplace, 1, &data, TRUE);
-    }
-}
-
-static xp_error
-xprColormapCallback(void *data, int first_color, int n_colors, uint32_t *colors)
-{
-    return (RootlessResolveColormap (data, first_color, n_colors, colors) ? XP_Success : XP_BadMatch);
-}
-
-/*
- * Create and display a new frame.
- */
-static Bool
-xprCreateFrame(RootlessWindowPtr pFrame, ScreenPtr pScreen,
-               int newX, int newY, RegionPtr pShape)
-{
-    WindowPtr pWin = pFrame->win;
-    xp_window_changes wc;
-    unsigned int mask = 0;
-    xp_error err;
-
-    TA_SERVER();
-    
-    wc.x = newX;
-    wc.y = newY;
-    wc.width = pFrame->width;
-    wc.height = pFrame->height;
-    wc.bit_gravity = XP_GRAVITY_NONE;
-    mask |= XP_BOUNDS;
-
-    if (pWin->drawable.depth == 8)
-    {
-        wc.depth = XP_DEPTH_INDEX8;
-        wc.colormap = xprColormapCallback;
-        wc.colormap_data = pScreen;
-        mask |= XP_COLORMAP;
-    }
-    else if (pWin->drawable.depth == 15)
-        wc.depth = XP_DEPTH_RGB555;
-    else if (pWin->drawable.depth == 24)
-        wc.depth = XP_DEPTH_ARGB8888;
-    else
-        wc.depth = XP_DEPTH_NIL;
-    mask |= XP_DEPTH;
-
-    if (pShape != NULL)
-    {
-        wc.shape_nrects = REGION_NUM_RECTS(pShape);
-        wc.shape_rects = REGION_RECTS(pShape);
-        wc.shape_tx = wc.shape_ty = 0;
-        mask |= XP_SHAPE;
-    }
-
-    pFrame->level = !IsRoot (pWin) ? AppleWMWindowLevelNormal : AppleWMNumWindowLevels;
-
-    if(quartzEnableRootless)
-        wc.window_level = normal_window_levels[pFrame->level];
-    else
-        wc.window_level = rooted_window_levels[pFrame->level];
-    mask |= XP_WINDOW_LEVEL;
-
-    err = xp_create_window(mask, &wc, (xp_window_id *) &pFrame->wid);
-
-    if (err != Success)
-    {
-        return FALSE;
-    }
-
-    if (window_hash == NULL)
-    {
-        window_hash = x_hash_table_new(NULL, NULL, NULL, NULL);
-        pthread_mutex_init(&window_hash_mutex, NULL);
-    }
-
-    pthread_mutex_lock(&window_hash_mutex);
-    x_hash_table_insert(window_hash, pFrame->wid, pFrame);
-    pthread_mutex_unlock(&window_hash_mutex);
-
-    xprSetNativeProperty(pFrame);
-
-    return TRUE;
-}
-
-
-/*
- * Destroy a frame.
- */
-static void
-xprDestroyFrame(RootlessFrameID wid)
-{
-    TA_SERVER();
-    
-    pthread_mutex_lock(&window_hash_mutex);
-    x_hash_table_remove(window_hash, wid);
-    pthread_mutex_unlock(&window_hash_mutex);
-
-    xp_destroy_window(x_cvt_vptr_to_uint(wid));
-}
-
-
-/*
- * Move a frame on screen.
- */
-static void
-xprMoveFrame(RootlessFrameID wid, ScreenPtr pScreen, int newX, int newY)
-{
-    xp_window_changes wc;
-
-    TA_SERVER();
-    
-    wc.x = newX;
-    wc.y = newY;
-    //    ErrorF("xprMoveFrame(%d, %p, %d, %d)\n", wid, pScreen, newX, newY);
-    xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_ORIGIN, &wc);
-}
-
-
-/*
- * Resize and move a frame.
- */
-static void
-xprResizeFrame(RootlessFrameID wid, ScreenPtr pScreen,
-               int newX, int newY, unsigned int newW, unsigned int newH,
-               unsigned int gravity)
-{
-    xp_window_changes wc;
-
-    TA_SERVER();
-    
-    wc.x = newX;
-    wc.y = newY;
-    wc.width = newW;
-    wc.height = newH;
-    wc.bit_gravity = gravity;
-
-    /* It's unlikely that being async will save us anything here.
-       But it can't hurt. */
-
-    xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_BOUNDS, &wc);
-}
-
-
-/*
- * Change frame stacking.
- */
-static void xprRestackFrame(RootlessFrameID wid, RootlessFrameID nextWid) {
-    xp_window_changes wc;
-    unsigned int mask = XP_STACKING;
-
-    TA_SERVER();
-    
-    /* Stack frame below nextWid it if it exists, or raise
-       frame above everything otherwise. */
-
-    if(nextWid == NULL) {
-        wc.stack_mode = XP_MAPPED_ABOVE;
-        wc.sibling = 0;
-    } else {
-        wc.stack_mode = XP_MAPPED_BELOW;
-        wc.sibling = x_cvt_vptr_to_uint(nextWid);
-    }
-
-    if(window_hash) {
-        RootlessWindowRec *winRec = x_hash_table_lookup(window_hash, wid, NULL);
-
-        if(winRec) {
-            if(quartzEnableRootless)
-                wc.window_level = normal_window_levels[winRec->level];
-            else
-                wc.window_level = rooted_window_levels[winRec->level];
-            mask |= XP_WINDOW_LEVEL;
-        }
-    }
-
-    xprConfigureWindow(x_cvt_vptr_to_uint(wid), mask, &wc);
-}
-
-
-/*
- * Change the frame's shape.
- */
-static void
-xprReshapeFrame(RootlessFrameID wid, RegionPtr pShape)
-{
-    xp_window_changes wc;
-
-    TA_SERVER();
-    
-    if (pShape != NULL)
-    {
-        wc.shape_nrects = REGION_NUM_RECTS(pShape);
-        wc.shape_rects = REGION_RECTS(pShape);
-    }
-    else
-    {
-        wc.shape_nrects = -1;
-        wc.shape_rects = NULL;
-    }
-
-    wc.shape_tx = wc.shape_ty = 0;
-
-    xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_SHAPE, &wc);
-}
-
-
-/*
- * Unmap a frame.
- */
-static void
-xprUnmapFrame(RootlessFrameID wid)
-{
-    xp_window_changes wc;
-
-    TA_SERVER();
-    
-    wc.stack_mode = XP_UNMAPPED;
-    wc.sibling = 0;
-
-    xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_STACKING, &wc);
-}
-
-
-/*
- * Start drawing to a frame.
- *  Prepare for direct access to its backing buffer.
- */
-static void
-xprStartDrawing(RootlessFrameID wid, char **pixelData, int *bytesPerRow)
-{
-    void *data[2];
-    unsigned int rowbytes[2];
-    xp_error err;
-
-    TA_SERVER();
-    
-    err = xp_lock_window(x_cvt_vptr_to_uint(wid), NULL, NULL, data, rowbytes, NULL);
-    if (err != Success)
-        FatalError("Could not lock window %i for drawing.", (int)x_cvt_vptr_to_uint(wid));
-
-    *pixelData = data[0];
-    *bytesPerRow = rowbytes[0];
-}
-
-
-/*
- * Stop drawing to a frame.
- */
-static void
-xprStopDrawing(RootlessFrameID wid, Bool flush)
-{
-    TA_SERVER();
-    
-    xp_unlock_window(x_cvt_vptr_to_uint(wid), flush);
-}
-
-
-/*
- * Flush drawing updates to the screen.
- */
-static void
-xprUpdateRegion(RootlessFrameID wid, RegionPtr pDamage)
-{
-    TA_SERVER();
-    
-    xp_flush_window(x_cvt_vptr_to_uint(wid));
-}
-
-
-/*
- * Mark damaged rectangles as requiring redisplay to screen.
- */
-static void
-xprDamageRects(RootlessFrameID wid, int nrects, const BoxRec *rects,
-               int shift_x, int shift_y)
-{
-    TA_SERVER();
-    
-    xp_mark_window(x_cvt_vptr_to_uint(wid), nrects, rects, shift_x, shift_y);
-}
-
-
-/*
- * Called after the window associated with a frame has been switched
- * to a new top-level parent.
- */
-static void
-xprSwitchWindow(RootlessWindowPtr pFrame, WindowPtr oldWin)
-{
-    DeleteProperty(serverClient, oldWin, xa_native_window_id());
-
-    TA_SERVER();
-    
-    xprSetNativeProperty(pFrame);
-}
-
-
-/*
- * Called to check if the frame should be reordered when it is restacked.
- */
-static Bool xprDoReorderWindow(RootlessWindowPtr pFrame)
-{
-    WindowPtr pWin = pFrame->win;
-
-    TA_SERVER();
-    
-    return AppleWMDoReorderWindow(pWin);
-}
-
-
-/*
- * Copy area in frame to another part of frame.
- *  Used to accelerate scrolling.
- */
-static void
-xprCopyWindow(RootlessFrameID wid, int dstNrects, const BoxRec *dstRects,
-              int dx, int dy)
-{
-    TA_SERVER();
-    
-    xp_copy_window(x_cvt_vptr_to_uint(wid), x_cvt_vptr_to_uint(wid),
-                   dstNrects, dstRects, dx, dy);
-}
-
-
-static RootlessFrameProcsRec xprRootlessProcs = {
-    xprCreateFrame,
-    xprDestroyFrame,
-    xprMoveFrame,
-    xprResizeFrame,
-    xprRestackFrame,
-    xprReshapeFrame,
-    xprUnmapFrame,
-    xprStartDrawing,
-    xprStopDrawing,
-    xprUpdateRegion,
-    xprDamageRects,
-    xprSwitchWindow,
-    xprDoReorderWindow,
-    xprHideWindow,
-    xprUpdateColormap,
-    xp_copy_bytes,
-    xp_fill_bytes,
-    xp_composite_pixels,
-    xprCopyWindow
-};
-
-
-/*
- * Initialize XPR implementation
- */
-Bool
-xprInit(ScreenPtr pScreen)
-{
-    RootlessInit(pScreen, &xprRootlessProcs);
-
-    TA_SERVER();
-    
-    rootless_CopyBytes_threshold = xp_copy_bytes_threshold;
-    rootless_FillBytes_threshold = xp_fill_bytes_threshold;
-    rootless_CompositePixels_threshold = xp_composite_area_threshold;
-    rootless_CopyWindow_threshold = xp_scroll_area_threshold;
-
-    return TRUE;
-}
-
-
-/*
- * Given the id of a physical window, try to find the top-level (or root)
- * X window that it represents.
- */
-WindowPtr
-xprGetXWindow(xp_window_id wid)
-{
-    RootlessWindowRec *winRec;
-
-    if (window_hash == NULL)
-        return NULL;
-
-    winRec = x_hash_table_lookup(window_hash, x_cvt_uint_to_vptr(wid), NULL);
-
-    return winRec != NULL ? winRec->win : NULL;
-}
-
-#ifdef UNUSED_CODE
-/*
- * Given the id of a physical window, try to find the top-level (or root)
- * X window that it represents.
- */
-WindowPtr
-xprGetXWindowFromAppKit(int windowNumber)
-{
-    RootlessWindowRec *winRec;
-    Bool ret;
-    xp_window_id wid;
-
-    if (window_hash == NULL)
-        return FALSE;
-
-    /* need to lock, since this function can be called by any thread */
-
-    pthread_mutex_lock(&window_hash_mutex);
-
-    if (xp_lookup_native_window(windowNumber, &wid))
-        ret = xprGetXWindow(wid) != NULL;
-    else
-        ret = FALSE;
-
-    pthread_mutex_unlock(&window_hash_mutex);
-
-    if (!ret) return NULL;
-    winRec = x_hash_table_lookup(window_hash, x_cvt_uint_to_vptr(wid), NULL);
-
-    return winRec != NULL ? winRec->win : NULL;
-}
-#endif
-
-/*
- * The windowNumber is an AppKit window number. Returns TRUE if xpr is
- * displaying a window with that number.
- */
-Bool
-xprIsX11Window(void *nsWindow, int windowNumber)
-{
-    Bool ret;
-    xp_window_id wid;
-
-    if (window_hash == NULL)
-        return FALSE;
-
-    /* need to lock, since this function can be called by any thread */
-
-    pthread_mutex_lock(&window_hash_mutex);
-
-    if (xp_lookup_native_window(windowNumber, &wid))
-        ret = xprGetXWindow(wid) != NULL;
-    else
-        ret = FALSE;
-
-    pthread_mutex_unlock(&window_hash_mutex);
-
-    return ret;
-}
-
-
-/*
- * xprHideWindows
- *  Hide or unhide all top level windows. This is called for application hide/
- *  unhide events if the window manager is not Apple-WM aware. Xplugin windows
- *  do not hide or unhide themselves.
- */
-void
-xprHideWindows(Bool hide)
-{
-    int screen;
-    WindowPtr pRoot, pWin;
-
-    TA_SERVER();
-    
-    for (screen = 0; screen < screenInfo.numScreens; screen++) {
-        RootlessFrameID prevWid = NULL;
-        pRoot = WindowTable[screenInfo.screens[screen]->myNum];
-
-        for (pWin = pRoot->firstChild; pWin; pWin = pWin->nextSib) {
-            RootlessWindowRec *winRec = WINREC(pWin);
-
-            if (winRec != NULL) {
-                if (hide) {
-                    xprUnmapFrame(winRec->wid);
-                } else {
-                    BoxRec box;
-
-                    xprRestackFrame(winRec->wid, prevWid);
-                    prevWid = winRec->wid;
-
-                    box.x1 = 0;
-                    box.y1 = 0;
-                    box.x2 = winRec->width;
-                    box.y2 = winRec->height;
-
-                    xprDamageRects(winRec->wid, 1, &box, 0, 0);
-                    RootlessQueueRedisplay(screenInfo.screens[screen]);
-                }
-            }
-        }
-    }
-}
-
-// XXX: identical to x_cvt_vptr_to_uint ?
-#define MAKE_WINDOW_ID(x)		((xp_window_id)((size_t)(x)))
-
-Bool no_configure_window;
-
-static inline int
-configure_window (xp_window_id id, unsigned int mask,
-                  const xp_window_changes *values)
-{
-  if (!no_configure_window)
-    return xp_configure_window (id, mask, values);
-  else
-    return XP_Success;
-}
-
-
-static
-void xprUpdateColormap(RootlessFrameID wid, ScreenPtr pScreen)
-{
-  /* This is how we tell xp that the colormap may have changed. */
-  xp_window_changes wc;
-  wc.colormap = xprColormapCallback;
-  wc.colormap_data = pScreen;
-
-  configure_window(MAKE_WINDOW_ID(wid), XP_COLORMAP, &wc);
-}
-
-static
-void xprHideWindow(RootlessFrameID wid)
-{
-  xp_window_changes wc;
-  wc.stack_mode = XP_UNMAPPED;
-  wc.sibling = 0;
-  configure_window(MAKE_WINDOW_ID(wid), XP_STACKING, &wc);
-}
+/*

+ * Xplugin rootless implementation frame functions

+ *

+ * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.

+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

+ * DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name(s) of the above copyright

+ * holders shall not be used in advertising or otherwise to promote the sale,

+ * use or other dealings in this Software without prior written authorization.

+ */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include "xpr.h"

+#include "rootlessCommon.h"

+#include <Xplugin.h>

+#include "x-hash.h"

+#include "x-list.h"

+#include "applewmExt.h"

+

+#include "propertyst.h"

+#include "dix.h"

+#include <X11/Xatom.h>

+#include "windowstr.h"

+#include "quartz.h"

+

+#include "threadSafety.h"

+

+#include <pthread.h>

+

+#define DEFINE_ATOM_HELPER(func,atom_name)                      \

+static Atom func (void) {                                       \

+    static int generation;                                      \

+    static Atom atom;                                           \

+    if (generation != serverGeneration) {                       \

+        generation = serverGeneration;                          \

+        atom = MakeAtom (atom_name, strlen (atom_name), TRUE);  \

+    }                                                           \

+    return atom;                                                \

+}

+

+DEFINE_ATOM_HELPER(xa_native_window_id, "_NATIVE_WINDOW_ID")

+

+/* Maps xp_window_id -> RootlessWindowRec */

+static x_hash_table *window_hash;

+static pthread_mutex_t window_hash_mutex;

+

+/* Prototypes for static functions */

+static Bool xprCreateFrame(RootlessWindowPtr pFrame, ScreenPtr pScreen,

+               int newX, int newY, RegionPtr pShape);

+static void xprDestroyFrame(RootlessFrameID wid);

+static void xprMoveFrame(RootlessFrameID wid, ScreenPtr pScreen, int newX, int newY);

+static void xprResizeFrame(RootlessFrameID wid, ScreenPtr pScreen,

+               int newX, int newY, unsigned int newW, unsigned int newH,

+               unsigned int gravity);

+static void xprRestackFrame(RootlessFrameID wid, RootlessFrameID nextWid);

+static void xprReshapeFrame(RootlessFrameID wid, RegionPtr pShape);

+static void xprUnmapFrame(RootlessFrameID wid);

+static void xprStartDrawing(RootlessFrameID wid, char **pixelData, int *bytesPerRow);

+static void xprStopDrawing(RootlessFrameID wid, Bool flush);

+static void xprUpdateRegion(RootlessFrameID wid, RegionPtr pDamage);

+static void xprDamageRects(RootlessFrameID wid, int nrects, const BoxRec *rects,

+               int shift_x, int shift_y);

+static void xprSwitchWindow(RootlessWindowPtr pFrame, WindowPtr oldWin);

+static Bool xprDoReorderWindow(RootlessWindowPtr pFrame);

+static void xprHideWindow(RootlessFrameID wid);

+static void xprUpdateColormap(RootlessFrameID wid, ScreenPtr pScreen);

+static void xprCopyWindow(RootlessFrameID wid, int dstNrects, const BoxRec *dstRects,

+              int dx, int dy);

+

+

+static inline xp_error

+xprConfigureWindow(xp_window_id id, unsigned int mask,

+                   const xp_window_changes *values)

+{

+    TA_SERVER();

+

+    return xp_configure_window(id, mask, values);

+}

+

+

+static void

+xprSetNativeProperty(RootlessWindowPtr pFrame)

+{

+    xp_error err;

+    unsigned int native_id;

+    long data;

+

+    TA_SERVER();

+    

+    err = xp_get_native_window(x_cvt_vptr_to_uint(pFrame->wid), &native_id);

+    if (err == Success)

+    {

+        /* FIXME: move this to AppleWM extension */

+

+        data = native_id;

+        dixChangeWindowProperty(serverClient, pFrame->win, xa_native_window_id(),

+				XA_INTEGER, 32, PropModeReplace, 1, &data, TRUE);

+    }

+}

+

+static xp_error

+xprColormapCallback(void *data, int first_color, int n_colors, uint32_t *colors)

+{

+    return (RootlessResolveColormap (data, first_color, n_colors, colors) ? XP_Success : XP_BadMatch);

+}

+

+/*

+ * Create and display a new frame.

+ */

+static Bool

+xprCreateFrame(RootlessWindowPtr pFrame, ScreenPtr pScreen,

+               int newX, int newY, RegionPtr pShape)

+{

+    WindowPtr pWin = pFrame->win;

+    xp_window_changes wc;

+    unsigned int mask = 0;

+    xp_error err;

+

+    TA_SERVER();

+    

+    wc.x = newX;

+    wc.y = newY;

+    wc.width = pFrame->width;

+    wc.height = pFrame->height;

+    wc.bit_gravity = XP_GRAVITY_NONE;

+    mask |= XP_BOUNDS;

+

+    if (pWin->drawable.depth == 8)

+    {

+        wc.depth = XP_DEPTH_INDEX8;

+        wc.colormap = xprColormapCallback;

+        wc.colormap_data = pScreen;

+        mask |= XP_COLORMAP;

+    }

+    else if (pWin->drawable.depth == 15)

+        wc.depth = XP_DEPTH_RGB555;

+    else if (pWin->drawable.depth == 24)

+        wc.depth = XP_DEPTH_ARGB8888;

+    else

+        wc.depth = XP_DEPTH_NIL;

+    mask |= XP_DEPTH;

+

+    if (pShape != NULL)

+    {

+        wc.shape_nrects = RegionNumRects(pShape);

+        wc.shape_rects = RegionRects(pShape);

+        wc.shape_tx = wc.shape_ty = 0;

+        mask |= XP_SHAPE;

+    }

+

+    pFrame->level = !IsRoot (pWin) ? AppleWMWindowLevelNormal : AppleWMNumWindowLevels;

+

+    if(quartzEnableRootless)

+        wc.window_level = normal_window_levels[pFrame->level];

+    else

+        wc.window_level = rooted_window_levels[pFrame->level];

+    mask |= XP_WINDOW_LEVEL;

+

+    err = xp_create_window(mask, &wc, (xp_window_id *) &pFrame->wid);

+

+    if (err != Success)

+    {

+        return FALSE;

+    }

+

+    if (window_hash == NULL)

+    {

+        window_hash = x_hash_table_new(NULL, NULL, NULL, NULL);

+        pthread_mutex_init(&window_hash_mutex, NULL);

+    }

+

+    pthread_mutex_lock(&window_hash_mutex);

+    x_hash_table_insert(window_hash, pFrame->wid, pFrame);

+    pthread_mutex_unlock(&window_hash_mutex);

+

+    xprSetNativeProperty(pFrame);

+

+    return TRUE;

+}

+

+

+/*

+ * Destroy a frame.

+ */

+static void

+xprDestroyFrame(RootlessFrameID wid)

+{

+    TA_SERVER();

+    

+    pthread_mutex_lock(&window_hash_mutex);

+    x_hash_table_remove(window_hash, wid);

+    pthread_mutex_unlock(&window_hash_mutex);

+

+    xp_destroy_window(x_cvt_vptr_to_uint(wid));

+}

+

+

+/*

+ * Move a frame on screen.

+ */

+static void

+xprMoveFrame(RootlessFrameID wid, ScreenPtr pScreen, int newX, int newY)

+{

+    xp_window_changes wc;

+

+    TA_SERVER();

+    

+    wc.x = newX;

+    wc.y = newY;

+    //    ErrorF("xprMoveFrame(%d, %p, %d, %d)\n", wid, pScreen, newX, newY);

+    xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_ORIGIN, &wc);

+}

+

+

+/*

+ * Resize and move a frame.

+ */

+static void

+xprResizeFrame(RootlessFrameID wid, ScreenPtr pScreen,

+               int newX, int newY, unsigned int newW, unsigned int newH,

+               unsigned int gravity)

+{

+    xp_window_changes wc;

+

+    TA_SERVER();

+    

+    wc.x = newX;

+    wc.y = newY;

+    wc.width = newW;

+    wc.height = newH;

+    wc.bit_gravity = gravity;

+

+    /* It's unlikely that being async will save us anything here.

+       But it can't hurt. */

+

+    xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_BOUNDS, &wc);

+}

+

+

+/*

+ * Change frame stacking.

+ */

+static void xprRestackFrame(RootlessFrameID wid, RootlessFrameID nextWid) {

+    xp_window_changes wc;

+    unsigned int mask = XP_STACKING;

+

+    TA_SERVER();

+    

+    /* Stack frame below nextWid it if it exists, or raise

+       frame above everything otherwise. */

+

+    if(nextWid == NULL) {

+        wc.stack_mode = XP_MAPPED_ABOVE;

+        wc.sibling = 0;

+    } else {

+        wc.stack_mode = XP_MAPPED_BELOW;

+        wc.sibling = x_cvt_vptr_to_uint(nextWid);

+    }

+

+    if(window_hash) {

+        RootlessWindowRec *winRec = x_hash_table_lookup(window_hash, wid, NULL);

+

+        if(winRec) {

+            if(quartzEnableRootless)

+                wc.window_level = normal_window_levels[winRec->level];

+            else

+                wc.window_level = rooted_window_levels[winRec->level];

+            mask |= XP_WINDOW_LEVEL;

+        }

+    }

+

+    xprConfigureWindow(x_cvt_vptr_to_uint(wid), mask, &wc);

+}

+

+

+/*

+ * Change the frame's shape.

+ */

+static void

+xprReshapeFrame(RootlessFrameID wid, RegionPtr pShape)

+{

+    xp_window_changes wc;

+

+    TA_SERVER();

+    

+    if (pShape != NULL)

+    {

+        wc.shape_nrects = RegionNumRects(pShape);

+        wc.shape_rects = RegionRects(pShape);

+    }

+    else

+    {

+        wc.shape_nrects = -1;

+        wc.shape_rects = NULL;

+    }

+

+    wc.shape_tx = wc.shape_ty = 0;

+

+    xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_SHAPE, &wc);

+}

+

+

+/*

+ * Unmap a frame.

+ */

+static void

+xprUnmapFrame(RootlessFrameID wid)

+{

+    xp_window_changes wc;

+

+    TA_SERVER();

+    

+    wc.stack_mode = XP_UNMAPPED;

+    wc.sibling = 0;

+

+    xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_STACKING, &wc);

+}

+

+

+/*

+ * Start drawing to a frame.

+ *  Prepare for direct access to its backing buffer.

+ */

+static void

+xprStartDrawing(RootlessFrameID wid, char **pixelData, int *bytesPerRow)

+{

+    void *data[2];

+    unsigned int rowbytes[2];

+    xp_error err;

+

+    TA_SERVER();

+    

+    err = xp_lock_window(x_cvt_vptr_to_uint(wid), NULL, NULL, data, rowbytes, NULL);

+    if (err != Success)

+        FatalError("Could not lock window %i for drawing.", (int)x_cvt_vptr_to_uint(wid));

+

+    *pixelData = data[0];

+    *bytesPerRow = rowbytes[0];

+}

+

+

+/*

+ * Stop drawing to a frame.

+ */

+static void

+xprStopDrawing(RootlessFrameID wid, Bool flush)

+{

+    TA_SERVER();

+    

+    xp_unlock_window(x_cvt_vptr_to_uint(wid), flush);

+}

+

+

+/*

+ * Flush drawing updates to the screen.

+ */

+static void

+xprUpdateRegion(RootlessFrameID wid, RegionPtr pDamage)

+{

+    TA_SERVER();

+    

+    xp_flush_window(x_cvt_vptr_to_uint(wid));

+}

+

+

+/*

+ * Mark damaged rectangles as requiring redisplay to screen.

+ */

+static void

+xprDamageRects(RootlessFrameID wid, int nrects, const BoxRec *rects,

+               int shift_x, int shift_y)

+{

+    TA_SERVER();

+    

+    xp_mark_window(x_cvt_vptr_to_uint(wid), nrects, rects, shift_x, shift_y);

+}

+

+

+/*

+ * Called after the window associated with a frame has been switched

+ * to a new top-level parent.

+ */

+static void

+xprSwitchWindow(RootlessWindowPtr pFrame, WindowPtr oldWin)

+{

+    DeleteProperty(serverClient, oldWin, xa_native_window_id());

+

+    TA_SERVER();

+    

+    xprSetNativeProperty(pFrame);

+}

+

+

+/*

+ * Called to check if the frame should be reordered when it is restacked.

+ */

+static Bool xprDoReorderWindow(RootlessWindowPtr pFrame)

+{

+    WindowPtr pWin = pFrame->win;

+

+    TA_SERVER();

+    

+    return AppleWMDoReorderWindow(pWin);

+}

+

+

+/*

+ * Copy area in frame to another part of frame.

+ *  Used to accelerate scrolling.

+ */

+static void

+xprCopyWindow(RootlessFrameID wid, int dstNrects, const BoxRec *dstRects,

+              int dx, int dy)

+{

+    TA_SERVER();

+    

+    xp_copy_window(x_cvt_vptr_to_uint(wid), x_cvt_vptr_to_uint(wid),

+                   dstNrects, dstRects, dx, dy);

+}

+

+

+static RootlessFrameProcsRec xprRootlessProcs = {

+    xprCreateFrame,

+    xprDestroyFrame,

+    xprMoveFrame,

+    xprResizeFrame,

+    xprRestackFrame,

+    xprReshapeFrame,

+    xprUnmapFrame,

+    xprStartDrawing,

+    xprStopDrawing,

+    xprUpdateRegion,

+    xprDamageRects,

+    xprSwitchWindow,

+    xprDoReorderWindow,

+    xprHideWindow,

+    xprUpdateColormap,

+    xp_copy_bytes,

+    xp_fill_bytes,

+    xp_composite_pixels,

+    xprCopyWindow

+};

+

+

+/*

+ * Initialize XPR implementation

+ */

+Bool

+xprInit(ScreenPtr pScreen)

+{

+    RootlessInit(pScreen, &xprRootlessProcs);

+

+    TA_SERVER();

+    

+    rootless_CopyBytes_threshold = xp_copy_bytes_threshold;

+    rootless_FillBytes_threshold = xp_fill_bytes_threshold;

+    rootless_CompositePixels_threshold = xp_composite_area_threshold;

+    rootless_CopyWindow_threshold = xp_scroll_area_threshold;

+

+    return TRUE;

+}

+

+

+/*

+ * Given the id of a physical window, try to find the top-level (or root)

+ * X window that it represents.

+ */

+WindowPtr

+xprGetXWindow(xp_window_id wid)

+{

+    RootlessWindowRec *winRec;

+

+    if (window_hash == NULL)

+        return NULL;

+

+    winRec = x_hash_table_lookup(window_hash, x_cvt_uint_to_vptr(wid), NULL);

+

+    return winRec != NULL ? winRec->win : NULL;

+}

+

+#ifdef UNUSED_CODE

+/*

+ * Given the id of a physical window, try to find the top-level (or root)

+ * X window that it represents.

+ */

+WindowPtr

+xprGetXWindowFromAppKit(int windowNumber)

+{

+    RootlessWindowRec *winRec;

+    Bool ret;

+    xp_window_id wid;

+

+    if (window_hash == NULL)

+        return FALSE;

+

+    /* need to lock, since this function can be called by any thread */

+

+    pthread_mutex_lock(&window_hash_mutex);

+

+    if (xp_lookup_native_window(windowNumber, &wid))

+        ret = xprGetXWindow(wid) != NULL;

+    else

+        ret = FALSE;

+

+    pthread_mutex_unlock(&window_hash_mutex);

+

+    if (!ret) return NULL;

+    winRec = x_hash_table_lookup(window_hash, x_cvt_uint_to_vptr(wid), NULL);

+

+    return winRec != NULL ? winRec->win : NULL;

+}

+#endif

+

+/*

+ * The windowNumber is an AppKit window number. Returns TRUE if xpr is

+ * displaying a window with that number.

+ */

+Bool

+xprIsX11Window(void *nsWindow, int windowNumber)

+{

+    Bool ret;

+    xp_window_id wid;

+

+    if (window_hash == NULL)

+        return FALSE;

+

+    /* need to lock, since this function can be called by any thread */

+

+    pthread_mutex_lock(&window_hash_mutex);

+

+    if (xp_lookup_native_window(windowNumber, &wid))

+        ret = xprGetXWindow(wid) != NULL;

+    else

+        ret = FALSE;

+

+    pthread_mutex_unlock(&window_hash_mutex);

+

+    return ret;

+}

+

+

+/*

+ * xprHideWindows

+ *  Hide or unhide all top level windows. This is called for application hide/

+ *  unhide events if the window manager is not Apple-WM aware. Xplugin windows

+ *  do not hide or unhide themselves.

+ */

+void

+xprHideWindows(Bool hide)

+{

+    int screen;

+    WindowPtr pRoot, pWin;

+

+    TA_SERVER();

+    

+    for (screen = 0; screen < screenInfo.numScreens; screen++) {

+        RootlessFrameID prevWid = NULL;

+        pRoot = screenInfo.screens[screen]->root;

+

+        for (pWin = pRoot->firstChild; pWin; pWin = pWin->nextSib) {

+            RootlessWindowRec *winRec = WINREC(pWin);

+

+            if (winRec != NULL) {

+                if (hide) {

+                    xprUnmapFrame(winRec->wid);

+                } else {

+                    BoxRec box;

+

+                    xprRestackFrame(winRec->wid, prevWid);

+                    prevWid = winRec->wid;

+

+                    box.x1 = 0;

+                    box.y1 = 0;

+                    box.x2 = winRec->width;

+                    box.y2 = winRec->height;

+

+                    xprDamageRects(winRec->wid, 1, &box, 0, 0);

+                    RootlessQueueRedisplay(screenInfo.screens[screen]);

+                }

+            }

+        }

+    }

+}

+

+// XXX: identical to x_cvt_vptr_to_uint ?

+#define MAKE_WINDOW_ID(x)		((xp_window_id)((size_t)(x)))

+

+Bool no_configure_window;

+

+static inline int

+configure_window (xp_window_id id, unsigned int mask,

+                  const xp_window_changes *values)

+{

+  if (!no_configure_window)

+    return xp_configure_window (id, mask, values);

+  else

+    return XP_Success;

+}

+

+

+static

+void xprUpdateColormap(RootlessFrameID wid, ScreenPtr pScreen)

+{

+  /* This is how we tell xp that the colormap may have changed. */

+  xp_window_changes wc;

+  wc.colormap = xprColormapCallback;

+  wc.colormap_data = pScreen;

+

+  configure_window(MAKE_WINDOW_ID(wid), XP_COLORMAP, &wc);

+}

+

+static

+void xprHideWindow(RootlessFrameID wid)

+{

+  xp_window_changes wc;

+  wc.stack_mode = XP_UNMAPPED;

+  wc.sibling = 0;

+  configure_window(MAKE_WINDOW_ID(wid), XP_STACKING, &wc);

+}

diff --git a/xorg-server/hw/xquartz/xpr/xprScreen.c b/xorg-server/hw/xquartz/xpr/xprScreen.c
index bc68f7923..d4fef8e0a 100644
--- a/xorg-server/hw/xquartz/xpr/xprScreen.c
+++ b/xorg-server/hw/xquartz/xpr/xprScreen.c
@@ -397,7 +397,7 @@ xprUpdateScreen(ScreenPtr pScreen)
     rootlessGlobalOffsetX = darwinMainScreenX;

     rootlessGlobalOffsetY = darwinMainScreenY;

 

-    AppleWMSetScreenOrigin(WindowTable[pScreen->myNum]);

+    AppleWMSetScreenOrigin(pScreen->root);

 

     RootlessRepositionWindows(pScreen);

     RootlessUpdateScreenPixmap(pScreen);

@@ -416,7 +416,7 @@ xprInitInput(int argc, char **argv)
     rootlessGlobalOffsetY = darwinMainScreenY;

 

     for (i = 0; i < screenInfo.numScreens; i++)

-        AppleWMSetScreenOrigin(WindowTable[i]);

+        AppleWMSetScreenOrigin(screenInfo.screens[i]->root);

 }

 

 /*

diff --git a/xorg-server/hw/xwin/win.h b/xorg-server/hw/xwin/win.h
index d0a41f9ea..3649fe830 100644
--- a/xorg-server/hw/xwin/win.h
+++ b/xorg-server/hw/xwin/win.h
@@ -596,11 +596,17 @@ extern DWORD			g_dwEvents;
 #ifdef HAS_DEVWINDOWS

 extern int			g_fdMessageQueue;

 #endif

-extern DevPrivateKey		g_iScreenPrivateKey;

-extern DevPrivateKey		g_iCmapPrivateKey;

-extern DevPrivateKey		g_iGCPrivateKey;

-extern DevPrivateKey		g_iPixmapPrivateKey;

-extern DevPrivateKey		g_iWindowPrivateKey;

+extern DevPrivateKeyRec		g_iScreenPrivateKeyRec;

+#define g_iScreenPrivateKey  	(&g_iScreenPrivateKeyRec)

+extern DevPrivateKeyRec		g_iCmapPrivateKeyRec;

+#define g_iCmapPrivateKey 	(&g_iCmapPrivateKeyRec)

+extern DevPrivateKeyRec		g_iGCPrivateKeyRec;

+#define g_iGCPrivateKey 	(&g_iGCPrivateKeyRec)

+extern DevPrivateKeyRec		g_iPixmapPrivateKeyRec;

+#define g_iPixmapPrivateKey 	(&g_iPixmapPrivateKeyRec)

+extern DevPrivateKeyRec		g_iWindowPrivateKeyRec;

+#define g_iWindowPrivateKey 	(&g_iWindowPrivateKeyRec)

+

 extern unsigned long		g_ulServerGeneration;

 extern DWORD			g_dwEnginesSupported;

 extern HINSTANCE		g_hInstance;

@@ -1175,7 +1181,7 @@ Bool
 winMapWindowRootless (WindowPtr pWindow);

 

 void

-winSetShapeRootless (WindowPtr pWindow);

+winSetShapeRootless (WindowPtr pWindow, int kind);

 

 

 /*

@@ -1197,7 +1203,7 @@ void
 winReshapeMultiWindow (WindowPtr pWin);

 

 void

-winSetShapeMultiWindow (WindowPtr pWindow);

+winSetShapeMultiWindow (WindowPtr pWindow, int kind);

 

 void

 winUpdateRgnMultiWindow (WindowPtr pWindow);

diff --git a/xorg-server/hw/xwin/winallpriv.c b/xorg-server/hw/xwin/winallpriv.c
index 3413ece53..604c5f673 100644
--- a/xorg-server/hw/xwin/winallpriv.c
+++ b/xorg-server/hw/xwin/winallpriv.c
@@ -1,164 +1,164 @@
-/*
- *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of the XFree86 Project
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from the XFree86 Project.
- *
- * Authors:	Keith Packard, MIT X Consortium
- *		Harold L Hunt II
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-
-
-/* See Porting Layer Definition - p. 58 */
-/*
- * Allocate indexes for the privates that we use.
- * Allocate memory directly for the screen privates.
- * Reserve space in GCs and Pixmaps for our privates.
- * Colormap privates are handled in winAllocateCmapPrivates ()
- */
-
-Bool
-winAllocatePrivates (ScreenPtr pScreen)
-{
-  winPrivScreenPtr	pScreenPriv;
-
-  winDebug ("winAllocateScreenPrivates - g_ulServerGeneration: %d "
-	  "serverGeneration: %d\n",
-	  g_ulServerGeneration, serverGeneration);
-
-  /* We need a new slot for our privates if the screen gen has changed */
-  if (g_ulServerGeneration != serverGeneration)
-    {
-      g_ulServerGeneration = serverGeneration;
-    }
-
-  /* Allocate memory for the screen private structure */
-  pScreenPriv = (winPrivScreenPtr) malloc (sizeof (winPrivScreenRec));
-  if (!pScreenPriv)
-    {
-      ErrorF ("winAllocateScreenPrivates - malloc () failed\n");
-      return FALSE;
-    }
-
-  /* Initialize the memory of the private structure */
-  ZeroMemory (pScreenPriv, sizeof (winPrivScreenRec));
-
-  /* Intialize private structure members */
-  pScreenPriv->fActive = TRUE;
-
-  /* Save the screen private pointer */
-  winSetScreenPriv (pScreen, pScreenPriv);
-
-  /* Reserve GC memory for our privates */
-  if (!dixRequestPrivate(g_iGCPrivateKey, sizeof (winPrivGCRec)))
-    {
-      ErrorF ("winAllocatePrivates - AllocateGCPrivate () failed\n");
-      return FALSE;
-    }
-
-  /* Reserve Pixmap memory for our privates */
-  if (!dixRequestPrivate(g_iPixmapPrivateKey, sizeof (winPrivPixmapRec)))
-    {
-      ErrorF ("winAllocatePrivates - AllocatePixmapPrivates () failed\n");
-      return FALSE;
-    }
-
-  /* Reserve Window memory for our privates */
-  if (!dixRequestPrivate(g_iWindowPrivateKey, sizeof (winPrivWinRec)))
-    {
-      ErrorF ("winAllocatePrivates () - AllocateWindowPrivates () failed\n");
-       return FALSE;
-     }
-
-  return TRUE;
-}
-
-
-/*
- * Colormap privates may be allocated after the default colormap has
- * already been created for some screens.  This initialization procedure
- * is called for each default colormap that is found.
- */
-
-Bool
-winInitCmapPrivates (ColormapPtr pcmap, int index)
-{
-  winDebug ("winInitCmapPrivates\n");
-  
-  /*
-   * I see no way that this function can do anything useful
-   * with only a ColormapPtr.  We don't have the index for
-   * our dev privates yet, so we can't really initialize
-   * anything.  Perhaps I am misunderstanding the purpose
-   * of this function.
-   */
-  /*  That's definitely true.
-   *  I therefore changed the API and added the index as argument.
-   */
-  return TRUE;
-}
-
-
-/*
- * Allocate memory for our colormap privates
- */
-
-Bool
-winAllocateCmapPrivates (ColormapPtr pCmap)
-{
-  winPrivCmapPtr		pCmapPriv;
-  static unsigned long		s_ulPrivateGeneration = 0;
-
-  winDebug ("winAllocateCmapPrivates\n");
-
-  /* Get a new privates index when the server generation changes */
-  if (s_ulPrivateGeneration != serverGeneration)
-    {
-      /* Save the new server generation */
-      s_ulPrivateGeneration = serverGeneration;
-    }
-
-  /* Allocate memory for our private structure */
-  pCmapPriv = (winPrivCmapPtr) malloc (sizeof (winPrivCmapRec));
-  if (!pCmapPriv)
-    {
-      ErrorF ("winAllocateCmapPrivates - malloc () failed\n");
-      return FALSE;
-    }
-
-  /* Initialize the memory of the private structure */
-  ZeroMemory (pCmapPriv, sizeof (winPrivCmapRec));
-
-  /* Save the cmap private pointer */
-  winSetCmapPriv (pCmap, pCmapPriv);
-
-  winDebug ("winAllocateCmapPrivates - Returning\n");
-
-  return TRUE;
-}
+/*

+ *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of the XFree86 Project

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from the XFree86 Project.

+ *

+ * Authors:	Keith Packard, MIT X Consortium

+ *		Harold L Hunt II

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+

+

+/* See Porting Layer Definition - p. 58 */

+/*

+ * Allocate indexes for the privates that we use.

+ * Allocate memory directly for the screen privates.

+ * Reserve space in GCs and Pixmaps for our privates.

+ * Colormap privates are handled in winAllocateCmapPrivates ()

+ */

+

+Bool

+winAllocatePrivates (ScreenPtr pScreen)

+{

+  winPrivScreenPtr	pScreenPriv;

+

+  winDebug ("winAllocateScreenPrivates - g_ulServerGeneration: %d "

+	  "serverGeneration: %d\n",

+	  g_ulServerGeneration, serverGeneration);

+

+  /* We need a new slot for our privates if the screen gen has changed */

+  if (g_ulServerGeneration != serverGeneration)

+    {

+      g_ulServerGeneration = serverGeneration;

+    }

+

+  /* Allocate memory for the screen private structure */

+  pScreenPriv = (winPrivScreenPtr) malloc (sizeof (winPrivScreenRec));

+  if (!pScreenPriv)

+    {

+      ErrorF ("winAllocateScreenPrivates - malloc () failed\n");

+      return FALSE;

+    }

+

+  /* Initialize the memory of the private structure */

+  ZeroMemory (pScreenPriv, sizeof (winPrivScreenRec));

+

+  /* Intialize private structure members */

+  pScreenPriv->fActive = TRUE;

+

+  /* Save the screen private pointer */

+  winSetScreenPriv (pScreen, pScreenPriv);

+

+  /* Reserve GC memory for our privates */

+  if (!dixRegisterPrivateKey(g_iGCPrivateKey, PRIVATE_GC, sizeof (winPrivGCRec)))

+    {

+      ErrorF ("winAllocatePrivates - AllocateGCPrivate () failed\n");

+      return FALSE;

+    }

+

+  /* Reserve Pixmap memory for our privates */

+  if (!dixRegisterPrivateKey(g_iPixmapPrivateKey, PRIVATE_PIXMAP, sizeof (winPrivPixmapRec)))

+    {

+      ErrorF ("winAllocatePrivates - AllocatePixmapPrivates () failed\n");

+      return FALSE;

+    }

+

+  /* Reserve Window memory for our privates */

+  if (!dixRegisterPrivateKey(g_iWindowPrivateKey, PRIVATE_WINDOW, sizeof (winPrivWinRec)))

+    {

+      ErrorF ("winAllocatePrivates () - AllocateWindowPrivates () failed\n");

+       return FALSE;

+     }

+

+  return TRUE;

+}

+

+

+/*

+ * Colormap privates may be allocated after the default colormap has

+ * already been created for some screens.  This initialization procedure

+ * is called for each default colormap that is found.

+ */

+

+Bool

+winInitCmapPrivates (ColormapPtr pcmap, int index)

+{

+  winDebug ("winInitCmapPrivates\n");

+  

+  /*

+   * I see no way that this function can do anything useful

+   * with only a ColormapPtr.  We don't have the index for

+   * our dev privates yet, so we can't really initialize

+   * anything.  Perhaps I am misunderstanding the purpose

+   * of this function.

+   */

+  /*  That's definitely true.

+   *  I therefore changed the API and added the index as argument.

+   */

+  return TRUE;

+}

+

+

+/*

+ * Allocate memory for our colormap privates

+ */

+

+Bool

+winAllocateCmapPrivates (ColormapPtr pCmap)

+{

+  winPrivCmapPtr		pCmapPriv;

+  static unsigned long		s_ulPrivateGeneration = 0;

+

+  winDebug ("winAllocateCmapPrivates\n");

+

+  /* Get a new privates index when the server generation changes */

+  if (s_ulPrivateGeneration != serverGeneration)

+    {

+      /* Save the new server generation */

+      s_ulPrivateGeneration = serverGeneration;

+    }

+

+  /* Allocate memory for our private structure */

+  pCmapPriv = (winPrivCmapPtr) malloc (sizeof (winPrivCmapRec));

+  if (!pCmapPriv)

+    {

+      ErrorF ("winAllocateCmapPrivates - malloc () failed\n");

+      return FALSE;

+    }

+

+  /* Initialize the memory of the private structure */

+  ZeroMemory (pCmapPriv, sizeof (winPrivCmapRec));

+

+  /* Save the cmap private pointer */

+  winSetCmapPriv (pCmap, pCmapPriv);

+

+  winDebug ("winAllocateCmapPrivates - Returning\n");

+

+  return TRUE;

+}

diff --git a/xorg-server/hw/xwin/winclipboardxevents.c b/xorg-server/hw/xwin/winclipboardxevents.c
index d7fa8ffd7..a3d333d80 100644
--- a/xorg-server/hw/xwin/winclipboardxevents.c
+++ b/xorg-server/hw/xwin/winclipboardxevents.c
@@ -426,8 +426,7 @@ winClipboardFlushXEvents (HWND hwnd,
 	    xtpText.value = NULL;

 	    xtpText.nitems = 0;

 	  }

-	  if (pszConvertData)

-	    free (pszConvertData);

+	  free(pszConvertData);

 	  if (hGlobal && pszGlobalData)

 	    GlobalUnlock (hGlobal);

 	  

@@ -792,10 +791,8 @@ winClipboardFlushXEvents (HWND hwnd,
 	    xtpText.value = NULL;

 	    xtpText.nitems = 0;

 	  }

-	  if (pszConvertData)

-	    free (pszConvertData);

-	  if (pwszUnicodeStr)

-	    free (pwszUnicodeStr);

+	  free(pszConvertData);

+	  free(pwszUnicodeStr);

 	  if (hGlobal && pszGlobalData)

 	    GlobalUnlock (hGlobal);

 	  if (fSetClipboardData && g_fUnicodeSupport)

diff --git a/xorg-server/hw/xwin/winconfig.c b/xorg-server/hw/xwin/winconfig.c
index fffd3e813..89a57eada 100644
--- a/xorg-server/hw/xwin/winconfig.c
+++ b/xorg-server/hw/xwin/winconfig.c
@@ -727,7 +727,7 @@ winNameCompare (const char *s1, const char *s2)
       c1 = (isupper (*s1) ? tolower (*s1) : *s1);

       c2 = (isupper (*s2) ? tolower (*s2) : *s2);

     }

-  return (c1 - c2);

+  return c1 - c2;

 }

 

 

@@ -762,11 +762,11 @@ winFindOptionValue (XF86OptionPtr list, const char *name)
   if (list)

     {

       if (list->opt_val)

-	return (list->opt_val);

+	return list->opt_val;

       else

 	return "";

     }

-  return (NULL);

+  return NULL;

 }

 

 

diff --git a/xorg-server/hw/xwin/winerror.c b/xorg-server/hw/xwin/winerror.c
index 2e706009c..b6b780ec4 100644
--- a/xorg-server/hw/xwin/winerror.c
+++ b/xorg-server/hw/xwin/winerror.c
@@ -162,9 +162,7 @@ winMessageBoxF (const char *pszError, UINT uType, ...)
 	      MB_OK | uType);

 

  winMessageBoxF_Cleanup:

-  if (pszErrorF)

-    free(pszErrorF);

-  if (pszMsgBox)

-    free(pszMsgBox);

+  free(pszErrorF);

+  free(pszMsgBox);

 #undef MESSAGEBOXF

 }

diff --git a/xorg-server/hw/xwin/winfillsp.c b/xorg-server/hw/xwin/winfillsp.c
index 702f34f96..ef427a3f1 100644
--- a/xorg-server/hw/xwin/winfillsp.c
+++ b/xorg-server/hw/xwin/winfillsp.c
@@ -1,866 +1,866 @@
-/*
- *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of the XFree86 Project
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from the XFree86 Project.
- *
- * Authors:	Harold L Hunt II
- * 		Alan Hourihane <alanh@fairlite.demon.co.uk>
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-
-
-extern void ROP16(HDC hdc, int rop);
-
-#define TRANSLATE_COLOR(color)						\
-{									\
-  if (pDrawable->depth == 15)						\
-    color = ((color & 0x1F) << 19) | ((color & 0x03E0) << 6) |		\
-      ((color & 0xF800) >> 8);						\
-  else if (pDrawable->depth == 16)					\
-    color = ((color & 0x1F) << 19) | ((color & 0x07E0) << 5) |		\
-      ((color & 0xF800) >> 8);						\
-  else if (pDrawable->depth == 24 || pDrawable->depth == 32)		\
-    color = ((color & 0xFF) << 16) | (color & 0xFF00) |			\
-      ((color & 0xFF0000) >> 16);					\
-}
-
-/* See Porting Layer Definition - p. 54 */
-void
-winFillSpansNativeGDI (DrawablePtr	pDrawable,
-		       GCPtr		pGC,
-		       int		iSpans,
-		       DDXPointPtr	pPoints,
-		       int		*piWidths,
-		       int		fSorted)
-{
-  winGCPriv(pGC);
-  HBITMAP		hbmpOrig = NULL, hbmpOrigStipple = NULL;
-  HBITMAP		hPenOrig = NULL;
-  HBITMAP		hBitmap = NULL;
-  PixmapPtr		pPixmap = NULL;
-  winPrivPixmapPtr	pPixmapPriv = NULL;
-  PixmapPtr		pStipple = NULL;
-  winPrivPixmapPtr	pStipplePriv = NULL;
-  PixmapPtr		pTile = NULL;
-  winPrivPixmapPtr	pTilePriv = NULL;
-  HDC			hdcStipple = NULL, hdcTile = NULL;
-  HPEN			hPen = NULL;
-  int			iX;
-  int			fg, bg;
-  RegionPtr	    	pClip = pGC->pCompositeClip;
-  BoxPtr	    	pextent, pbox;
-  int		    	nbox;
-  int		    	extentX1, extentX2, extentY1, extentY2;
-  int		    	fullX1, fullX2, fullY1;
-  HRGN			hrgn = NULL, combined = NULL;
-
-  nbox = REGION_NUM_RECTS (pClip);
-  pbox = REGION_RECTS (pClip);
-
-  if (!nbox) return;
-
-  combined = CreateRectRgn (pbox->x1, pbox->y1, pbox->x2, pbox->y2);
-  nbox--; pbox++;
-
-  while (nbox--)
-    {
-      hrgn = CreateRectRgn (pbox->x1, pbox->y1, pbox->x2, pbox->y2);
-      CombineRgn (combined, combined, hrgn, RGN_OR);
-      DeleteObject (hrgn);
-      hrgn = NULL;
-      pbox++;
-    }
-
-  pextent = REGION_EXTENTS (pGC->pScreen, pClip);
-  extentX1 = pextent->x1;
-  extentY1 = pextent->y1;
-  extentX2 = pextent->x2;
-  extentY2 = pextent->y2;
-
-  /* Branch on the type of drawable we have */
-  switch (pDrawable->type)
-    {
-    case DRAWABLE_PIXMAP:
-
-      SelectClipRgn (pGCPriv->hdcMem, combined);
-      DeleteObject (combined);
-      combined = NULL;
-
-      /* Get a pixmap pointer from the drawable pointer, and fetch privates  */
-      pPixmap = (PixmapPtr) pDrawable;
-      pPixmapPriv = winGetPixmapPriv (pPixmap);
-
-      /* Select the drawable pixmap into memory hdc */
-      hbmpOrig = SelectObject (pGCPriv->hdcMem, pPixmapPriv->hBitmap);
-      if (hbmpOrig == NULL)
-	FatalError ("winFillSpans - DRAWABLE_PIXMAP - "
-		    "SelectObject () failed on\n\tpPixmapPriv->hBitmap: "
-		    "%08x\n", (unsigned int) pPixmapPriv->hBitmap);
-      
-      /* Branch on the fill type */
-      switch (pGC->fillStyle)
-	{
-	case FillSolid:
-
-          ROP16 (pGCPriv->hdcMem, pGC->alu);
-
-	  if (pDrawable->depth == 1) 
-	    {
-	      if (pGC->fgPixel == 0)
-		hPenOrig = SelectObject (pGCPriv->hdcMem, 
-					 GetStockObject (BLACK_PEN));
-	      else
-		hPenOrig = SelectObject (pGCPriv->hdcMem,
-					 GetStockObject (WHITE_PEN));
-	    } 
-	  else 
-	    {
-	      fg = pGC->fgPixel;
-	      TRANSLATE_COLOR (fg);
-	      hPen = CreatePen (PS_SOLID, 0, fg);
-	      hPenOrig = SelectObject (pGCPriv->hdcMem, hPen);
-	    }
-    	
-	  while (iSpans--)
-	    {
-	      fullX1 = pPoints->x;
-	      fullY1 = pPoints->y;
-	      fullX2 = fullX1 + (int) *piWidths;
-	      pPoints++;
-	      piWidths++;
-	
-	      if (fullY1 < extentY1 || extentY2 <= fullY1)
-		continue;
-	
-	      if (fullX1 < extentX1)
-		fullX1 = extentX1;
-	      if (fullX2 > extentX2)
-		fullX2 = extentX2;
-	
-	      if (fullX1 >= fullX2)
-		continue;
-	
-	      MoveToEx (pGCPriv->hdcMem, fullX1, fullY1, NULL);
-	      LineTo (pGCPriv->hdcMem, fullX2, fullY1);
-	    }
-
-          SetROP2 (pGCPriv->hdcMem, R2_COPYPEN);
-
-	  /* Give back the Pen */
-	  SelectObject (pGCPriv->hdcMem, hPenOrig);
-
-	  if (pDrawable->depth != 1)
-	    DeleteObject (hPen);
-	  break;
-
-	case FillOpaqueStippled:
-
-	  pStipple = pGC->stipple;
-	  pStipplePriv = winGetPixmapPriv (pStipple);
-
-	  /* Create a device-dependent bitmap for the stipple */
-	  hBitmap = CreateDIBitmap (pGCPriv->hdcMem,
-				    (BITMAPINFOHEADER *)pStipplePriv->pbmih,
-				    CBM_INIT,
-				    pStipplePriv->pbBits,
-				    (BITMAPINFO *)pStipplePriv->pbmih,
-				    DIB_RGB_COLORS);
-
-	  /* Create a memory DC to hold the stipple */
-	  hdcStipple = CreateCompatibleDC (pGCPriv->hdcMem);
-
-	  /* Select the stipple bitmap into the stipple DC */
-	  hbmpOrigStipple = SelectObject (hdcStipple, hBitmap);
-	  if (hbmpOrigStipple == NULL)
-	    FatalError ("winFillSpans () - DRAWABLE_PIXMAP - FillStippled - "
-			"SelectObject () failed on hbmpOrigStipple\n");
-
-	  /* Make a temporary copy of the foreground and background colors */
-   	  bg = pGC->bgPixel;
-   	  fg = pGC->fgPixel;
-
-	  /* Translate the depth-dependent colors to Win32 COLORREFs */
-	  TRANSLATE_COLOR (fg);
-	  TRANSLATE_COLOR (bg);
-	  SetTextColor (pGCPriv->hdcMem, fg);
-	  SetBkColor (pGCPriv->hdcMem, bg);
-
-	  while (iSpans--)
-	    {
-	      int width = pStipple->drawable.width;
-	      fullX1 = pPoints->x;
-	      fullY1 = pPoints->y;
-	      fullX2 = fullX1 + (int) *piWidths;
-	      pPoints++;
-	      piWidths++;
-	
-	      if (fullY1 < extentY1 || extentY2 <= fullY1)
-		continue;
-	
-	      if (fullX1 < extentX1)
-		fullX1 = extentX1;
-	      if (fullX2 > extentX2)
-		fullX2 = extentX2;
-	
-	      if (fullX1 >= fullX2)
-		continue;
-	
-	      for (iX = fullX1; iX < fullX2; iX += width)
-		{
-		  int xoffset;
-
-		  if ((iX + pStipple->drawable.width) > fullX2)
-		    width = fullX2 - iX;
-		  else
-		    width = pStipple->drawable.width;
-
-		  if (iX == fullX1)
-		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pStipple->drawable.width) - pStipple->drawable.width)) % pStipple->drawable.width;
-		  else
-		    xoffset = 0;
-
-		  if (xoffset + width > pStipple->drawable.width)
-		    width = pStipple->drawable.width - xoffset;
-
-		  BitBlt (pGCPriv->hdcMem,
-			  iX, fullY1,
-			  width, 1,
-			  hdcStipple,
-			  xoffset,
-			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pStipple->drawable.height) - pStipple->drawable.height)) % pStipple->drawable.height,
-			  g_copyROP[pGC->alu]);
-		}
-	    }
-
-	  /* Clear the stipple HDC */
-	  SelectObject (hdcStipple, hbmpOrigStipple);
-	  DeleteDC (hdcStipple);
-
-	  /* Delete the device dependent stipple bitmap */
-	  DeleteObject (hBitmap);
-
-	  break;
-	case FillStippled:
-
-	  pStipple = pGC->stipple;
-	  pStipplePriv = winGetPixmapPriv (pStipple);
-
-	  /* Create a device-dependent bitmap for the stipple */
-	  hBitmap = CreateDIBitmap (pGCPriv->hdcMem,
-				    (BITMAPINFOHEADER *)pStipplePriv->pbmih,
-				    CBM_INIT,
-				    pStipplePriv->pbBits,
-				    (BITMAPINFO *)pStipplePriv->pbmih,
-				    DIB_RGB_COLORS);
-
-	  /* Create a memory DC to hold the stipple */
-	  hdcStipple = CreateCompatibleDC (pGCPriv->hdcMem);
-
-	  /* Select the stipple bitmap into the stipple DC */
-	  hbmpOrigStipple = SelectObject (hdcStipple, hBitmap);
-	  if (hbmpOrigStipple == NULL)
-	    FatalError ("winFillSpans () - DRAWABLE_PIXMAP - FillStippled - "
-			"SelectObject () failed on hbmpOrigStipple\n");
-
-	  /* Make a temporary copy of the foreground and background colors */
-   	  bg = pGC->bgPixel;
-   	  fg = pGC->fgPixel;
-
-	  /* Translate the depth-dependent colors to Win32 COLORREFs */
-	  TRANSLATE_COLOR (fg);
-	  TRANSLATE_COLOR (bg);
-
-	  /* this is fudgy, we should only invert on the last one
-	   * We need to get the black/white pixels right in the
-	   * colormap. But yeah ! it's working.. 
-	   */
-	  if (pGC->bgPixel != -1 && pGC->fgPixel != -1) 
-	    {
-	      SetTextColor (pGCPriv->hdcMem, fg);
-	      SetBkColor (pGCPriv->hdcMem, bg);
-	      BitBlt (hdcStipple,
-		      0, 0,
-		      pStipple->drawable.width, pStipple->drawable.height,
-		      hdcStipple,
-		      0, 0,
-		      0x330008);
-	    } 
-	  else if (pGC->bgPixel == -1) 
-	    {
-	      SetTextColor (pGCPriv->hdcMem, fg);
-	      SetBkMode (pGCPriv->hdcMem, TRANSPARENT);
-	      BitBlt (hdcStipple,
-		      0, 0,
-		      pStipple->drawable.width, pStipple->drawable.height,
-		      hdcStipple,
-		      0, 0,
-		      0x330008);
-	    } 
-	  else if (pGC->fgPixel == -1) 
-	    {
-	      SetTextColor (pGCPriv->hdcMem, bg);
-	      SetBkMode (pGCPriv->hdcMem, TRANSPARENT);
-#if 0
-	      BitBlt (hdcStipple,
-		      0, 0,
-		      pStipple->drawable.width, pStipple->drawable.height,
-		      hdcStipple,
-		      0, 0,
-		      0x330008);
-#endif
-	    }
-
-	  while (iSpans--)
-	    {
-	      int width = pStipple->drawable.width;
-	      fullX1 = pPoints->x;
-	      fullY1 = pPoints->y;
-	      fullX2 = fullX1 + (int) *piWidths;
-	      pPoints++;
-	      piWidths++;
-	
-	      if (fullY1 < extentY1 || extentY2 <= fullY1)
-		continue;
-	
-	      if (fullX1 < extentX1)
-		fullX1 = extentX1;
-	      if (fullX2 > extentX2)
-		fullX2 = extentX2;
-	
-	      if (fullX1 >= fullX2)
-		continue;
-	
-	      for (iX = fullX1; iX < fullX2; iX += width)
-		{
-		  int xoffset;
-
-		  if ((iX + pStipple->drawable.width) > fullX2)
-		    width = fullX2 - iX;
-		  else
-		    width = pStipple->drawable.width;
-
-		  if (iX == fullX1)
-		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pStipple->drawable.width) - pStipple->drawable.width)) % pStipple->drawable.width;
-		  else
-		    xoffset = 0;
-
-		  if (xoffset + width > pStipple->drawable.width)
-		    width = pStipple->drawable.width - xoffset;
-
-		  BitBlt (pGCPriv->hdcMem,
-		          iX, fullY1,
-		          width, 1,
-		          hdcStipple,
-			  xoffset,
-			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pStipple->drawable.height) - pStipple->drawable.height)) % pStipple->drawable.height,
-			  g_copyROP[pGC->alu]);
-		}
-	    }
-
-	  /* Clear the stipple HDC */
-	  SelectObject (hdcStipple, hbmpOrigStipple);
-	  DeleteDC (hdcStipple);
-
-	  /* Delete the device dependent stipple bitmap */
-	  DeleteObject (hBitmap);
-
-	  /* Restore the background mode */
-	  SetBkMode (pGCPriv->hdcMem, OPAQUE);
-	  break;
-
-	case FillTiled:
-
-	  /* Get a pixmap pointer from the tile pointer, and fetch privates  */
-	  pTile = (PixmapPtr) pGC->tile.pixmap;
-	  pTilePriv = winGetPixmapPriv (pTile);
-
-	  /* Create a memory DC to hold the tile */
-	  hdcTile = CreateCompatibleDC (pGCPriv->hdcMem);
-
-	  /* Select the tile into a DC */
-	  hbmpOrig = SelectObject (hdcTile, pTilePriv->hBitmap);
-	  if (hbmpOrig == NULL)
-	    FatalError ("winFillSpans - DRAWABLE_PIXMAP - FillTiled - "
-			"SelectObject () failed on pTilePriv->hBitmap\n");
-
-	  while (iSpans--)
-	    {
-	      int width = pTile->drawable.width;
-	      fullX1 = pPoints->x;
-	      fullY1 = pPoints->y;
-	      fullX2 = fullX1 + (int) *piWidths;
-	      pPoints++;
-	      piWidths++;
-	
-	      if (fullY1 < extentY1 || extentY2 <= fullY1)
-		continue;
-	
-	      if (fullX1 < extentX1)
-		fullX1 = extentX1;
-	      if (fullX2 > extentX2)
-		fullX2 = extentX2;
-	
-	      if (fullX1 >= fullX2)
-		continue;
-	
-	      for (iX = fullX1; iX < fullX2; iX += width)
-	      	{
-		  int xoffset;
-
-		  if ((iX + pTile->drawable.width) > fullX2)
-		    width = fullX2 - iX;
-		  else
-		    width = pTile->drawable.width;
-
-		  if (iX == fullX1)
-		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pTile->drawable.width) - pTile->drawable.width)) % pTile->drawable.width;
-		  else
-		    xoffset = 0;
-
-		  if (xoffset + width > pTile->drawable.width)
-		    width = pTile->drawable.width - xoffset;
-
-		  BitBlt (pGCPriv->hdcMem,
-			  iX, fullY1,
-			  width, 1,
-			  hdcTile,
-			  xoffset,
-			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pTile->drawable.height) - pTile->drawable.height)) % pTile->drawable.height,
-			  g_copyROP[pGC->alu]);
-		}
-	    }
-
-	  /* Push the tile pixmap out of the memory HDC */
-	  SelectObject (hdcTile, hbmpOrig);
-
-	  /* Delete the tile */
-	  DeleteDC (hdcTile);
-	  break;
-
-	default:
-	  ErrorF ("winFillSpans - DRAWABLE_PIXMAP - Unknown fillStyle\n");
-	  break;
-	}
-
-      /* Reset clip region */
-      SelectClipRgn (pGCPriv->hdcMem, NULL);
-
-      /* Push the drawable pixmap out of the GC HDC */
-      SelectObject (pGCPriv->hdcMem, hbmpOrig);
-      break;
-      
-    case DRAWABLE_WINDOW:
-
-      SelectClipRgn (pGCPriv->hdc, combined);
-      DeleteObject (combined);
-      combined = NULL;
-
-      /* Branch on fill style */
-      switch (pGC->fillStyle)
-	{
-	case FillSolid:
-
-          ROP16 (pGCPriv->hdc, pGC->alu);
-
-	  if (pDrawable->depth == 1) 
-	    {
-	      if (pGC->fgPixel == 0)
-		hPenOrig = SelectObject (pGCPriv->hdc, 
-					 GetStockObject (BLACK_PEN));
-	      else
-		hPenOrig = SelectObject (pGCPriv->hdc,
-					 GetStockObject (WHITE_PEN));
-	    } 
-	  else 
-	    {
-	      fg = pGC->fgPixel;
-	      TRANSLATE_COLOR (fg);
-	      hPen = CreatePen (PS_SOLID, 0, fg);
-	      hPenOrig = SelectObject (pGCPriv->hdc, hPen);
-	    }
-
-	  while (iSpans--)
-	    {
-	      fullX1 = pPoints->x;
-	      fullY1 = pPoints->y;
-	      fullX2 = fullX1 + (int) *piWidths;
-	      pPoints++;
-	      piWidths++;
-	
-	      if (fullY1 < extentY1 || extentY2 <= fullY1)
-		continue;
-	
-	      if (fullX1 < extentX1)
-		fullX1 = extentX1;
-	      if (fullX2 > extentX2)
-		fullX2 = extentX2;
-	
-	      if (fullX1 >= fullX2)
-		continue;
-	
-	      MoveToEx (pGCPriv->hdc, fullX1, fullY1, NULL);
-	      LineTo (pGCPriv->hdc, fullX2, fullY1);
-	    }
-
-          SetROP2 (pGCPriv->hdc, R2_COPYPEN);
-
-	  /* Give back the Brush */
-	  SelectObject (pGCPriv->hdc, hPenOrig);
-
-	  if (pDrawable->depth != 1)
-	    DeleteObject (hPen);
-	  break;
-
-	case FillOpaqueStippled:
-
-	  pStipple = pGC->stipple;
-	  pStipplePriv = winGetPixmapPriv (pStipple);
-
-	  /* Create a device-dependent bitmap for the stipple */
-	  hBitmap = CreateDIBitmap (pGCPriv->hdc,
-				    (BITMAPINFOHEADER *)pStipplePriv->pbmih,
-				    CBM_INIT,
-				    pStipplePriv->pbBits,
-				    (BITMAPINFO *)pStipplePriv->pbmih,
-				    DIB_RGB_COLORS);
-
-	  /* Create a memory DC to hold the stipple */
-	  hdcStipple = CreateCompatibleDC (pGCPriv->hdc);
-
-	  /* Select the stipple bitmap into the stipple DC */
-	  hbmpOrigStipple = SelectObject (hdcStipple, hBitmap);
-	  if (hbmpOrigStipple == NULL)
-	    FatalError ("winFillSpans () - DRAWABLE_PIXMAP - FillStippled - "
-			"SelectObject () failed on hbmpOrigStipple\n");
-
-	  /* Make a temporary copy of the foreground and background colors */
-   	  bg = pGC->bgPixel;
-   	  fg = pGC->fgPixel;
-
-	  /* Translate the depth-dependent colors to Win32 COLORREFs */
-	  TRANSLATE_COLOR (fg);
-	  TRANSLATE_COLOR (bg);
-	  SetTextColor (pGCPriv->hdc, fg);
-	  SetBkColor (pGCPriv->hdc, bg);
-
-	  while (iSpans--)
-	    {
-	      int width = pStipple->drawable.width;
-	      fullX1 = pPoints->x;
-	      fullY1 = pPoints->y;
-	      fullX2 = fullX1 + (int) *piWidths;
-	      pPoints++;
-	      piWidths++;
-	
-	      if (fullY1 < extentY1 || extentY2 <= fullY1)
-		continue;
-	
-	      if (fullX1 < extentX1)
-		fullX1 = extentX1;
-	      if (fullX2 > extentX2)
-		fullX2 = extentX2;
-	
-	      if (fullX1 >= fullX2)
-		continue;
-	
-	      for (iX = fullX1; iX < fullX2; iX += width)
-		{
-		  int xoffset;
-
-		  if ((iX + pStipple->drawable.width) > fullX2)
-		    width = fullX2 - iX;
-		  else
-		    width = pStipple->drawable.width;
-
-		  if (iX == fullX1)
-		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pStipple->drawable.width) - pStipple->drawable.width)) % pStipple->drawable.width;
-		  else
-		    xoffset = 0;
-
-		  if (xoffset + width > pStipple->drawable.width)
-		    width = pStipple->drawable.width - xoffset;
-
-		  BitBlt (pGCPriv->hdc,
-			  iX, fullY1,
-			  width, 1,
-			  hdcStipple,
-			  xoffset,
-			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pStipple->drawable.height) - pStipple->drawable.height)) % pStipple->drawable.height,
-			  g_copyROP[pGC->alu]);
-		}
-	    }
-
-	  /* Clear the stipple HDC */
-	  SelectObject (hdcStipple, hbmpOrigStipple);
-	  DeleteDC (hdcStipple);
-
-	  /* Delete the device dependent stipple bitmap */
-	  DeleteObject (hBitmap);
-
-	  break;
-
-	case FillStippled:
-	  pStipple = pGC->stipple;
-	  pStipplePriv = winGetPixmapPriv (pStipple);
-
-	  /* Create a device-dependent bitmap for the stipple */
-	  hBitmap = CreateDIBitmap (pGCPriv->hdcMem,
-				    (BITMAPINFOHEADER *)pStipplePriv->pbmih,
-				    CBM_INIT,
-				    pStipplePriv->pbBits,
-				    (BITMAPINFO *)pStipplePriv->pbmih,
-				    DIB_RGB_COLORS);
-
-	  /* Create a memory DC to hold the stipple */
-	  hdcStipple = CreateCompatibleDC (pGCPriv->hdc);
-
-	  /* Select the stipple bitmap into the stipple DC */
-	  hbmpOrigStipple = SelectObject (hdcStipple, hBitmap);
-	  if (hbmpOrigStipple == NULL)
-	    FatalError ("winFillSpans () - DRAWABLE_PIXMAP - FillStippled - "
-			"SelectObject () failed on hbmpOrigStipple\n");
-
-	  /* Make a temporary copy of the foreground and background colors */
-   	  bg = pGC->bgPixel;
-   	  fg = pGC->fgPixel;
-
-	  /* Translate the depth-dependent colors to Win32 COLORREFs */
-	  TRANSLATE_COLOR (fg);
-	  TRANSLATE_COLOR (bg);
-
-	  /* this is fudgy, we should only invert on the last one
-	   * We need to get the black/white pixels right in the
-	   * colormap. But yeah ! it's working.. 
-	   */
-	  if (pGC->bgPixel != -1 && pGC->fgPixel != -1) 
-	    {
-	      SetTextColor (pGCPriv->hdc, fg);
-	      SetBkColor (pGCPriv->hdc, bg);
-	      BitBlt (hdcStipple,
-		      0, 0,
-		      pStipple->drawable.width, pStipple->drawable.height,
-		      hdcStipple,
-		      0,0,
-		      0x330008);
-	    } 
-	  else if (pGC->bgPixel == -1) 
-	    {
-	      SetTextColor (pGCPriv->hdc, fg);
-	      SetBkMode (pGCPriv->hdc, TRANSPARENT);
-	      BitBlt (hdcStipple,
-		      0, 0,
-		      pStipple->drawable.width, pStipple->drawable.height,
-		      hdcStipple,
-		      0,0,
-		      0x330008);
-	    } 
-	  else if (pGC->fgPixel == -1) 
-	    {
-	      SetTextColor (pGCPriv->hdc, bg);
-	      SetBkMode (pGCPriv->hdc, TRANSPARENT);
-#if 0
-	      BitBlt (hdcStipple,
-		      0, 0,
-		      pStipple->drawable.width, pStipple->drawable.height,
-		      hdcStipple,
-		      0, 0,
-		      0x330008);
-#endif
-	    }
-
-	  while (iSpans--)
-	    {
- 	      int width = pStipple->drawable.width;
-	      fullX1 = pPoints->x;
-	      fullY1 = pPoints->y;
-	      fullX2 = fullX1 + (int) *piWidths;
-	      pPoints++;
-	      piWidths++;
-	
-	      if (fullY1 < extentY1 || extentY2 <= fullY1)
-		continue;
-	
-	      if (fullX1 < extentX1)
-		fullX1 = extentX1;
-	      if (fullX2 > extentX2)
-		fullX2 = extentX2;
-	
-	      if (fullX1 >= fullX2)
-		continue;
-	
-	      for (iX = fullX1; iX < fullX2; iX += width)
-		{
-		  int xoffset;
-
-		  if ((iX + pStipple->drawable.width) > fullX2)
-		    width = fullX2 - iX;
-		  else
-		    width = pStipple->drawable.width;
-
-		  if (iX == fullX1)
-		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pStipple->drawable.width) - pStipple->drawable.width)) % pStipple->drawable.width;
-		  else
-		    xoffset = 0;
-
-		  if (xoffset + width > pStipple->drawable.width)
-		    width = pStipple->drawable.width - xoffset;
-
-		  BitBlt (pGCPriv->hdc,
-			  iX, fullY1,
-			  width, 1,
-			  hdcStipple,
-			  xoffset,
-			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pStipple->drawable.height) - pStipple->drawable.height)) % pStipple->drawable.height,
-			  g_copyROP[pGC->alu]);
-		}
-	    }
-
-	  /* Clear the stipple HDC */
-	  SelectObject (hdcStipple, hbmpOrigStipple);
-	  DeleteDC (hdcStipple);
-
-	  /* Delete the device dependent stipple bitmap */
-	  DeleteObject (hBitmap);
-
-	  /* Restore the background mode */
-	  SetBkMode (pGCPriv->hdc, OPAQUE);	  
-	  break;
-
-	case FillTiled:
-
-	  /* Get a pixmap pointer from the tile pointer, and fetch privates  */
-	  pTile = (PixmapPtr) pGC->tile.pixmap;
-	  pTilePriv = winGetPixmapPriv (pTile);
-
-	  /* Select the tile into a DC */
-	  hbmpOrig = SelectObject (pGCPriv->hdcMem, pTilePriv->hBitmap);
-	  if (hbmpOrig == NULL)
-	    FatalError ("winFillSpans - DRAWABLE_WINDOW - FillTiled - "
-			"SelectObject () failed on pTilePriv->hBitmap\n");
-
-	  while (iSpans--)
-	    {
-	      int width = pTile->drawable.width;
-	      fullX1 = pPoints->x;
-	      fullY1 = pPoints->y;
-	      fullX2 = fullX1 + (int) *piWidths;
-	      pPoints++;
-	      piWidths++;
-	
-	      if (fullY1 < extentY1 || extentY2 <= fullY1)
-		continue;
-	
-	      if (fullX1 < extentX1)
-		fullX1 = extentX1;
-	      if (fullX2 > extentX2)
-		fullX2 = extentX2;
-	
-	      if (fullX1 >= fullX2)
-		continue;
-	
-	      for (iX = fullX1; iX < fullX2; iX += width)
-	      	{
-		  int xoffset;
-
-		  if ((iX + pTile->drawable.width) > fullX2)
-		    width = fullX2 - iX;
-		  else
-		    width = pTile->drawable.width;
-
-		  if (iX == fullX1)
-		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pTile->drawable.width) - pTile->drawable.width)) % pTile->drawable.width;
-		  else
-		    xoffset = 0;
-
-		  if (xoffset + width > pTile->drawable.width)
-		    width = pTile->drawable.width - xoffset;
-
-		  BitBlt (pGCPriv->hdc,
-			  iX, fullY1,
-			  width, 1,
-			  pGCPriv->hdcMem,
-			  xoffset,
-			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pTile->drawable.height) - pTile->drawable.height)) % pTile->drawable.height,
-			  g_copyROP[pGC->alu]);
-		}
-	    }
-
-	  /* Push the tile pixmap out of the memory HDC */
-	  SelectObject (pGCPriv->hdcMem, hbmpOrig);
-	  break;
-
-	default:
-	  ErrorF ("winFillSpans - DRAWABLE_WINDOW - Unknown fillStyle\n");
-	  break;
-	}
-
-      /* Reset clip region */
-      SelectClipRgn (pGCPriv->hdc, NULL);
-      break;
-
-    case UNDRAWABLE_WINDOW:
-      /* UNDRAWABLE_WINDOW doesn't appear to get called when running xterm */
-      switch (pGC->fillStyle)
-	{
-	case FillSolid:
-	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - FillSolid - "
-		  "Unimplemented\n");
-	  break;
-
-	case FillStippled:
-	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - FillStippled - "
-		  "Unimplemented\n");
-	  break;
-
-	case FillTiled:
-	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - FillTiled - "
-		  "Unimplemented\n");
-	  break;
-
-	case FillOpaqueStippled:
-	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - OpaqueStippled - "
-		  "Unimplemented\n");
-	  break;
-
-	default:
-	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - Unknown fillStyle\n");
-	  break;
-	}
-      break;
-
-    case DRAWABLE_BUFFER:
-      /* DRAWABLE_BUFFER seems to be undocumented. */
-      ErrorF ("winFillSpans - DRAWABLE_BUFFER - Unimplemented\n");
-      break;
-
-    default:
-      ErrorF ("winFillSpans - Unknown drawable type\n");
-      break;
-    }
-}
+/*

+ *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of the XFree86 Project

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from the XFree86 Project.

+ *

+ * Authors:	Harold L Hunt II

+ * 		Alan Hourihane <alanh@fairlite.demon.co.uk>

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+

+

+extern void ROP16(HDC hdc, int rop);

+

+#define TRANSLATE_COLOR(color)						\

+{									\

+  if (pDrawable->depth == 15)						\

+    color = ((color & 0x1F) << 19) | ((color & 0x03E0) << 6) |		\

+      ((color & 0xF800) >> 8);						\

+  else if (pDrawable->depth == 16)					\

+    color = ((color & 0x1F) << 19) | ((color & 0x07E0) << 5) |		\

+      ((color & 0xF800) >> 8);						\

+  else if (pDrawable->depth == 24 || pDrawable->depth == 32)		\

+    color = ((color & 0xFF) << 16) | (color & 0xFF00) |			\

+      ((color & 0xFF0000) >> 16);					\

+}

+

+/* See Porting Layer Definition - p. 54 */

+void

+winFillSpansNativeGDI (DrawablePtr	pDrawable,

+		       GCPtr		pGC,

+		       int		iSpans,

+		       DDXPointPtr	pPoints,

+		       int		*piWidths,

+		       int		fSorted)

+{

+  winGCPriv(pGC);

+  HBITMAP		hbmpOrig = NULL, hbmpOrigStipple = NULL;

+  HBITMAP		hPenOrig = NULL;

+  HBITMAP		hBitmap = NULL;

+  PixmapPtr		pPixmap = NULL;

+  winPrivPixmapPtr	pPixmapPriv = NULL;

+  PixmapPtr		pStipple = NULL;

+  winPrivPixmapPtr	pStipplePriv = NULL;

+  PixmapPtr		pTile = NULL;

+  winPrivPixmapPtr	pTilePriv = NULL;

+  HDC			hdcStipple = NULL, hdcTile = NULL;

+  HPEN			hPen = NULL;

+  int			iX;

+  int			fg, bg;

+  RegionPtr	    	pClip = pGC->pCompositeClip;

+  BoxPtr	    	pextent, pbox;

+  int		    	nbox;

+  int		    	extentX1, extentX2, extentY1, extentY2;

+  int		    	fullX1, fullX2, fullY1;

+  HRGN			hrgn = NULL, combined = NULL;

+

+  nbox = RegionNumRects (pClip);

+  pbox = RegionRects (pClip);

+

+  if (!nbox) return;

+

+  combined = CreateRectRgn (pbox->x1, pbox->y1, pbox->x2, pbox->y2);

+  nbox--; pbox++;

+

+  while (nbox--)

+    {

+      hrgn = CreateRectRgn (pbox->x1, pbox->y1, pbox->x2, pbox->y2);

+      CombineRgn (combined, combined, hrgn, RGN_OR);

+      DeleteObject (hrgn);

+      hrgn = NULL;

+      pbox++;

+    }

+

+  pextent = RegionExtents(pClip);

+  extentX1 = pextent->x1;

+  extentY1 = pextent->y1;

+  extentX2 = pextent->x2;

+  extentY2 = pextent->y2;

+

+  /* Branch on the type of drawable we have */

+  switch (pDrawable->type)

+    {

+    case DRAWABLE_PIXMAP:

+

+      SelectClipRgn (pGCPriv->hdcMem, combined);

+      DeleteObject (combined);

+      combined = NULL;

+

+      /* Get a pixmap pointer from the drawable pointer, and fetch privates  */

+      pPixmap = (PixmapPtr) pDrawable;

+      pPixmapPriv = winGetPixmapPriv (pPixmap);

+

+      /* Select the drawable pixmap into memory hdc */

+      hbmpOrig = SelectObject (pGCPriv->hdcMem, pPixmapPriv->hBitmap);

+      if (hbmpOrig == NULL)

+	FatalError ("winFillSpans - DRAWABLE_PIXMAP - "

+		    "SelectObject () failed on\n\tpPixmapPriv->hBitmap: "

+		    "%08x\n", (unsigned int) pPixmapPriv->hBitmap);

+      

+      /* Branch on the fill type */

+      switch (pGC->fillStyle)

+	{

+	case FillSolid:

+

+          ROP16 (pGCPriv->hdcMem, pGC->alu);

+

+	  if (pDrawable->depth == 1) 

+	    {

+	      if (pGC->fgPixel == 0)

+		hPenOrig = SelectObject (pGCPriv->hdcMem, 

+					 GetStockObject (BLACK_PEN));

+	      else

+		hPenOrig = SelectObject (pGCPriv->hdcMem,

+					 GetStockObject (WHITE_PEN));

+	    } 

+	  else 

+	    {

+	      fg = pGC->fgPixel;

+	      TRANSLATE_COLOR (fg);

+	      hPen = CreatePen (PS_SOLID, 0, fg);

+	      hPenOrig = SelectObject (pGCPriv->hdcMem, hPen);

+	    }

+    	

+	  while (iSpans--)

+	    {

+	      fullX1 = pPoints->x;

+	      fullY1 = pPoints->y;

+	      fullX2 = fullX1 + (int) *piWidths;

+	      pPoints++;

+	      piWidths++;

+	

+	      if (fullY1 < extentY1 || extentY2 <= fullY1)

+		continue;

+	

+	      if (fullX1 < extentX1)

+		fullX1 = extentX1;

+	      if (fullX2 > extentX2)

+		fullX2 = extentX2;

+	

+	      if (fullX1 >= fullX2)

+		continue;

+	

+	      MoveToEx (pGCPriv->hdcMem, fullX1, fullY1, NULL);

+	      LineTo (pGCPriv->hdcMem, fullX2, fullY1);

+	    }

+

+          SetROP2 (pGCPriv->hdcMem, R2_COPYPEN);

+

+	  /* Give back the Pen */

+	  SelectObject (pGCPriv->hdcMem, hPenOrig);

+

+	  if (pDrawable->depth != 1)

+	    DeleteObject (hPen);

+	  break;

+

+	case FillOpaqueStippled:

+

+	  pStipple = pGC->stipple;

+	  pStipplePriv = winGetPixmapPriv (pStipple);

+

+	  /* Create a device-dependent bitmap for the stipple */

+	  hBitmap = CreateDIBitmap (pGCPriv->hdcMem,

+				    (BITMAPINFOHEADER *)pStipplePriv->pbmih,

+				    CBM_INIT,

+				    pStipplePriv->pbBits,

+				    (BITMAPINFO *)pStipplePriv->pbmih,

+				    DIB_RGB_COLORS);

+

+	  /* Create a memory DC to hold the stipple */

+	  hdcStipple = CreateCompatibleDC (pGCPriv->hdcMem);

+

+	  /* Select the stipple bitmap into the stipple DC */

+	  hbmpOrigStipple = SelectObject (hdcStipple, hBitmap);

+	  if (hbmpOrigStipple == NULL)

+	    FatalError ("winFillSpans () - DRAWABLE_PIXMAP - FillStippled - "

+			"SelectObject () failed on hbmpOrigStipple\n");

+

+	  /* Make a temporary copy of the foreground and background colors */

+   	  bg = pGC->bgPixel;

+   	  fg = pGC->fgPixel;

+

+	  /* Translate the depth-dependent colors to Win32 COLORREFs */

+	  TRANSLATE_COLOR (fg);

+	  TRANSLATE_COLOR (bg);

+	  SetTextColor (pGCPriv->hdcMem, fg);

+	  SetBkColor (pGCPriv->hdcMem, bg);

+

+	  while (iSpans--)

+	    {

+	      int width = pStipple->drawable.width;

+	      fullX1 = pPoints->x;

+	      fullY1 = pPoints->y;

+	      fullX2 = fullX1 + (int) *piWidths;

+	      pPoints++;

+	      piWidths++;

+	

+	      if (fullY1 < extentY1 || extentY2 <= fullY1)

+		continue;

+	

+	      if (fullX1 < extentX1)

+		fullX1 = extentX1;

+	      if (fullX2 > extentX2)

+		fullX2 = extentX2;

+	

+	      if (fullX1 >= fullX2)

+		continue;

+	

+	      for (iX = fullX1; iX < fullX2; iX += width)

+		{

+		  int xoffset;

+

+		  if ((iX + pStipple->drawable.width) > fullX2)

+		    width = fullX2 - iX;

+		  else

+		    width = pStipple->drawable.width;

+

+		  if (iX == fullX1)

+		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pStipple->drawable.width) - pStipple->drawable.width)) % pStipple->drawable.width;

+		  else

+		    xoffset = 0;

+

+		  if (xoffset + width > pStipple->drawable.width)

+		    width = pStipple->drawable.width - xoffset;

+

+		  BitBlt (pGCPriv->hdcMem,

+			  iX, fullY1,

+			  width, 1,

+			  hdcStipple,

+			  xoffset,

+			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pStipple->drawable.height) - pStipple->drawable.height)) % pStipple->drawable.height,

+			  g_copyROP[pGC->alu]);

+		}

+	    }

+

+	  /* Clear the stipple HDC */

+	  SelectObject (hdcStipple, hbmpOrigStipple);

+	  DeleteDC (hdcStipple);

+

+	  /* Delete the device dependent stipple bitmap */

+	  DeleteObject (hBitmap);

+

+	  break;

+	case FillStippled:

+

+	  pStipple = pGC->stipple;

+	  pStipplePriv = winGetPixmapPriv (pStipple);

+

+	  /* Create a device-dependent bitmap for the stipple */

+	  hBitmap = CreateDIBitmap (pGCPriv->hdcMem,

+				    (BITMAPINFOHEADER *)pStipplePriv->pbmih,

+				    CBM_INIT,

+				    pStipplePriv->pbBits,

+				    (BITMAPINFO *)pStipplePriv->pbmih,

+				    DIB_RGB_COLORS);

+

+	  /* Create a memory DC to hold the stipple */

+	  hdcStipple = CreateCompatibleDC (pGCPriv->hdcMem);

+

+	  /* Select the stipple bitmap into the stipple DC */

+	  hbmpOrigStipple = SelectObject (hdcStipple, hBitmap);

+	  if (hbmpOrigStipple == NULL)

+	    FatalError ("winFillSpans () - DRAWABLE_PIXMAP - FillStippled - "

+			"SelectObject () failed on hbmpOrigStipple\n");

+

+	  /* Make a temporary copy of the foreground and background colors */

+   	  bg = pGC->bgPixel;

+   	  fg = pGC->fgPixel;

+

+	  /* Translate the depth-dependent colors to Win32 COLORREFs */

+	  TRANSLATE_COLOR (fg);

+	  TRANSLATE_COLOR (bg);

+

+	  /* this is fudgy, we should only invert on the last one

+	   * We need to get the black/white pixels right in the

+	   * colormap. But yeah ! it's working.. 

+	   */

+	  if (pGC->bgPixel != -1 && pGC->fgPixel != -1) 

+	    {

+	      SetTextColor (pGCPriv->hdcMem, fg);

+	      SetBkColor (pGCPriv->hdcMem, bg);

+	      BitBlt (hdcStipple,

+		      0, 0,

+		      pStipple->drawable.width, pStipple->drawable.height,

+		      hdcStipple,

+		      0, 0,

+		      0x330008);

+	    } 

+	  else if (pGC->bgPixel == -1) 

+	    {

+	      SetTextColor (pGCPriv->hdcMem, fg);

+	      SetBkMode (pGCPriv->hdcMem, TRANSPARENT);

+	      BitBlt (hdcStipple,

+		      0, 0,

+		      pStipple->drawable.width, pStipple->drawable.height,

+		      hdcStipple,

+		      0, 0,

+		      0x330008);

+	    } 

+	  else if (pGC->fgPixel == -1) 

+	    {

+	      SetTextColor (pGCPriv->hdcMem, bg);

+	      SetBkMode (pGCPriv->hdcMem, TRANSPARENT);

+#if 0

+	      BitBlt (hdcStipple,

+		      0, 0,

+		      pStipple->drawable.width, pStipple->drawable.height,

+		      hdcStipple,

+		      0, 0,

+		      0x330008);

+#endif

+	    }

+

+	  while (iSpans--)

+	    {

+	      int width = pStipple->drawable.width;

+	      fullX1 = pPoints->x;

+	      fullY1 = pPoints->y;

+	      fullX2 = fullX1 + (int) *piWidths;

+	      pPoints++;

+	      piWidths++;

+	

+	      if (fullY1 < extentY1 || extentY2 <= fullY1)

+		continue;

+	

+	      if (fullX1 < extentX1)

+		fullX1 = extentX1;

+	      if (fullX2 > extentX2)

+		fullX2 = extentX2;

+	

+	      if (fullX1 >= fullX2)

+		continue;

+	

+	      for (iX = fullX1; iX < fullX2; iX += width)

+		{

+		  int xoffset;

+

+		  if ((iX + pStipple->drawable.width) > fullX2)

+		    width = fullX2 - iX;

+		  else

+		    width = pStipple->drawable.width;

+

+		  if (iX == fullX1)

+		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pStipple->drawable.width) - pStipple->drawable.width)) % pStipple->drawable.width;

+		  else

+		    xoffset = 0;

+

+		  if (xoffset + width > pStipple->drawable.width)

+		    width = pStipple->drawable.width - xoffset;

+

+		  BitBlt (pGCPriv->hdcMem,

+		          iX, fullY1,

+		          width, 1,

+		          hdcStipple,

+			  xoffset,

+			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pStipple->drawable.height) - pStipple->drawable.height)) % pStipple->drawable.height,

+			  g_copyROP[pGC->alu]);

+		}

+	    }

+

+	  /* Clear the stipple HDC */

+	  SelectObject (hdcStipple, hbmpOrigStipple);

+	  DeleteDC (hdcStipple);

+

+	  /* Delete the device dependent stipple bitmap */

+	  DeleteObject (hBitmap);

+

+	  /* Restore the background mode */

+	  SetBkMode (pGCPriv->hdcMem, OPAQUE);

+	  break;

+

+	case FillTiled:

+

+	  /* Get a pixmap pointer from the tile pointer, and fetch privates  */

+	  pTile = (PixmapPtr) pGC->tile.pixmap;

+	  pTilePriv = winGetPixmapPriv (pTile);

+

+	  /* Create a memory DC to hold the tile */

+	  hdcTile = CreateCompatibleDC (pGCPriv->hdcMem);

+

+	  /* Select the tile into a DC */

+	  hbmpOrig = SelectObject (hdcTile, pTilePriv->hBitmap);

+	  if (hbmpOrig == NULL)

+	    FatalError ("winFillSpans - DRAWABLE_PIXMAP - FillTiled - "

+			"SelectObject () failed on pTilePriv->hBitmap\n");

+

+	  while (iSpans--)

+	    {

+	      int width = pTile->drawable.width;

+	      fullX1 = pPoints->x;

+	      fullY1 = pPoints->y;

+	      fullX2 = fullX1 + (int) *piWidths;

+	      pPoints++;

+	      piWidths++;

+	

+	      if (fullY1 < extentY1 || extentY2 <= fullY1)

+		continue;

+	

+	      if (fullX1 < extentX1)

+		fullX1 = extentX1;

+	      if (fullX2 > extentX2)

+		fullX2 = extentX2;

+	

+	      if (fullX1 >= fullX2)

+		continue;

+	

+	      for (iX = fullX1; iX < fullX2; iX += width)

+	      	{

+		  int xoffset;

+

+		  if ((iX + pTile->drawable.width) > fullX2)

+		    width = fullX2 - iX;

+		  else

+		    width = pTile->drawable.width;

+

+		  if (iX == fullX1)

+		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pTile->drawable.width) - pTile->drawable.width)) % pTile->drawable.width;

+		  else

+		    xoffset = 0;

+

+		  if (xoffset + width > pTile->drawable.width)

+		    width = pTile->drawable.width - xoffset;

+

+		  BitBlt (pGCPriv->hdcMem,

+			  iX, fullY1,

+			  width, 1,

+			  hdcTile,

+			  xoffset,

+			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pTile->drawable.height) - pTile->drawable.height)) % pTile->drawable.height,

+			  g_copyROP[pGC->alu]);

+		}

+	    }

+

+	  /* Push the tile pixmap out of the memory HDC */

+	  SelectObject (hdcTile, hbmpOrig);

+

+	  /* Delete the tile */

+	  DeleteDC (hdcTile);

+	  break;

+

+	default:

+	  ErrorF ("winFillSpans - DRAWABLE_PIXMAP - Unknown fillStyle\n");

+	  break;

+	}

+

+      /* Reset clip region */

+      SelectClipRgn (pGCPriv->hdcMem, NULL);

+

+      /* Push the drawable pixmap out of the GC HDC */

+      SelectObject (pGCPriv->hdcMem, hbmpOrig);

+      break;

+      

+    case DRAWABLE_WINDOW:

+

+      SelectClipRgn (pGCPriv->hdc, combined);

+      DeleteObject (combined);

+      combined = NULL;

+

+      /* Branch on fill style */

+      switch (pGC->fillStyle)

+	{

+	case FillSolid:

+

+          ROP16 (pGCPriv->hdc, pGC->alu);

+

+	  if (pDrawable->depth == 1) 

+	    {

+	      if (pGC->fgPixel == 0)

+		hPenOrig = SelectObject (pGCPriv->hdc, 

+					 GetStockObject (BLACK_PEN));

+	      else

+		hPenOrig = SelectObject (pGCPriv->hdc,

+					 GetStockObject (WHITE_PEN));

+	    } 

+	  else 

+	    {

+	      fg = pGC->fgPixel;

+	      TRANSLATE_COLOR (fg);

+	      hPen = CreatePen (PS_SOLID, 0, fg);

+	      hPenOrig = SelectObject (pGCPriv->hdc, hPen);

+	    }

+

+	  while (iSpans--)

+	    {

+	      fullX1 = pPoints->x;

+	      fullY1 = pPoints->y;

+	      fullX2 = fullX1 + (int) *piWidths;

+	      pPoints++;

+	      piWidths++;

+	

+	      if (fullY1 < extentY1 || extentY2 <= fullY1)

+		continue;

+	

+	      if (fullX1 < extentX1)

+		fullX1 = extentX1;

+	      if (fullX2 > extentX2)

+		fullX2 = extentX2;

+	

+	      if (fullX1 >= fullX2)

+		continue;

+	

+	      MoveToEx (pGCPriv->hdc, fullX1, fullY1, NULL);

+	      LineTo (pGCPriv->hdc, fullX2, fullY1);

+	    }

+

+          SetROP2 (pGCPriv->hdc, R2_COPYPEN);

+

+	  /* Give back the Brush */

+	  SelectObject (pGCPriv->hdc, hPenOrig);

+

+	  if (pDrawable->depth != 1)

+	    DeleteObject (hPen);

+	  break;

+

+	case FillOpaqueStippled:

+

+	  pStipple = pGC->stipple;

+	  pStipplePriv = winGetPixmapPriv (pStipple);

+

+	  /* Create a device-dependent bitmap for the stipple */

+	  hBitmap = CreateDIBitmap (pGCPriv->hdc,

+				    (BITMAPINFOHEADER *)pStipplePriv->pbmih,

+				    CBM_INIT,

+				    pStipplePriv->pbBits,

+				    (BITMAPINFO *)pStipplePriv->pbmih,

+				    DIB_RGB_COLORS);

+

+	  /* Create a memory DC to hold the stipple */

+	  hdcStipple = CreateCompatibleDC (pGCPriv->hdc);

+

+	  /* Select the stipple bitmap into the stipple DC */

+	  hbmpOrigStipple = SelectObject (hdcStipple, hBitmap);

+	  if (hbmpOrigStipple == NULL)

+	    FatalError ("winFillSpans () - DRAWABLE_PIXMAP - FillStippled - "

+			"SelectObject () failed on hbmpOrigStipple\n");

+

+	  /* Make a temporary copy of the foreground and background colors */

+   	  bg = pGC->bgPixel;

+   	  fg = pGC->fgPixel;

+

+	  /* Translate the depth-dependent colors to Win32 COLORREFs */

+	  TRANSLATE_COLOR (fg);

+	  TRANSLATE_COLOR (bg);

+	  SetTextColor (pGCPriv->hdc, fg);

+	  SetBkColor (pGCPriv->hdc, bg);

+

+	  while (iSpans--)

+	    {

+	      int width = pStipple->drawable.width;

+	      fullX1 = pPoints->x;

+	      fullY1 = pPoints->y;

+	      fullX2 = fullX1 + (int) *piWidths;

+	      pPoints++;

+	      piWidths++;

+	

+	      if (fullY1 < extentY1 || extentY2 <= fullY1)

+		continue;

+	

+	      if (fullX1 < extentX1)

+		fullX1 = extentX1;

+	      if (fullX2 > extentX2)

+		fullX2 = extentX2;

+	

+	      if (fullX1 >= fullX2)

+		continue;

+	

+	      for (iX = fullX1; iX < fullX2; iX += width)

+		{

+		  int xoffset;

+

+		  if ((iX + pStipple->drawable.width) > fullX2)

+		    width = fullX2 - iX;

+		  else

+		    width = pStipple->drawable.width;

+

+		  if (iX == fullX1)

+		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pStipple->drawable.width) - pStipple->drawable.width)) % pStipple->drawable.width;

+		  else

+		    xoffset = 0;

+

+		  if (xoffset + width > pStipple->drawable.width)

+		    width = pStipple->drawable.width - xoffset;

+

+		  BitBlt (pGCPriv->hdc,

+			  iX, fullY1,

+			  width, 1,

+			  hdcStipple,

+			  xoffset,

+			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pStipple->drawable.height) - pStipple->drawable.height)) % pStipple->drawable.height,

+			  g_copyROP[pGC->alu]);

+		}

+	    }

+

+	  /* Clear the stipple HDC */

+	  SelectObject (hdcStipple, hbmpOrigStipple);

+	  DeleteDC (hdcStipple);

+

+	  /* Delete the device dependent stipple bitmap */

+	  DeleteObject (hBitmap);

+

+	  break;

+

+	case FillStippled:

+	  pStipple = pGC->stipple;

+	  pStipplePriv = winGetPixmapPriv (pStipple);

+

+	  /* Create a device-dependent bitmap for the stipple */

+	  hBitmap = CreateDIBitmap (pGCPriv->hdcMem,

+				    (BITMAPINFOHEADER *)pStipplePriv->pbmih,

+				    CBM_INIT,

+				    pStipplePriv->pbBits,

+				    (BITMAPINFO *)pStipplePriv->pbmih,

+				    DIB_RGB_COLORS);

+

+	  /* Create a memory DC to hold the stipple */

+	  hdcStipple = CreateCompatibleDC (pGCPriv->hdc);

+

+	  /* Select the stipple bitmap into the stipple DC */

+	  hbmpOrigStipple = SelectObject (hdcStipple, hBitmap);

+	  if (hbmpOrigStipple == NULL)

+	    FatalError ("winFillSpans () - DRAWABLE_PIXMAP - FillStippled - "

+			"SelectObject () failed on hbmpOrigStipple\n");

+

+	  /* Make a temporary copy of the foreground and background colors */

+   	  bg = pGC->bgPixel;

+   	  fg = pGC->fgPixel;

+

+	  /* Translate the depth-dependent colors to Win32 COLORREFs */

+	  TRANSLATE_COLOR (fg);

+	  TRANSLATE_COLOR (bg);

+

+	  /* this is fudgy, we should only invert on the last one

+	   * We need to get the black/white pixels right in the

+	   * colormap. But yeah ! it's working.. 

+	   */

+	  if (pGC->bgPixel != -1 && pGC->fgPixel != -1) 

+	    {

+	      SetTextColor (pGCPriv->hdc, fg);

+	      SetBkColor (pGCPriv->hdc, bg);

+	      BitBlt (hdcStipple,

+		      0, 0,

+		      pStipple->drawable.width, pStipple->drawable.height,

+		      hdcStipple,

+		      0,0,

+		      0x330008);

+	    } 

+	  else if (pGC->bgPixel == -1) 

+	    {

+	      SetTextColor (pGCPriv->hdc, fg);

+	      SetBkMode (pGCPriv->hdc, TRANSPARENT);

+	      BitBlt (hdcStipple,

+		      0, 0,

+		      pStipple->drawable.width, pStipple->drawable.height,

+		      hdcStipple,

+		      0,0,

+		      0x330008);

+	    } 

+	  else if (pGC->fgPixel == -1) 

+	    {

+	      SetTextColor (pGCPriv->hdc, bg);

+	      SetBkMode (pGCPriv->hdc, TRANSPARENT);

+#if 0

+	      BitBlt (hdcStipple,

+		      0, 0,

+		      pStipple->drawable.width, pStipple->drawable.height,

+		      hdcStipple,

+		      0, 0,

+		      0x330008);

+#endif

+	    }

+

+	  while (iSpans--)

+	    {

+ 	      int width = pStipple->drawable.width;

+	      fullX1 = pPoints->x;

+	      fullY1 = pPoints->y;

+	      fullX2 = fullX1 + (int) *piWidths;

+	      pPoints++;

+	      piWidths++;

+	

+	      if (fullY1 < extentY1 || extentY2 <= fullY1)

+		continue;

+	

+	      if (fullX1 < extentX1)

+		fullX1 = extentX1;

+	      if (fullX2 > extentX2)

+		fullX2 = extentX2;

+	

+	      if (fullX1 >= fullX2)

+		continue;

+	

+	      for (iX = fullX1; iX < fullX2; iX += width)

+		{

+		  int xoffset;

+

+		  if ((iX + pStipple->drawable.width) > fullX2)

+		    width = fullX2 - iX;

+		  else

+		    width = pStipple->drawable.width;

+

+		  if (iX == fullX1)

+		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pStipple->drawable.width) - pStipple->drawable.width)) % pStipple->drawable.width;

+		  else

+		    xoffset = 0;

+

+		  if (xoffset + width > pStipple->drawable.width)

+		    width = pStipple->drawable.width - xoffset;

+

+		  BitBlt (pGCPriv->hdc,

+			  iX, fullY1,

+			  width, 1,

+			  hdcStipple,

+			  xoffset,

+			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pStipple->drawable.height) - pStipple->drawable.height)) % pStipple->drawable.height,

+			  g_copyROP[pGC->alu]);

+		}

+	    }

+

+	  /* Clear the stipple HDC */

+	  SelectObject (hdcStipple, hbmpOrigStipple);

+	  DeleteDC (hdcStipple);

+

+	  /* Delete the device dependent stipple bitmap */

+	  DeleteObject (hBitmap);

+

+	  /* Restore the background mode */

+	  SetBkMode (pGCPriv->hdc, OPAQUE);	  

+	  break;

+

+	case FillTiled:

+

+	  /* Get a pixmap pointer from the tile pointer, and fetch privates  */

+	  pTile = (PixmapPtr) pGC->tile.pixmap;

+	  pTilePriv = winGetPixmapPriv (pTile);

+

+	  /* Select the tile into a DC */

+	  hbmpOrig = SelectObject (pGCPriv->hdcMem, pTilePriv->hBitmap);

+	  if (hbmpOrig == NULL)

+	    FatalError ("winFillSpans - DRAWABLE_WINDOW - FillTiled - "

+			"SelectObject () failed on pTilePriv->hBitmap\n");

+

+	  while (iSpans--)

+	    {

+	      int width = pTile->drawable.width;

+	      fullX1 = pPoints->x;

+	      fullY1 = pPoints->y;

+	      fullX2 = fullX1 + (int) *piWidths;

+	      pPoints++;

+	      piWidths++;

+	

+	      if (fullY1 < extentY1 || extentY2 <= fullY1)

+		continue;

+	

+	      if (fullX1 < extentX1)

+		fullX1 = extentX1;

+	      if (fullX2 > extentX2)

+		fullX2 = extentX2;

+	

+	      if (fullX1 >= fullX2)

+		continue;

+	

+	      for (iX = fullX1; iX < fullX2; iX += width)

+	      	{

+		  int xoffset;

+

+		  if ((iX + pTile->drawable.width) > fullX2)

+		    width = fullX2 - iX;

+		  else

+		    width = pTile->drawable.width;

+

+		  if (iX == fullX1)

+		    xoffset = (fullX1 - (pDrawable->x + (pGC->patOrg.x % pTile->drawable.width) - pTile->drawable.width)) % pTile->drawable.width;

+		  else

+		    xoffset = 0;

+

+		  if (xoffset + width > pTile->drawable.width)

+		    width = pTile->drawable.width - xoffset;

+

+		  BitBlt (pGCPriv->hdc,

+			  iX, fullY1,

+			  width, 1,

+			  pGCPriv->hdcMem,

+			  xoffset,

+			  (fullY1 - (pDrawable->y + (pGC->patOrg.y % pTile->drawable.height) - pTile->drawable.height)) % pTile->drawable.height,

+			  g_copyROP[pGC->alu]);

+		}

+	    }

+

+	  /* Push the tile pixmap out of the memory HDC */

+	  SelectObject (pGCPriv->hdcMem, hbmpOrig);

+	  break;

+

+	default:

+	  ErrorF ("winFillSpans - DRAWABLE_WINDOW - Unknown fillStyle\n");

+	  break;

+	}

+

+      /* Reset clip region */

+      SelectClipRgn (pGCPriv->hdc, NULL);

+      break;

+

+    case UNDRAWABLE_WINDOW:

+      /* UNDRAWABLE_WINDOW doesn't appear to get called when running xterm */

+      switch (pGC->fillStyle)

+	{

+	case FillSolid:

+	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - FillSolid - "

+		  "Unimplemented\n");

+	  break;

+

+	case FillStippled:

+	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - FillStippled - "

+		  "Unimplemented\n");

+	  break;

+

+	case FillTiled:

+	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - FillTiled - "

+		  "Unimplemented\n");

+	  break;

+

+	case FillOpaqueStippled:

+	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - OpaqueStippled - "

+		  "Unimplemented\n");

+	  break;

+

+	default:

+	  ErrorF ("winFillSpans - UNDRAWABLE_WINDOW - Unknown fillStyle\n");

+	  break;

+	}

+      break;

+

+    case DRAWABLE_BUFFER:

+      /* DRAWABLE_BUFFER seems to be undocumented. */

+      ErrorF ("winFillSpans - DRAWABLE_BUFFER - Unimplemented\n");

+      break;

+

+    default:

+      ErrorF ("winFillSpans - Unknown drawable type\n");

+      break;

+    }

+}

diff --git a/xorg-server/hw/xwin/wingc.c b/xorg-server/hw/xwin/wingc.c
index 61ba78a54..5f8b2905e 100644
--- a/xorg-server/hw/xwin/wingc.c
+++ b/xorg-server/hw/xwin/wingc.c
@@ -1,167 +1,167 @@
-/*
- *Copyright (C) 2001-2004 Harold L Hunt II All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL HAROLD L HUNT II BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of Harold L Hunt II
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from Harold L Hunt II.
- *
- * Authors:	Harold L Hunt II
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-
-void
-winPushPixels (GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDrawable, int dx, int dy, int xOrg, int yOrg);
-
-
-/*
- * Local prototypes
- */
-
-static void
-winValidateGCNativeGDI (GCPtr pGC,
-			unsigned long changes,
-			DrawablePtr pDrawable);
-
-static void
-winDestroyGCNativeGDI (GCPtr pGC);
-
-const GCFuncs winGCFuncs = {
-  winValidateGCNativeGDI,
-  miChangeGC,
-  miCopyGC,
-  winDestroyGCNativeGDI,
-  miChangeClip,
-  miDestroyClip,
-  miCopyClip,
-};
-
-/* Drawing Primitives */
-const GCOps winGCOps = {
-  winFillSpansNativeGDI,
-  winSetSpansNativeGDI,
-  miPutImage,
-  miCopyArea,
-  miCopyPlane,
-  miPolyPoint,
-  winPolyLineNativeGDI,
-  miPolySegment,
-  miPolyRectangle,
-  miPolyArc,
-  miFillPolygon,
-  miPolyFillRect,
-  miPolyFillArc,
-  miPolyText8,
-  miPolyText16,
-  miImageText8,
-  miImageText16,
-  miImageGlyphBlt,
-  miPolyGlyphBlt,
-  miPushPixels,
-};
-
-
-/* See Porting Layer Definition - p. 45 */
-/* See mfb/mfbgc.c - mfbCreateGC() */
-/* See Strategies for Porting - pp. 15, 16 */
-Bool
-winCreateGCNativeGDI (GCPtr pGC)
-{
-  winPrivGCPtr		pGCPriv = NULL;
-  winPrivScreenPtr	pScreenPriv = NULL;
-
-  winDebug ("winCreateGCNativeGDI - depth: %d\n",
-	  pGC->depth);
-
-  pGC->clientClip = NULL;
-  pGC->clientClipType = CT_NONE;
-  pGC->freeCompClip = FALSE;
-  pGC->pCompositeClip = 0;
-
-  pGC->ops = (GCOps *) &winGCOps;
-  pGC->funcs = (GCFuncs *) &winGCFuncs;
-
-  /* We want all coordinates passed to spans functions to be screen relative */
-  pGC->miTranslate = TRUE;
-
-  /* Allocate privates for this GC */
-  pGCPriv = winGetGCPriv (pGC);
-  if (pGCPriv == NULL)
-    {
-      ErrorF ("winCreateGCNativeGDI () - Privates pointer was NULL\n");
-      return FALSE;
-    }
-
-  /* Create a new screen DC for the display window */
-  pScreenPriv = winGetScreenPriv (pGC->pScreen);
-  pGCPriv->hdc = GetDC (pScreenPriv->hwndScreen);
-
-  /* Allocate a memory DC for the GC */
-  pGCPriv->hdcMem = CreateCompatibleDC (pGCPriv->hdc);
-
-  return TRUE;
-}
-
-static void
-winValidateGCNativeGDI (GCPtr pGC,
-			unsigned long ulChanges,
-			DrawablePtr pDrawable)
-{
-  if ((ulChanges & (GCClipXOrigin | GCClipYOrigin | GCClipMask | GCSubwindowMode)) 
-      || (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS)))
-  {
-    miComputeCompositeClip (pGC, pDrawable);
-  }
-}
-
-
-/* See Porting Layer Definition - p. 46 */
-static void
-winDestroyGCNativeGDI (GCPtr pGC)
-{
-  winGCPriv(pGC);
-  winScreenPriv(pGC->pScreen);
-
-  if (pGC->freeCompClip)
-	REGION_DESTROY (pGC->pScreen, pGC->pCompositeClip);
-
-  /* Free the memory DC */
-  if (pGCPriv->hdcMem != NULL)
-    {
-      DeleteDC (pGCPriv->hdcMem);
-      pGCPriv->hdcMem = NULL;
-    }
-
-  /* Release the screen DC for the display window */
-  if (pGCPriv->hdc != NULL)
-    {
-      ReleaseDC (pScreenPriv->hwndScreen, pGCPriv->hdc);
-      pGCPriv->hdc = NULL;
-    }
-
-  /* Invalidate the GC privates pointer */
-  winSetGCPriv (pGC, NULL);
-}
+/*

+ *Copyright (C) 2001-2004 Harold L Hunt II All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL HAROLD L HUNT II BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of Harold L Hunt II

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from Harold L Hunt II.

+ *

+ * Authors:	Harold L Hunt II

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+

+void

+winPushPixels (GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDrawable, int dx, int dy, int xOrg, int yOrg);

+

+

+/*

+ * Local prototypes

+ */

+

+static void

+winValidateGCNativeGDI (GCPtr pGC,

+			unsigned long changes,

+			DrawablePtr pDrawable);

+

+static void

+winDestroyGCNativeGDI (GCPtr pGC);

+

+const GCFuncs winGCFuncs = {

+  winValidateGCNativeGDI,

+  miChangeGC,

+  miCopyGC,

+  winDestroyGCNativeGDI,

+  miChangeClip,

+  miDestroyClip,

+  miCopyClip,

+};

+

+/* Drawing Primitives */

+const GCOps winGCOps = {

+  winFillSpansNativeGDI,

+  winSetSpansNativeGDI,

+  miPutImage,

+  miCopyArea,

+  miCopyPlane,

+  miPolyPoint,

+  winPolyLineNativeGDI,

+  miPolySegment,

+  miPolyRectangle,

+  miPolyArc,

+  miFillPolygon,

+  miPolyFillRect,

+  miPolyFillArc,

+  miPolyText8,

+  miPolyText16,

+  miImageText8,

+  miImageText16,

+  miImageGlyphBlt,

+  miPolyGlyphBlt,

+  miPushPixels,

+};

+

+

+/* See Porting Layer Definition - p. 45 */

+/* See mfb/mfbgc.c - mfbCreateGC() */

+/* See Strategies for Porting - pp. 15, 16 */

+Bool

+winCreateGCNativeGDI (GCPtr pGC)

+{

+  winPrivGCPtr		pGCPriv = NULL;

+  winPrivScreenPtr	pScreenPriv = NULL;

+

+  winDebug ("winCreateGCNativeGDI - depth: %d\n",

+	  pGC->depth);

+

+  pGC->clientClip = NULL;

+  pGC->clientClipType = CT_NONE;

+  pGC->freeCompClip = FALSE;

+  pGC->pCompositeClip = 0;

+

+  pGC->ops = (GCOps *) &winGCOps;

+  pGC->funcs = (GCFuncs *) &winGCFuncs;

+

+  /* We want all coordinates passed to spans functions to be screen relative */

+  pGC->miTranslate = TRUE;

+

+  /* Allocate privates for this GC */

+  pGCPriv = winGetGCPriv (pGC);

+  if (pGCPriv == NULL)

+    {

+      ErrorF ("winCreateGCNativeGDI () - Privates pointer was NULL\n");

+      return FALSE;

+    }

+

+  /* Create a new screen DC for the display window */

+  pScreenPriv = winGetScreenPriv (pGC->pScreen);

+  pGCPriv->hdc = GetDC (pScreenPriv->hwndScreen);

+

+  /* Allocate a memory DC for the GC */

+  pGCPriv->hdcMem = CreateCompatibleDC (pGCPriv->hdc);

+

+  return TRUE;

+}

+

+static void

+winValidateGCNativeGDI (GCPtr pGC,

+			unsigned long ulChanges,

+			DrawablePtr pDrawable)

+{

+  if ((ulChanges & (GCClipXOrigin | GCClipYOrigin | GCClipMask | GCSubwindowMode)) 

+      || (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS)))

+  {

+    miComputeCompositeClip (pGC, pDrawable);

+  }

+}

+

+

+/* See Porting Layer Definition - p. 46 */

+static void

+winDestroyGCNativeGDI (GCPtr pGC)

+{

+  winGCPriv(pGC);

+  winScreenPriv(pGC->pScreen);

+

+  if (pGC->freeCompClip)

+	RegionDestroy(pGC->pCompositeClip);

+

+  /* Free the memory DC */

+  if (pGCPriv->hdcMem != NULL)

+    {

+      DeleteDC (pGCPriv->hdcMem);

+      pGCPriv->hdcMem = NULL;

+    }

+

+  /* Release the screen DC for the display window */

+  if (pGCPriv->hdc != NULL)

+    {

+      ReleaseDC (pScreenPriv->hwndScreen, pGCPriv->hdc);

+      pGCPriv->hdc = NULL;

+    }

+

+  /* Invalidate the GC privates pointer */

+  winSetGCPriv (pGC, NULL);

+}

diff --git a/xorg-server/hw/xwin/winglobals.c b/xorg-server/hw/xwin/winglobals.c
index 09b75031e..b698270b7 100644
--- a/xorg-server/hw/xwin/winglobals.c
+++ b/xorg-server/hw/xwin/winglobals.c
@@ -1,144 +1,146 @@
-/*
- *Copyright (C) 2003-2004 Harold L Hunt II All Rights Reserved.
- *Copyright (C) Colin Harrison 2005-2008
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL HAROLD L HUNT II BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of Harold L Hunt II
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from Harold L Hunt II.
- *
- * Authors:	Harold L Hunt II
- *              Colin Harrison
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-
-
-/*
- * General global variables
- */
-
-int		g_iNumScreens = 0;
-winScreenInfo * g_ScreenInfo = 0;
-#ifdef HAS_DEVWINDOWS
-int		g_fdMessageQueue = WIN_FD_INVALID;
-#endif
-static int	g_iScreenPrivateKeyIndex;
-DevPrivateKey	g_iScreenPrivateKey = &g_iScreenPrivateKeyIndex;
-static int	g_iCmapPrivateKeyIndex;
-DevPrivateKey	g_iCmapPrivateKey = &g_iCmapPrivateKeyIndex;
-static int	g_iGCPrivateKeyIndex;
-DevPrivateKey	g_iGCPrivateKey = &g_iGCPrivateKeyIndex;
-static int	g_iPixmapPrivateKeyIndex;
-DevPrivateKey	g_iPixmapPrivateKey = &g_iPixmapPrivateKeyIndex;
-static int	g_iWindowPrivateKeyIndex;
-DevPrivateKey	g_iWindowPrivateKey = &g_iWindowPrivateKeyIndex;
-unsigned long	g_ulServerGeneration = 0;
-DWORD		g_dwEnginesSupported = 0;
-HINSTANCE	g_hInstance = 0;
-HWND		g_hDlgDepthChange = NULL;
-HWND		g_hDlgExit = NULL;
-HWND		g_hDlgAbout = NULL;
-const char *	g_pszQueryHost = NULL;
-Bool		g_fXdmcpEnabled = FALSE;
-Bool           g_fAuthEnabled = FALSE;
-HICON		g_hIconX = NULL;
-HICON		g_hSmallIconX = NULL;
-#ifndef RELOCATE_PROJECTROOT
-const char *	g_pszLogFile = DEFAULT_LOGDIR "/XWin.%s.log";
-#else
-const char *	g_pszLogFile = "XWin.log";
-Bool		g_fLogFileChanged = FALSE;
-#endif
-int		g_iLogVerbose = 2;
-Bool		g_fLogInited = FALSE;
-char *		g_pszCommandLine = NULL;
-Bool		g_fSilentFatalError = FALSE;
-DWORD		g_dwCurrentThreadID = 0;
-Bool		g_fKeyboardHookLL = FALSE;
-HHOOK		g_hhookKeyboardLL = NULL;
-HWND		g_hwndKeyboardFocus = NULL;
-Bool		g_fNoHelpMessageBox = FALSE;
-Bool		g_fSoftwareCursor = FALSE;
-Bool		g_fSilentDupError = FALSE;
-Bool		g_fNativeGl = FALSE;
-
-/*
- * Global variables for dynamically loaded libraries and
- * their function pointers
- */
-
-HMODULE		g_hmodDirectDraw = NULL;
-FARPROC		g_fpDirectDrawCreate = NULL;
-FARPROC		g_fpDirectDrawCreateClipper = NULL;
-
-HMODULE		g_hmodCommonControls = NULL;
-FARPROC		g_fpTrackMouseEvent = (FARPROC) (void (*)(void))NoopDDA;
-
-
-#ifdef XWIN_CLIPBOARD
-/*
- * Wrapped DIX functions
- */
-winDispatchProcPtr	winProcEstablishConnectionOrig = NULL;
-winDispatchProcPtr	winProcQueryTreeOrig = NULL;
-winDispatchProcPtr	winProcSetSelectionOwnerOrig = NULL;
-
-
-/*
- * Clipboard variables
- */
-
-Bool			g_fUnicodeClipboard = TRUE;
-Bool			g_fClipboard = TRUE;
-Bool			g_fClipboardLaunched = FALSE;
-Bool			g_fClipboardStarted = FALSE;
-pthread_t		g_ptClipboardProc;
-HWND			g_hwndClipboard = NULL;
-void			*g_pClipboardDisplay = NULL;
-Window			g_iClipboardWindow = None;
-Atom			g_atomLastOwnedSelection = None;
-#endif
-
-
-/*
- * Re-initialize global variables that are invalidated
- * by a server reset.
- */
-
-void
-winInitializeGlobals (void)
-{
-  g_dwCurrentThreadID = GetCurrentThreadId ();
-  g_hwndKeyboardFocus = NULL;
-#ifdef XWIN_CLIPBOARD
-  g_fClipboardLaunched = FALSE;
-  g_fClipboardStarted = FALSE;
-  g_iClipboardWindow = None;
-  g_pClipboardDisplay = NULL;
-  g_atomLastOwnedSelection = None;
-  g_hwndClipboard = NULL;
-#endif
-}
+/*

+ *Copyright (C) 2003-2004 Harold L Hunt II All Rights Reserved.

+ *Copyright (C) Colin Harrison 2005-2008

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL HAROLD L HUNT II BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of Harold L Hunt II

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from Harold L Hunt II.

+ *

+ * Authors:	Harold L Hunt II

+ *              Colin Harrison

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+

+

+/*

+ * General global variables

+ */

+

+int		g_iNumScreens = 0;

+winScreenInfo * g_ScreenInfo = 0;

+#ifdef HAS_DEVWINDOWS

+int		g_fdMessageQueue = WIN_FD_INVALID;

+#endif

+DevPrivateKeyRec g_iScreenPrivateKeyRec;

+DevPrivateKeyRec g_iCmapPrivateKeyRec;

+DevPrivateKeyRec g_iGCPrivateKeyRec;

+DevPrivateKeyRec g_iPixmapPrivateKeyRec;

+DevPrivateKeyRec g_iWindowPrivateKeyRec;

+unsigned long	g_ulServerGeneration = 0;

+DWORD		g_dwEnginesSupported = 0;

+HINSTANCE	g_hInstance = 0;

+HWND		g_hDlgDepthChange = NULL;

+HWND		g_hDlgExit = NULL;

+HWND		g_hDlgAbout = NULL;

+const char *	g_pszQueryHost = NULL;

+Bool		g_fXdmcpEnabled = FALSE;

+Bool           g_fAuthEnabled = FALSE;

+HICON		g_hIconX = NULL;

+HICON		g_hSmallIconX = NULL;

+#ifndef RELOCATE_PROJECTROOT

+const char *	g_pszLogFile = DEFAULT_LOGDIR "/XWin.%s.log";

+#else

+const char *	g_pszLogFile = "XWin.log";

+Bool		g_fLogFileChanged = FALSE;

+#endif

+int		g_iLogVerbose = 2;

+Bool		g_fLogInited = FALSE;

+char *		g_pszCommandLine = NULL;

+Bool		g_fSilentFatalError = FALSE;

+DWORD		g_dwCurrentThreadID = 0;

+Bool		g_fKeyboardHookLL = FALSE;

+HHOOK		g_hhookKeyboardLL = NULL;

+HWND		g_hwndKeyboardFocus = NULL;

+Bool		g_fNoHelpMessageBox = FALSE;

+Bool		g_fSoftwareCursor = FALSE;

+Bool		g_fSilentDupError = FALSE;

+Bool		g_fNativeGl = FALSE;

+

+/*

+ * Global variables for dynamically loaded libraries and

+ * their function pointers

+ */

+

+HMODULE		g_hmodDirectDraw = NULL;

+FARPROC		g_fpDirectDrawCreate = NULL;

+FARPROC		g_fpDirectDrawCreateClipper = NULL;

+

+HMODULE		g_hmodCommonControls = NULL;

+FARPROC		g_fpTrackMouseEvent = (FARPROC) (void (*)(void))NoopDDA;

+

+

+#ifdef XWIN_CLIPBOARD

+/*

+ * Wrapped DIX functions

+ */

+winDispatchProcPtr	winProcEstablishConnectionOrig = NULL;

+winDispatchProcPtr	winProcQueryTreeOrig = NULL;

+winDispatchProcPtr	winProcSetSelectionOwnerOrig = NULL;

+

+

+/*

+ * Clipboard variables

+ */

+

+Bool			g_fUnicodeClipboard = TRUE;

+Bool			g_fClipboard = TRUE;

+Bool			g_fClipboardLaunched = FALSE;

+Bool			g_fClipboardStarted = FALSE;

+pthread_t		g_ptClipboardProc;

+HWND			g_hwndClipboard = NULL;

+void			*g_pClipboardDisplay = NULL;

+Window			g_iClipboardWindow = None;

+Atom			g_atomLastOwnedSelection = None;

+#endif

+

+

+/*

+ * Re-initialize global variables that are invalidated

+ * by a server reset.

+ */

+

+void

+winInitializeGlobals (void)

+{

+  if (!dixRegisterPrivateKey(&g_iScreenPrivateKeyRec, PRIVATE_SCREEN, 0) ||

+      !dixRegisterPrivateKey(&g_iCmapPrivateKeyRec, PRIVATE_COLORMAP, 0) ||

+      !dixRegisterPrivateKey(&g_iGCPrivateKeyRec, PRIVATE_GC, 0) ||

+      !dixRegisterPrivateKey(&g_iPixmapPrivateKeyRec, PRIVATE_PIXMAP, 0) ||

+      !dixRegisterPrivateKey(&g_iWindowPrivateKeyRec, PRIVATE_WINDOW, 0)) {

+      FatalError("cannot register private key");

+  }

+  g_dwCurrentThreadID = GetCurrentThreadId ();

+  g_hwndKeyboardFocus = NULL;

+#ifdef XWIN_CLIPBOARD

+  g_fClipboardLaunched = FALSE;

+  g_fClipboardStarted = FALSE;

+  g_iClipboardWindow = None;

+  g_pClipboardDisplay = NULL;

+  g_atomLastOwnedSelection = None;

+  g_hwndClipboard = NULL;

+#endif

+}

diff --git a/xorg-server/hw/xwin/winkeybd.c b/xorg-server/hw/xwin/winkeybd.c
index bbfeba553..e69edf7c0 100644
--- a/xorg-server/hw/xwin/winkeybd.c
+++ b/xorg-server/hw/xwin/winkeybd.c
@@ -1,529 +1,529 @@
-/*
- *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of the XFree86 Project
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from the XFree86 Project.
- *
- * Authors:	Dakshinamurthy Karra
- *		Suhaib M Siddiqi
- *		Peter Busch
- *		Harold L Hunt II
- */
-
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-#include "winkeybd.h"
-#include "winconfig.h"
-#include "winmsg.h"
-
-#include "xkbsrv.h"
-
-static Bool g_winKeyState[NUM_KEYCODES];
-
-/*
- * Local prototypes
- */
-
-static void
-winKeybdBell (int iPercent, DeviceIntPtr pDeviceInt,
-	      pointer pCtrl, int iClass);
-
-static void
-winKeybdCtrl (DeviceIntPtr pDevice, KeybdCtrl *pCtrl);
-
-
-/* 
- * Translate a Windows WM_[SYS]KEY(UP/DOWN) message
- * into an ASCII scan code.
- *
- * We do this ourselves, rather than letting Windows handle it,
- * because Windows tends to munge the handling of special keys,
- * like AltGr on European keyboards.
- */
-
-void
-winTranslateKey (WPARAM wParam, LPARAM lParam, int *piScanCode)
-{
-  int		iKeyFixup = g_iKeyMap[wParam * WIN_KEYMAP_COLS + 1];
-  int		iKeyFixupEx = g_iKeyMap[wParam * WIN_KEYMAP_COLS + 2];
-  int		iParam = HIWORD (lParam);
-  int		iParamScanCode = LOBYTE (iParam);
-
-/* WM_ key messages faked by Vista speech recognition (WSR) don't have a
- * scan code.
- *
- * Vocola 3 (Rick Mohr's supplement to WSR) uses
- * System.Windows.Forms.SendKeys.SendWait(), which appears always to give a
- * scan code of 1
- */
-  if (iParamScanCode <= 1)
-    {
-      if (VK_PRIOR <= wParam && wParam <= VK_DOWN)
-        /* Trigger special case table to translate to extended
-         * keycode, otherwise if num_lock is on, we can get keypad
-         * numbers instead of navigation keys. */
-        iParam |= KF_EXTENDED;
-      else
-        iParamScanCode = MapVirtualKeyEx(wParam,
-                         /*MAPVK_VK_TO_VSC*/0,
-                         GetKeyboardLayout(0));
-    }
-
-  /* Branch on special extended, special non-extended, or normal key */
-  if ((iParam & KF_EXTENDED) && iKeyFixupEx)
-    *piScanCode = iKeyFixupEx;
-  else if (iKeyFixup)
-    *piScanCode = iKeyFixup;
-  else if (wParam == 0 && iParamScanCode == 0x70)
-    *piScanCode = KEY_HKTG;
-  else
-    switch (iParamScanCode)
-    {
-      case 0x70:
-        *piScanCode = KEY_HKTG;
-        break;
-      case 0x73:
-        *piScanCode = KEY_BSlash2;
-        break;
-      default: 
-        *piScanCode = iParamScanCode;
-        break;
-    }
-}
-
-/* Ring the keyboard bell (system speaker on PCs) */
-static void
-winKeybdBell (int iPercent, DeviceIntPtr pDeviceInt,
-	      pointer pCtrl, int iClass)
-{
-  /*
-   * We can't use Beep () here because it uses the PC speaker
-   * on NT/2000.  MessageBeep (MB_OK) will play the default system
-   * sound on systems with a sound card or it will beep the PC speaker
-   * on systems that do not have a sound card.
-   */
-  MessageBeep (MB_OK);
-}
-
-
-/* Change some keyboard configuration parameters */
-static void
-winKeybdCtrl (DeviceIntPtr pDevice, KeybdCtrl *pCtrl)
-{
-}
-
-
-/* 
- * See Porting Layer Definition - p. 18
- * winKeybdProc is known as a DeviceProc.
- */
-
-int
-winKeybdProc (DeviceIntPtr pDeviceInt, int iState)
-{
-  DevicePtr		pDevice = (DevicePtr) pDeviceInt;
-  XkbSrvInfoPtr       xkbi;
-  XkbControlsPtr      ctrl;
-
-  switch (iState)
-    {
-    case DEVICE_INIT:
-      winConfigKeyboard (pDeviceInt);
-
-      /* FIXME: Maybe we should use winGetKbdLeds () here? */
-      defaultKeyboardControl.leds = g_winInfo.keyboard.leds;
-
-      winDebug("Rules = \"%s\" Model = \"%s\" Layout = \"%s\""
-               " Variant = \"%s\" Options = \"%s\"\n",
-               g_winInfo.xkb.rules ? g_winInfo.xkb.rules : "none",
-               g_winInfo.xkb.model ? g_winInfo.xkb.model : "none",
-               g_winInfo.xkb.layout ? g_winInfo.xkb.layout : "none",
-               g_winInfo.xkb.variant ? g_winInfo.xkb.variant : "none",
-               g_winInfo.xkb.options ? g_winInfo.xkb.options : "none");
-
-      InitKeyboardDeviceStruct (pDeviceInt,
-                                &g_winInfo.xkb,
-                                winKeybdBell,
-                                winKeybdCtrl);
-
-      xkbi = pDeviceInt->key->xkbInfo;
-      if ((xkbi != NULL) && (xkbi->desc != NULL))
-        {
-          ctrl = xkbi->desc->ctrls;
-          ctrl->repeat_delay = g_winInfo.keyboard.delay;
-          ctrl->repeat_interval = 1000/g_winInfo.keyboard.rate;
-        }
-      else
-        {
-          winDebug ("winKeybdProc - Error initializing keyboard AutoRepeat\n");
-        }
-
-	  XkbSetExtension(pDeviceInt, ProcessKeyboardEvent);
-      break;
-      
-    case DEVICE_ON: 
-      pDevice->on = TRUE;
-
-      // immediately copy the state of this keyboard device to the VCK
-      // (which otherwise happens lazily after the first keypress)
-      CopyKeyClass(pDeviceInt, inputInfo.keyboard);
-      break;
-
-    case DEVICE_CLOSE:
-    case DEVICE_OFF: 
-      pDevice->on = FALSE;
-      break;
-    }
-
-  return Success;
-}
-
-
-/*
- * Detect current mode key states upon server startup.
- *
- * Simulate a press and release of any key that is currently
- * toggled.
- */
-
-void
-winInitializeModeKeyStates (void)
-{
-  /* Restore NumLock */
-  if (GetKeyState (VK_NUMLOCK) & 0x0001)
-    {
-      winSendKeyEvent (KEY_NumLock, TRUE);
-      winSendKeyEvent (KEY_NumLock, FALSE);
-    }
-
-  /* Restore CapsLock */
-  if (GetKeyState (VK_CAPITAL) & 0x0001)
-    {
-      winSendKeyEvent (KEY_CapsLock, TRUE);
-      winSendKeyEvent (KEY_CapsLock, FALSE);
-    }
-
-  /* Restore ScrollLock */
-  if (GetKeyState (VK_SCROLL) & 0x0001)
-    {
-      winSendKeyEvent (KEY_ScrollLock, TRUE);
-      winSendKeyEvent (KEY_ScrollLock, FALSE);
-    }
-
-  /* Restore KanaLock */
-  if (GetKeyState (VK_KANA) & 0x0001)
-    {
-      winSendKeyEvent (KEY_HKTG, TRUE);
-      winSendKeyEvent (KEY_HKTG, FALSE);
-    }
-}
-
-
-/*
- * Upon regaining the keyboard focus we must
- * resynchronize our internal mode key states
- * with the actual state of the keys.
- */
-
-void
-winRestoreModeKeyStates (void)
-{
-  DWORD			dwKeyState;
-  BOOL			processEvents = TRUE;
-  unsigned short	internalKeyStates;
-
-  /* X server is being initialized */
-  if (!inputInfo.keyboard)
-    return;
-
-  /* Only process events if the rootwindow is mapped. The keyboard events
-   * will cause segfaults otherwise */
-  if (WindowTable && WindowTable[0] && WindowTable[0]->mapped == FALSE)
-    processEvents = FALSE;    
-  
-  /* Force to process all pending events in the mi event queue */
-  if (processEvents)
-    mieqProcessInputEvents ();
-  
-  /* Read the mode key states of our X server */
-  /* (stored in the virtual core keyboard) */
-  internalKeyStates = XkbStateFieldFromRec(&inputInfo.keyboard->key->xkbInfo->state);
-  winDebug("winRestoreModeKeyStates: state %d\n", internalKeyStates);
-
-  /* 
-   * NOTE: The C XOR operator, ^, will not work here because it is
-   * a bitwise operator, not a logical operator.  C does not
-   * have a logical XOR operator, so we use a macro instead.
-   */
-
-  /* Has the key state changed? */
-  dwKeyState = GetKeyState (VK_NUMLOCK) & 0x0001;
-  if (WIN_XOR (internalKeyStates & NumLockMask, dwKeyState))
-    {
-      winSendKeyEvent (KEY_NumLock, TRUE);
-      winSendKeyEvent (KEY_NumLock, FALSE);
-    }
-
-  /* Has the key state changed? */
-  dwKeyState = GetKeyState (VK_CAPITAL) & 0x0001;
-  if (WIN_XOR (internalKeyStates & LockMask, dwKeyState))
-    {
-      winSendKeyEvent (KEY_CapsLock, TRUE);
-      winSendKeyEvent (KEY_CapsLock, FALSE);
-    }
-
-  /* Has the key state changed? */
-  dwKeyState = GetKeyState (VK_SCROLL) & 0x0001;
-  if (WIN_XOR (internalKeyStates & ScrollLockMask, dwKeyState))
-    {
-      winSendKeyEvent (KEY_ScrollLock, TRUE);
-      winSendKeyEvent (KEY_ScrollLock, FALSE);
-    }
-
-  /* Has the key state changed? */
-  dwKeyState = GetKeyState (VK_KANA) & 0x0001;
-  if (WIN_XOR (internalKeyStates & KanaMask, dwKeyState))
-    {
-      winSendKeyEvent (KEY_HKTG, TRUE);
-      winSendKeyEvent (KEY_HKTG, FALSE);
-    }
-}
-
-
-/*
- * Look for the lovely fake Control_L press/release generated by Windows
- * when AltGr is pressed/released on a non-U.S. keyboard.
- */
-
-Bool
-winIsFakeCtrl_L (UINT message, WPARAM wParam, LPARAM lParam)
-{
-  MSG		msgNext;
-  LONG		lTime;
-  Bool		fReturn;
-
-  /*
-   * Fake Ctrl_L presses will be followed by an Alt_R keypress
-   * with the same timestamp as the Ctrl_L press.
-   */
-  if ((message == WM_KEYDOWN || message == WM_SYSKEYDOWN)
-      && wParam == VK_CONTROL
-      && (HIWORD (lParam) & KF_EXTENDED) == 0)
-    {
-      /* Got a Ctrl_L press */
-
-      /* Get time of current message */
-      lTime = GetMessageTime ();
-
-      /* Look for fake Ctrl_L preceeding an Alt_R press. */
-      fReturn = PeekMessage (&msgNext, NULL,
-			     WM_KEYDOWN, WM_SYSKEYDOWN,
-			     PM_NOREMOVE);
-
-      /*
-       * Try again if the first call fails.
-       * NOTE: This usually happens when TweakUI is enabled.
-       */
-      if (!fReturn)
-	{
-	  /* Voodoo to make sure that the Alt_R message has posted */
-	  Sleep (0);
-
-	  /* Look for fake Ctrl_L preceeding an Alt_R press. */
-	  fReturn = PeekMessage (&msgNext, NULL,
-				 WM_KEYDOWN, WM_SYSKEYDOWN,
-				 PM_NOREMOVE);
-	}
-      if (msgNext.message != WM_KEYDOWN && msgNext.message != WM_SYSKEYDOWN)
-          fReturn = 0;
-
-      /* Is next press an Alt_R with the same timestamp? */
-      if (fReturn && msgNext.wParam == VK_MENU
-	  && msgNext.time == lTime
-	  && (HIWORD (msgNext.lParam) & KF_EXTENDED))
-	{
-	  /* 
-	   * Next key press is Alt_R with same timestamp as current
-	   * Ctrl_L message.  Therefore, this Ctrl_L press is a fake
-	   * event, so discard it.
-	   */
-	  return TRUE;
-	}
-    }
-
-  /* 
-   * Fake Ctrl_L releases will be followed by an Alt_R release
-   * with the same timestamp as the Ctrl_L release.
-   */
-  if ((message == WM_KEYUP || message == WM_SYSKEYUP)
-      && wParam == VK_CONTROL
-      && (HIWORD (lParam) & KF_EXTENDED) == 0)
-    {
-      /* Got a Ctrl_L release */
-
-      /* Get time of current message */
-      lTime = GetMessageTime ();
-
-      /* Look for fake Ctrl_L release preceeding an Alt_R release. */
-      fReturn = PeekMessage (&msgNext, NULL,
-			     WM_KEYUP, WM_SYSKEYUP, 
-			     PM_NOREMOVE);
-
-      /*
-       * Try again if the first call fails.
-       * NOTE: This usually happens when TweakUI is enabled.
-       */
-      if (!fReturn)
-	{
-	  /* Voodoo to make sure that the Alt_R message has posted */
-	  Sleep (0);
-
-	  /* Look for fake Ctrl_L release preceeding an Alt_R release. */
-	  fReturn = PeekMessage (&msgNext, NULL,
-				 WM_KEYUP, WM_SYSKEYUP, 
-				 PM_NOREMOVE);
-	}
-
-      if (msgNext.message != WM_KEYUP && msgNext.message != WM_SYSKEYUP)
-          fReturn = 0;
-      
-      /* Is next press an Alt_R with the same timestamp? */
-      if (fReturn
-	  && (msgNext.message == WM_KEYUP
-	      || msgNext.message == WM_SYSKEYUP)
-	  && msgNext.wParam == VK_MENU
-	  && msgNext.time == lTime
-	  && (HIWORD (msgNext.lParam) & KF_EXTENDED))
-	{
-	  /*
-	   * Next key release is Alt_R with same timestamp as current
-	   * Ctrl_L message. Therefore, this Ctrl_L release is a fake
-	   * event, so discard it.
-	   */
-	  return TRUE;
-	}
-    }
-  
-  /* Not a fake control left press/release */
-  return FALSE;
-}
-
-
-/*
- * Lift any modifier keys that are pressed
- */
-
-void
-winKeybdReleaseKeys (void)
-{
-  int				i;
-
-#ifdef HAS_DEVWINDOWS
-  /* Verify that the mi input system has been initialized */
-  if (g_fdMessageQueue == WIN_FD_INVALID)
-    return;
-#endif
-
-  /* Loop through all keys */
-  for (i = 0; i < NUM_KEYCODES; ++i)
-    {
-      /* Pop key if pressed */
-      if (g_winKeyState[i])
-	winSendKeyEvent (i, FALSE);
-
-      /* Reset pressed flag for keys */
-      g_winKeyState[i] = FALSE;
-    }
-}
-
-
-/*
- * Take a raw X key code and send an up or down event for it.
- *
- * Thanks to VNC for inspiration, though it is a simple function.
- */
-
-void
-winSendKeyEvent (DWORD dwKey, Bool fDown)
-{
-  EventListPtr events;
-  int i, nevents;
-
-  /*
-   * When alt-tabing between screens we can get phantom key up messages
-   * Here we only pass them through it we think we should!
-   */
-  if (g_winKeyState[dwKey] == FALSE && fDown == FALSE) return;
-
-  /* Update the keyState map */
-  g_winKeyState[dwKey] = fDown;
-
-  GetEventList(&events);
-  nevents = GetKeyboardEvents(events, g_pwinKeyboard, fDown ? KeyPress : KeyRelease, dwKey + MIN_KEYCODE);
-
-  for (i = 0; i < nevents; i++)
-    mieqEnqueue(g_pwinKeyboard, (InternalEvent*)events[i].event);
-
-  winDebug("winSendKeyEvent: dwKey: %d, fDown: %d, nEvents %d\n",
-          dwKey, fDown, nevents);
-}
-
-BOOL winCheckKeyPressed(WPARAM wParam, LPARAM lParam)
-{
-  switch (wParam)
-  {
-    case VK_CONTROL:
-      if ((lParam & 0x1ff0000) == 0x11d0000 && g_winKeyState[KEY_RCtrl])
-        return TRUE;
-      if ((lParam & 0x1ff0000) == 0x01d0000 && g_winKeyState[KEY_LCtrl])
-        return TRUE;
-      break;
-    case VK_SHIFT:
-      if ((lParam & 0x1ff0000) == 0x0360000 && g_winKeyState[KEY_ShiftR])
-        return TRUE;
-      if ((lParam & 0x1ff0000) == 0x02a0000 && g_winKeyState[KEY_ShiftL])
-        return TRUE;
-      break;
-    default:
-      return TRUE;
-  }
-  return FALSE;
-}
-
-/* Only on shift release message is sent even if both are pressed.
- * Fix this here 
- */
-void winFixShiftKeys (int iScanCode)
-{
-  if (GetKeyState (VK_SHIFT) & 0x8000)
-    return;
-
-  if (iScanCode == KEY_ShiftL && g_winKeyState[KEY_ShiftR])
-    winSendKeyEvent (KEY_ShiftR, FALSE);
-  if (iScanCode == KEY_ShiftR && g_winKeyState[KEY_ShiftL])
-    winSendKeyEvent (KEY_ShiftL, FALSE);
-}
+/*

+ *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of the XFree86 Project

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from the XFree86 Project.

+ *

+ * Authors:	Dakshinamurthy Karra

+ *		Suhaib M Siddiqi

+ *		Peter Busch

+ *		Harold L Hunt II

+ */

+

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+#include "winkeybd.h"

+#include "winconfig.h"

+#include "winmsg.h"

+

+#include "xkbsrv.h"

+

+static Bool g_winKeyState[NUM_KEYCODES];

+

+/*

+ * Local prototypes

+ */

+

+static void

+winKeybdBell (int iPercent, DeviceIntPtr pDeviceInt,

+	      pointer pCtrl, int iClass);

+

+static void

+winKeybdCtrl (DeviceIntPtr pDevice, KeybdCtrl *pCtrl);

+

+

+/* 

+ * Translate a Windows WM_[SYS]KEY(UP/DOWN) message

+ * into an ASCII scan code.

+ *

+ * We do this ourselves, rather than letting Windows handle it,

+ * because Windows tends to munge the handling of special keys,

+ * like AltGr on European keyboards.

+ */

+

+void

+winTranslateKey (WPARAM wParam, LPARAM lParam, int *piScanCode)

+{

+  int		iKeyFixup = g_iKeyMap[wParam * WIN_KEYMAP_COLS + 1];

+  int		iKeyFixupEx = g_iKeyMap[wParam * WIN_KEYMAP_COLS + 2];

+  int		iParam = HIWORD (lParam);

+  int		iParamScanCode = LOBYTE (iParam);

+

+/* WM_ key messages faked by Vista speech recognition (WSR) don't have a

+ * scan code.

+ *

+ * Vocola 3 (Rick Mohr's supplement to WSR) uses

+ * System.Windows.Forms.SendKeys.SendWait(), which appears always to give a

+ * scan code of 1

+ */

+  if (iParamScanCode <= 1)

+    {

+      if (VK_PRIOR <= wParam && wParam <= VK_DOWN)

+        /* Trigger special case table to translate to extended

+         * keycode, otherwise if num_lock is on, we can get keypad

+         * numbers instead of navigation keys. */

+        iParam |= KF_EXTENDED;

+      else

+        iParamScanCode = MapVirtualKeyEx(wParam,

+                         /*MAPVK_VK_TO_VSC*/0,

+                         GetKeyboardLayout(0));

+    }

+

+  /* Branch on special extended, special non-extended, or normal key */

+  if ((iParam & KF_EXTENDED) && iKeyFixupEx)

+    *piScanCode = iKeyFixupEx;

+  else if (iKeyFixup)

+    *piScanCode = iKeyFixup;

+  else if (wParam == 0 && iParamScanCode == 0x70)

+    *piScanCode = KEY_HKTG;

+  else

+    switch (iParamScanCode)

+    {

+      case 0x70:

+        *piScanCode = KEY_HKTG;

+        break;

+      case 0x73:

+        *piScanCode = KEY_BSlash2;

+        break;

+      default: 

+        *piScanCode = iParamScanCode;

+        break;

+    }

+}

+

+/* Ring the keyboard bell (system speaker on PCs) */

+static void

+winKeybdBell (int iPercent, DeviceIntPtr pDeviceInt,

+	      pointer pCtrl, int iClass)

+{

+  /*

+   * We can't use Beep () here because it uses the PC speaker

+   * on NT/2000.  MessageBeep (MB_OK) will play the default system

+   * sound on systems with a sound card or it will beep the PC speaker

+   * on systems that do not have a sound card.

+   */

+  MessageBeep (MB_OK);

+}

+

+

+/* Change some keyboard configuration parameters */

+static void

+winKeybdCtrl (DeviceIntPtr pDevice, KeybdCtrl *pCtrl)

+{

+}

+

+

+/* 

+ * See Porting Layer Definition - p. 18

+ * winKeybdProc is known as a DeviceProc.

+ */

+

+int

+winKeybdProc (DeviceIntPtr pDeviceInt, int iState)

+{

+  DevicePtr		pDevice = (DevicePtr) pDeviceInt;

+  XkbSrvInfoPtr       xkbi;

+  XkbControlsPtr      ctrl;

+

+  switch (iState)

+    {

+    case DEVICE_INIT:

+      winConfigKeyboard (pDeviceInt);

+

+      /* FIXME: Maybe we should use winGetKbdLeds () here? */

+      defaultKeyboardControl.leds = g_winInfo.keyboard.leds;

+

+      winDebug("Rules = \"%s\" Model = \"%s\" Layout = \"%s\""

+               " Variant = \"%s\" Options = \"%s\"\n",

+               g_winInfo.xkb.rules ? g_winInfo.xkb.rules : "none",

+               g_winInfo.xkb.model ? g_winInfo.xkb.model : "none",

+               g_winInfo.xkb.layout ? g_winInfo.xkb.layout : "none",

+               g_winInfo.xkb.variant ? g_winInfo.xkb.variant : "none",

+               g_winInfo.xkb.options ? g_winInfo.xkb.options : "none");

+

+      InitKeyboardDeviceStruct (pDeviceInt,

+                                &g_winInfo.xkb,

+                                winKeybdBell,

+                                winKeybdCtrl);

+

+      xkbi = pDeviceInt->key->xkbInfo;

+      if ((xkbi != NULL) && (xkbi->desc != NULL))

+        {

+          ctrl = xkbi->desc->ctrls;

+          ctrl->repeat_delay = g_winInfo.keyboard.delay;

+          ctrl->repeat_interval = 1000/g_winInfo.keyboard.rate;

+        }

+      else

+        {

+          winDebug ("winKeybdProc - Error initializing keyboard AutoRepeat\n");

+        }

+

+	  XkbSetExtension(pDeviceInt, ProcessKeyboardEvent);

+      break;

+      

+    case DEVICE_ON: 

+      pDevice->on = TRUE;

+

+      // immediately copy the state of this keyboard device to the VCK

+      // (which otherwise happens lazily after the first keypress)

+      CopyKeyClass(pDeviceInt, inputInfo.keyboard);

+      break;

+

+    case DEVICE_CLOSE:

+    case DEVICE_OFF: 

+      pDevice->on = FALSE;

+      break;

+    }

+

+  return Success;

+}

+

+

+/*

+ * Detect current mode key states upon server startup.

+ *

+ * Simulate a press and release of any key that is currently

+ * toggled.

+ */

+

+void

+winInitializeModeKeyStates (void)

+{

+  /* Restore NumLock */

+  if (GetKeyState (VK_NUMLOCK) & 0x0001)

+    {

+      winSendKeyEvent (KEY_NumLock, TRUE);

+      winSendKeyEvent (KEY_NumLock, FALSE);

+    }

+

+  /* Restore CapsLock */

+  if (GetKeyState (VK_CAPITAL) & 0x0001)

+    {

+      winSendKeyEvent (KEY_CapsLock, TRUE);

+      winSendKeyEvent (KEY_CapsLock, FALSE);

+    }

+

+  /* Restore ScrollLock */

+  if (GetKeyState (VK_SCROLL) & 0x0001)

+    {

+      winSendKeyEvent (KEY_ScrollLock, TRUE);

+      winSendKeyEvent (KEY_ScrollLock, FALSE);

+    }

+

+  /* Restore KanaLock */

+  if (GetKeyState (VK_KANA) & 0x0001)

+    {

+      winSendKeyEvent (KEY_HKTG, TRUE);

+      winSendKeyEvent (KEY_HKTG, FALSE);

+    }

+}

+

+

+/*

+ * Upon regaining the keyboard focus we must

+ * resynchronize our internal mode key states

+ * with the actual state of the keys.

+ */

+

+void

+winRestoreModeKeyStates (void)

+{

+  DWORD			dwKeyState;

+  BOOL			processEvents = TRUE;

+  unsigned short	internalKeyStates;

+

+  /* X server is being initialized */

+  if (!inputInfo.keyboard)

+    return;

+

+  /* Only process events if the rootwindow is mapped. The keyboard events

+   * will cause segfaults otherwise */

+  if (screenInfo.screens[0]->root && screenInfo.screens[0]->root->mapped == FALSE)

+    processEvents = FALSE;    

+  

+  /* Force to process all pending events in the mi event queue */

+  if (processEvents)

+    mieqProcessInputEvents ();

+  

+  /* Read the mode key states of our X server */

+  /* (stored in the virtual core keyboard) */

+  internalKeyStates = XkbStateFieldFromRec(&inputInfo.keyboard->key->xkbInfo->state);

+  winDebug("winRestoreModeKeyStates: state %d\n", internalKeyStates);

+

+  /* 

+   * NOTE: The C XOR operator, ^, will not work here because it is

+   * a bitwise operator, not a logical operator.  C does not

+   * have a logical XOR operator, so we use a macro instead.

+   */

+

+  /* Has the key state changed? */

+  dwKeyState = GetKeyState (VK_NUMLOCK) & 0x0001;

+  if (WIN_XOR (internalKeyStates & NumLockMask, dwKeyState))

+    {

+      winSendKeyEvent (KEY_NumLock, TRUE);

+      winSendKeyEvent (KEY_NumLock, FALSE);

+    }

+

+  /* Has the key state changed? */

+  dwKeyState = GetKeyState (VK_CAPITAL) & 0x0001;

+  if (WIN_XOR (internalKeyStates & LockMask, dwKeyState))

+    {

+      winSendKeyEvent (KEY_CapsLock, TRUE);

+      winSendKeyEvent (KEY_CapsLock, FALSE);

+    }

+

+  /* Has the key state changed? */

+  dwKeyState = GetKeyState (VK_SCROLL) & 0x0001;

+  if (WIN_XOR (internalKeyStates & ScrollLockMask, dwKeyState))

+    {

+      winSendKeyEvent (KEY_ScrollLock, TRUE);

+      winSendKeyEvent (KEY_ScrollLock, FALSE);

+    }

+

+  /* Has the key state changed? */

+  dwKeyState = GetKeyState (VK_KANA) & 0x0001;

+  if (WIN_XOR (internalKeyStates & KanaMask, dwKeyState))

+    {

+      winSendKeyEvent (KEY_HKTG, TRUE);

+      winSendKeyEvent (KEY_HKTG, FALSE);

+    }

+}

+

+

+/*

+ * Look for the lovely fake Control_L press/release generated by Windows

+ * when AltGr is pressed/released on a non-U.S. keyboard.

+ */

+

+Bool

+winIsFakeCtrl_L (UINT message, WPARAM wParam, LPARAM lParam)

+{

+  MSG		msgNext;

+  LONG		lTime;

+  Bool		fReturn;

+

+  /*

+   * Fake Ctrl_L presses will be followed by an Alt_R keypress

+   * with the same timestamp as the Ctrl_L press.

+   */

+  if ((message == WM_KEYDOWN || message == WM_SYSKEYDOWN)

+      && wParam == VK_CONTROL

+      && (HIWORD (lParam) & KF_EXTENDED) == 0)

+    {

+      /* Got a Ctrl_L press */

+

+      /* Get time of current message */

+      lTime = GetMessageTime ();

+

+      /* Look for fake Ctrl_L preceeding an Alt_R press. */

+      fReturn = PeekMessage (&msgNext, NULL,

+			     WM_KEYDOWN, WM_SYSKEYDOWN,

+			     PM_NOREMOVE);

+

+      /*

+       * Try again if the first call fails.

+       * NOTE: This usually happens when TweakUI is enabled.

+       */

+      if (!fReturn)

+	{

+	  /* Voodoo to make sure that the Alt_R message has posted */

+	  Sleep (0);

+

+	  /* Look for fake Ctrl_L preceeding an Alt_R press. */

+	  fReturn = PeekMessage (&msgNext, NULL,

+				 WM_KEYDOWN, WM_SYSKEYDOWN,

+				 PM_NOREMOVE);

+	}

+      if (msgNext.message != WM_KEYDOWN && msgNext.message != WM_SYSKEYDOWN)

+          fReturn = 0;

+

+      /* Is next press an Alt_R with the same timestamp? */

+      if (fReturn && msgNext.wParam == VK_MENU

+	  && msgNext.time == lTime

+	  && (HIWORD (msgNext.lParam) & KF_EXTENDED))

+	{

+	  /* 

+	   * Next key press is Alt_R with same timestamp as current

+	   * Ctrl_L message.  Therefore, this Ctrl_L press is a fake

+	   * event, so discard it.

+	   */

+	  return TRUE;

+	}

+    }

+

+  /* 

+   * Fake Ctrl_L releases will be followed by an Alt_R release

+   * with the same timestamp as the Ctrl_L release.

+   */

+  if ((message == WM_KEYUP || message == WM_SYSKEYUP)

+      && wParam == VK_CONTROL

+      && (HIWORD (lParam) & KF_EXTENDED) == 0)

+    {

+      /* Got a Ctrl_L release */

+

+      /* Get time of current message */

+      lTime = GetMessageTime ();

+

+      /* Look for fake Ctrl_L release preceeding an Alt_R release. */

+      fReturn = PeekMessage (&msgNext, NULL,

+			     WM_KEYUP, WM_SYSKEYUP, 

+			     PM_NOREMOVE);

+

+      /*

+       * Try again if the first call fails.

+       * NOTE: This usually happens when TweakUI is enabled.

+       */

+      if (!fReturn)

+	{

+	  /* Voodoo to make sure that the Alt_R message has posted */

+	  Sleep (0);

+

+	  /* Look for fake Ctrl_L release preceeding an Alt_R release. */

+	  fReturn = PeekMessage (&msgNext, NULL,

+				 WM_KEYUP, WM_SYSKEYUP, 

+				 PM_NOREMOVE);

+	}

+

+      if (msgNext.message != WM_KEYUP && msgNext.message != WM_SYSKEYUP)

+          fReturn = 0;

+      

+      /* Is next press an Alt_R with the same timestamp? */

+      if (fReturn

+	  && (msgNext.message == WM_KEYUP

+	      || msgNext.message == WM_SYSKEYUP)

+	  && msgNext.wParam == VK_MENU

+	  && msgNext.time == lTime

+	  && (HIWORD (msgNext.lParam) & KF_EXTENDED))

+	{

+	  /*

+	   * Next key release is Alt_R with same timestamp as current

+	   * Ctrl_L message. Therefore, this Ctrl_L release is a fake

+	   * event, so discard it.

+	   */

+	  return TRUE;

+	}

+    }

+  

+  /* Not a fake control left press/release */

+  return FALSE;

+}

+

+

+/*

+ * Lift any modifier keys that are pressed

+ */

+

+void

+winKeybdReleaseKeys (void)

+{

+  int				i;

+

+#ifdef HAS_DEVWINDOWS

+  /* Verify that the mi input system has been initialized */

+  if (g_fdMessageQueue == WIN_FD_INVALID)

+    return;

+#endif

+

+  /* Loop through all keys */

+  for (i = 0; i < NUM_KEYCODES; ++i)

+    {

+      /* Pop key if pressed */

+      if (g_winKeyState[i])

+	winSendKeyEvent (i, FALSE);

+

+      /* Reset pressed flag for keys */

+      g_winKeyState[i] = FALSE;

+    }

+}

+

+

+/*

+ * Take a raw X key code and send an up or down event for it.

+ *

+ * Thanks to VNC for inspiration, though it is a simple function.

+ */

+

+void

+winSendKeyEvent (DWORD dwKey, Bool fDown)

+{

+  EventListPtr events;

+  int i, nevents;

+

+  /*

+   * When alt-tabing between screens we can get phantom key up messages

+   * Here we only pass them through it we think we should!

+   */

+  if (g_winKeyState[dwKey] == FALSE && fDown == FALSE) return;

+

+  /* Update the keyState map */

+  g_winKeyState[dwKey] = fDown;

+

+  GetEventList(&events);

+  nevents = GetKeyboardEvents(events, g_pwinKeyboard, fDown ? KeyPress : KeyRelease, dwKey + MIN_KEYCODE);

+

+  for (i = 0; i < nevents; i++)

+    mieqEnqueue(g_pwinKeyboard, (InternalEvent*)events[i].event);

+

+  winDebug("winSendKeyEvent: dwKey: %d, fDown: %d, nEvents %d\n",

+          dwKey, fDown, nevents);

+}

+

+BOOL winCheckKeyPressed(WPARAM wParam, LPARAM lParam)

+{

+  switch (wParam)

+  {

+    case VK_CONTROL:

+      if ((lParam & 0x1ff0000) == 0x11d0000 && g_winKeyState[KEY_RCtrl])

+        return TRUE;

+      if ((lParam & 0x1ff0000) == 0x01d0000 && g_winKeyState[KEY_LCtrl])

+        return TRUE;

+      break;

+    case VK_SHIFT:

+      if ((lParam & 0x1ff0000) == 0x0360000 && g_winKeyState[KEY_ShiftR])

+        return TRUE;

+      if ((lParam & 0x1ff0000) == 0x02a0000 && g_winKeyState[KEY_ShiftL])

+        return TRUE;

+      break;

+    default:

+      return TRUE;

+  }

+  return FALSE;

+}

+

+/* Only on shift release message is sent even if both are pressed.

+ * Fix this here 

+ */

+void winFixShiftKeys (int iScanCode)

+{

+  if (GetKeyState (VK_SHIFT) & 0x8000)

+    return;

+

+  if (iScanCode == KEY_ShiftL && g_winKeyState[KEY_ShiftR])

+    winSendKeyEvent (KEY_ShiftR, FALSE);

+  if (iScanCode == KEY_ShiftR && g_winKeyState[KEY_ShiftL])

+    winSendKeyEvent (KEY_ShiftL, FALSE);

+}

diff --git a/xorg-server/hw/xwin/winmultiwindowshape.c b/xorg-server/hw/xwin/winmultiwindowshape.c
index 32a3f16e6..9219bb708 100644
--- a/xorg-server/hw/xwin/winmultiwindowshape.c
+++ b/xorg-server/hw/xwin/winmultiwindowshape.c
@@ -1,218 +1,215 @@
-/*
- *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of the XFree86 Project
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from the XFree86 Project.
- *
- * Authors:	Kensuke Matsuzaki
- *		Harold L Hunt II
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-
-#include "win.h"
-
-
-/*
- * winSetShapeMultiWindow - See Porting Layer Definition - p. 42
- */
-
-void
-winSetShapeMultiWindow (WindowPtr pWin)
-{
-  ScreenPtr		pScreen = pWin->drawable.pScreen;
-  winScreenPriv(pScreen);
-
-  winDebug ("winSetShapeMultiWindow - pWin: %08x\n", pWin);
-  
-  WIN_UNWRAP(SetShape); 
-  (*pScreen->SetShape)(pWin);
-  WIN_WRAP(SetShape, winSetShapeMultiWindow);
-  
-  /* Update the Windows window's shape */
-  winReshapeMultiWindow (pWin);
-  winUpdateRgnMultiWindow (pWin);
-
-  return;
-}
-
-
-/*
- * winUpdateRgnMultiWindow - Local function to update a Windows window region
- */
-
-void
-winUpdateRgnMultiWindow (WindowPtr pWin)
-{
-  SetWindowRgn (winGetWindowPriv(pWin)->hWnd,
-		winGetWindowPriv(pWin)->hRgn, TRUE);
-
-  /* The system now owns the region specified by the region handle and will delete it when it is no longer needed. */
-  winGetWindowPriv(pWin)->hRgn = NULL;
-}
-
-
-/*
- * winReshapeMultiWindow - Computes the composite clipping region for a window
- */
-
-void
-winReshapeMultiWindow (WindowPtr pWin)
-{
-  int		nRects;
-  RegionRec	rrNewShape;
-  BoxPtr	pShape, pRects, pEnd;
-  HRGN		hRgn, hRgnRect;
-  winWindowPriv(pWin);
-
-  winDebug ("winReshape ()\n");
-  
-  /* Bail if the window is the root window */
-  if (pWin->parent == NULL)
-    return;
-
-  /* Bail if the window is not top level */
-  if (pWin->parent->parent != NULL)
-    return;
-
-  /* Bail if Windows window handle is invalid */
-  if (pWinPriv->hWnd == NULL)
-    return;
-  
-  /* Free any existing window region stored in the window privates */
-  if (pWinPriv->hRgn != NULL)
-    {
-      DeleteObject (pWinPriv->hRgn);
-      pWinPriv->hRgn = NULL;
-    }
-  
-  /* Bail if the window has no bounding region defined */
-  if (!wBoundingShape (pWin))
-    return;
-
-  REGION_NULL(pWin->drawable.pScreen, &rrNewShape);
-  REGION_COPY(pWin->drawable.pScreen, &rrNewShape, wBoundingShape(pWin));
-  REGION_TRANSLATE(pWin->drawable.pScreen,
-		   &rrNewShape,
-		   pWin->borderWidth,
-                   pWin->borderWidth);
-  
-  nRects = REGION_NUM_RECTS(&rrNewShape);
-  pShape = REGION_RECTS(&rrNewShape);
-  
-  /* Don't do anything if there are no rectangles in the region */
-  if (nRects > 0)
-    {
-      RECT			rcClient;
-      RECT			rcWindow;
-      int			iOffsetX, iOffsetY;
-      
-      /* Get client rectangle */
-      if (!GetClientRect (pWinPriv->hWnd, &rcClient))
-	{
-	  ErrorF ("winReshape - GetClientRect failed, bailing: %d\n",
-		  (int) GetLastError ());
-	  return;
-	}
-
-      /* Translate client rectangle coords to screen coords */
-      /* NOTE: Only transforms top and left members */
-      ClientToScreen (pWinPriv->hWnd, (LPPOINT) &rcClient);
-
-      /* Get window rectangle */
-      if (!GetWindowRect (pWinPriv->hWnd, &rcWindow))
-	{
-	  ErrorF ("winReshape - GetWindowRect failed, bailing: %d\n",
-		  (int) GetLastError ());
-	  return;
-	}
-
-      /* Calculate offset from window upper-left to client upper-left */
-      iOffsetX = rcClient.left - rcWindow.left;
-      iOffsetY = rcClient.top - rcWindow.top;
-
-      /* Create initial Windows region for title bar */
-      /* FIXME: Mean, nasty, ugly hack!!! */
-      hRgn = CreateRectRgn (0, 0, rcWindow.right, iOffsetY);
-      if (hRgn == NULL)
-	{
-	  ErrorF ("winReshape - Initial CreateRectRgn (%d, %d, %d, %d) "
-		  "failed: %d\n",
-		  0, 0, (int) rcWindow.right, iOffsetY, (int) GetLastError ());
-	}
-
-      /* Loop through all rectangles in the X region */
-      for (pRects = pShape, pEnd = pShape + nRects; pRects < pEnd; pRects++)
-        {
-	  /* Create a Windows region for the X rectangle */
-	  hRgnRect = CreateRectRgn (pRects->x1 + iOffsetX,
-				    pRects->y1 + iOffsetY,
-				    pRects->x2 + iOffsetX,
-				    pRects->y2 + iOffsetY);
-	  if (hRgnRect == NULL)
-	    {
-	      ErrorF ("winReshape - Loop CreateRectRgn (%d, %d, %d, %d) "
-		      "failed: %d\n"
-		      "\tx1: %d x2: %d xOff: %d y1: %d y2: %d yOff: %d\n",
-		      pRects->x1 + iOffsetX,
-		      pRects->y1 + iOffsetY,
-		      pRects->x2 + iOffsetX,
-		      pRects->y2 + iOffsetY,
-		      (int) GetLastError (),
-		      pRects->x1, pRects->x2, iOffsetX,
-		      pRects->y1, pRects->y2, iOffsetY);
-	    }
-
-	  /* Merge the Windows region with the accumulated region */
-	  if (CombineRgn (hRgn, hRgn, hRgnRect, RGN_OR) == ERROR)
-	    {
-	      ErrorF ("winReshape - CombineRgn () failed: %d\n",
-		      (int) GetLastError ());
-	    }
-
-	  /* Delete the temporary Windows region */
-	  DeleteObject (hRgnRect);
-        }
-      
-      /* Save a handle to the composite region in the window privates */
-      pWinPriv->hRgn = hRgn;
-    }
-
-  REGION_UNINIT(pWin->drawable.pScreen, &rrNewShape);
-  
-  return;
-}
-
-void
-winShapeRgnUpdateMultiwindow(HWND hwnd)
-{
-  WindowPtr pWin = GetProp (hwnd, WIN_WINDOW_PROP);
-  if (pWin)
-    {
-      winReshapeMultiWindow(pWin);
-      winUpdateRgnMultiWindow(pWin);
-    }
-}
+/*

+ *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of the XFree86 Project

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from the XFree86 Project.

+ *

+ * Authors:	Kensuke Matsuzaki

+ *		Harold L Hunt II

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+

+#include "win.h"

+

+

+/*

+ * winSetShapeMultiWindow - See Porting Layer Definition - p. 42

+ */

+

+void

+winSetShapeMultiWindow (WindowPtr pWin, int kind)

+{

+  ScreenPtr		pScreen = pWin->drawable.pScreen;

+  winScreenPriv(pScreen);

+

+  winDebug ("winSetShapeMultiWindow - pWin: %08x kind: %i\n", pWin, kind);

+  

+  WIN_UNWRAP(SetShape); 

+  (*pScreen->SetShape)(pWin, kind);

+  WIN_WRAP(SetShape, winSetShapeMultiWindow);

+  

+  /* Update the Windows window's shape */

+  winReshapeMultiWindow (pWin);

+  winUpdateRgnMultiWindow (pWin);

+

+  return;

+}

+

+

+/*

+ * winUpdateRgnMultiWindow - Local function to update a Windows window region

+ */

+

+void

+winUpdateRgnMultiWindow (WindowPtr pWin)

+{

+  SetWindowRgn (winGetWindowPriv(pWin)->hWnd,

+		winGetWindowPriv(pWin)->hRgn, TRUE);

+

+  /* The system now owns the region specified by the region handle and will delete it when it is no longer needed. */

+  winGetWindowPriv(pWin)->hRgn = NULL;

+}

+

+

+/*

+ * winReshapeMultiWindow - Computes the composite clipping region for a window

+ */

+

+void

+winReshapeMultiWindow (WindowPtr pWin)

+{

+  int		nRects;

+  RegionRec	rrNewShape;

+  BoxPtr	pShape, pRects, pEnd;

+  HRGN		hRgn, hRgnRect;

+  winWindowPriv(pWin);

+

+  winDebug ("winReshape ()\n");

+  

+  /* Bail if the window is the root window */

+  if (pWin->parent == NULL)

+    return;

+

+  /* Bail if the window is not top level */

+  if (pWin->parent->parent != NULL)

+    return;

+

+  /* Bail if Windows window handle is invalid */

+  if (pWinPriv->hWnd == NULL)

+    return;

+  

+  /* Free any existing window region stored in the window privates */

+  if (pWinPriv->hRgn != NULL)

+    {

+      DeleteObject (pWinPriv->hRgn);

+      pWinPriv->hRgn = NULL;

+    }

+  

+  /* Bail if the window has no bounding region defined */

+  if (!wBoundingShape (pWin))

+    return;

+

+  RegionNull(&rrNewShape);

+  RegionCopy(&rrNewShape, wBoundingShape(pWin));

+  RegionTranslate(&rrNewShape, pWin->borderWidth, pWin->borderWidth);

+  

+  nRects = RegionNumRects(&rrNewShape);

+  pShape = RegionRects(&rrNewShape);

+  

+  /* Don't do anything if there are no rectangles in the region */

+  if (nRects > 0)

+    {

+      RECT			rcClient;

+      RECT			rcWindow;

+      int			iOffsetX, iOffsetY;

+      

+      /* Get client rectangle */

+      if (!GetClientRect (pWinPriv->hWnd, &rcClient))

+	{

+	  ErrorF ("winReshape - GetClientRect failed, bailing: %d\n",

+		  (int) GetLastError ());

+	  return;

+	}

+

+      /* Translate client rectangle coords to screen coords */

+      /* NOTE: Only transforms top and left members */

+      ClientToScreen (pWinPriv->hWnd, (LPPOINT) &rcClient);

+

+      /* Get window rectangle */

+      if (!GetWindowRect (pWinPriv->hWnd, &rcWindow))

+	{

+	  ErrorF ("winReshape - GetWindowRect failed, bailing: %d\n",

+		  (int) GetLastError ());

+	  return;

+	}

+

+      /* Calculate offset from window upper-left to client upper-left */

+      iOffsetX = rcClient.left - rcWindow.left;

+      iOffsetY = rcClient.top - rcWindow.top;

+

+      /* Create initial Windows region for title bar */

+      /* FIXME: Mean, nasty, ugly hack!!! */

+      hRgn = CreateRectRgn (0, 0, rcWindow.right, iOffsetY);

+      if (hRgn == NULL)

+	{

+	  ErrorF ("winReshape - Initial CreateRectRgn (%d, %d, %d, %d) "

+		  "failed: %d\n",

+		  0, 0, (int) rcWindow.right, iOffsetY, (int) GetLastError ());

+	}

+

+      /* Loop through all rectangles in the X region */

+      for (pRects = pShape, pEnd = pShape + nRects; pRects < pEnd; pRects++)

+        {

+	  /* Create a Windows region for the X rectangle */

+	  hRgnRect = CreateRectRgn (pRects->x1 + iOffsetX,

+				    pRects->y1 + iOffsetY,

+				    pRects->x2 + iOffsetX,

+				    pRects->y2 + iOffsetY);

+	  if (hRgnRect == NULL)

+	    {

+	      ErrorF ("winReshape - Loop CreateRectRgn (%d, %d, %d, %d) "

+		      "failed: %d\n"

+		      "\tx1: %d x2: %d xOff: %d y1: %d y2: %d yOff: %d\n",

+		      pRects->x1 + iOffsetX,

+		      pRects->y1 + iOffsetY,

+		      pRects->x2 + iOffsetX,

+		      pRects->y2 + iOffsetY,

+		      (int) GetLastError (),

+		      pRects->x1, pRects->x2, iOffsetX,

+		      pRects->y1, pRects->y2, iOffsetY);

+	    }

+

+	  /* Merge the Windows region with the accumulated region */

+	  if (CombineRgn (hRgn, hRgn, hRgnRect, RGN_OR) == ERROR)

+	    {

+	      ErrorF ("winReshape - CombineRgn () failed: %d\n",

+		      (int) GetLastError ());

+	    }

+

+	  /* Delete the temporary Windows region */

+	  DeleteObject (hRgnRect);

+        }

+      

+      /* Save a handle to the composite region in the window privates */

+      pWinPriv->hRgn = hRgn;

+    }

+

+  RegionUninit(&rrNewShape);

+  

+  return;

+}

+

+void

+winShapeRgnUpdateMultiwindow(HWND hwnd)

+{

+  WindowPtr pWin = GetProp (hwnd, WIN_WINDOW_PROP);

+  if (pWin)

+    {

+      winReshapeMultiWindow(pWin);

+      winUpdateRgnMultiWindow(pWin);

+    }

+}

diff --git a/xorg-server/hw/xwin/winprefs.c b/xorg-server/hw/xwin/winprefs.c
index 3becb436a..4d34e41a1 100644
--- a/xorg-server/hw/xwin/winprefs.c
+++ b/xorg-server/hw/xwin/winprefs.c
@@ -1,875 +1,871 @@
-/*
- * Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- * Copyright (C) Colin Harrison 2005-2008
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the XFree86 Project
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * from the XFree86 Project.
- *
- * Authors:     Earle F. Philhower, III
- *              Colin Harrison
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include <stdio.h>
-#include <stdlib.h>
-#ifdef __CYGWIN__
-#include <sys/resource.h>
-#endif
-#include "win.h"
-
-#include <X11/Xwindows.h>
-#include <shellapi.h>
-
-#include "winprefs.h"
-#include "winmultiwindowclass.h"
-
-/* Where will the custom menu commands start counting from? */
-#define STARTMENUID WM_USER
-
-/* External global variables */
-#ifdef XWIN_MULTIWINDOW
-extern DWORD g_dwCurrentThreadID;
-#endif
-
-extern const char *winGetBaseDir(void);
-
-extern const char *g_pszLogFile;
-
-/* From winmultiwindowflex.l, the real parser */
-extern void parse_file (FILE *fp);
-
-/* From winprefyacc.y, the pref structure loaded by the parser */
-extern WINPREFS pref;
-
-/* The global X default icon */
-extern HICON		g_hIconX;
-extern HICON		g_hSmallIconX;
-
-/* Currently in use command ID, incremented each new menu item created */
-static int g_cmdid = STARTMENUID;
-
-
-/* Defined in DIX */
-extern char *display;
-
-/* Local function to handle comma-ified icon names */
-static HICON
-LoadImageComma (char *fname, int sx, int sy, int flags);
-
-
-/*
- * Creates or appends a menu from a MENUPARSED structure
- */
-static HMENU
-MakeMenu (char *name,
-	  HMENU editMenu,
-	  int editItem)
-{
-  int i;
-  int item;
-  MENUPARSED *m;
-  HMENU hmenu, hsub;
-
-  for (i=0; i<pref.menuItems; i++)
-    {
-      if (!strcmp(name, pref.menu[i].menuName))
-	break;
-    }
-  
-  /* Didn't find a match, bummer */
-  if (i==pref.menuItems)
-    {
-      ErrorF("MakeMenu: Can't find menu %s\n", name);
-      return NULL;
-    }
-  
-  m = &(pref.menu[i]);
-
-  if (editMenu)
-    {
-      hmenu = editMenu;
-      item = editItem;
-    }
-  else
-    {
-      hmenu = CreatePopupMenu();
-      if (!hmenu)
-	{
-	  ErrorF("MakeMenu: Unable to CreatePopupMenu() %s\n", name);
-	  return NULL;
-	}
-      item = 0;
-    }
-
-  /* Add the menu items */
-  for (i=0; i<m->menuItems; i++)
-    {
-      /* Only assign IDs one time... */
-      if ( m->menuItem[i].commandID == 0 )
-	m->menuItem[i].commandID = g_cmdid++;
-
-      switch (m->menuItem[i].cmd)
-	{
-	case CMD_EXEC:
-	case CMD_ALWAYSONTOP:
-	case CMD_RELOAD:
-	  InsertMenu (hmenu,
-		      item,
-		      MF_BYPOSITION|MF_ENABLED|MF_STRING,
-		      m->menuItem[i].commandID,
-		      m->menuItem[i].text);
-	  break;
-	  
-	case CMD_SEPARATOR:
-	  InsertMenu (hmenu,
-		      item,
-		      MF_BYPOSITION|MF_SEPARATOR,
-		      0,
-		      NULL);
-	  break;
-	  
-	case CMD_MENU:
-	  /* Recursive! */
-	  hsub = MakeMenu (m->menuItem[i].param, 0, 0);
-	  if (hsub)
-	    InsertMenu (hmenu,
-			item,
-			MF_BYPOSITION|MF_POPUP|MF_ENABLED|MF_STRING,
-			(UINT_PTR)hsub,
-			m->menuItem[i].text);
-	  break;
-	}
-
-      /* If item==-1 (means to add at end of menu) don't increment) */
-      if (item>=0)
-	item++;
-    }
-
-  return hmenu;
-}
-
-
-#ifdef XWIN_MULTIWINDOW
-/*
- * Callback routine that is executed once per window class.
- * Removes or creates custom window settings depending on LPARAM
- */
-static wBOOL CALLBACK
-ReloadEnumWindowsProc (HWND hwnd, LPARAM lParam)
-{
-  HICON   hicon;
-  Window  wid;
-
-  if (!hwnd) {
-    ErrorF("ReloadEnumWindowsProc: hwnd==NULL!\n");
-    return FALSE;
-  }
-
-  /* It's our baby, either clean or dirty it */
-  if (lParam==FALSE) 
-    {
-      /* Reset the window's icon to undefined. */
-      hicon = (HICON)SendMessage(hwnd, WM_SETICON, ICON_BIG, 0);
-
-      /* If the old icon is generated on-the-fly, get rid of it, will regen */
-      winDestroyIcon (hicon);
-
-      /* Same for the small icon */
-      hicon = (HICON)SendMessage(hwnd, WM_SETICON, ICON_SMALL, 0);
-      winDestroyIcon (hicon);
-
-      /* Remove any menu additions; bRevert=TRUE destroys any modified menus */
-      GetSystemMenu (hwnd, TRUE);
-      
-      /* This window is now clean of our taint (but with undefined icons) */
-    }
-  else
-    {
-      /* winUpdateIcon() will set the icon default, dynamic, or from xwinrc */
-      wid = (Window)GetProp (hwnd, WIN_WID_PROP);
-      if (wid)
-	winUpdateIcon (wid);
-
-      /* Update the system menu for this window */
-      SetupSysMenu ((unsigned long)hwnd);
-
-      /* That was easy... */
-    }
-
-  return TRUE;
-}
-#endif
-
-
-/*
- * Removes any custom icons in classes, custom menus, etc.
- * Frees all members in pref structure.
- * Reloads the preferences file.
- * Set custom icons and menus again.
- */
-static void
-ReloadPrefs (void)
-{
-  int i;
-
-#ifdef XWIN_MULTIWINDOW
-  /* First, iterate over all windows, deleting their icons and custom menus.
-   * This is really only needed because winDestroyIcon() will try to
-   * destroy the old global icons, which will have changed.
-   * It is probably better to set a windows USER_DATA to flag locally defined
-   * icons, and use that to accurately know when to destroy old icons.
-   */
-  EnumThreadWindows (g_dwCurrentThreadID, ReloadEnumWindowsProc, FALSE);
-#endif
-  
-  /* Now, free/clear all info from our prefs structure */
-  for (i=0; i<pref.menuItems; i++)
-    free (pref.menu[i].menuItem);
-  free (pref.menu);
-  pref.menu = NULL;
-  pref.menuItems = 0;
-
-  pref.rootMenuName[0] = 0;
-
-  free (pref.sysMenu);
-  pref.sysMenuItems = 0;
-
-  pref.defaultSysMenuName[0] = 0;
-  pref.defaultSysMenuPos = 0;
-
-  pref.iconDirectory[0] = 0;
-  pref.defaultIconName[0] = 0;
-  pref.trayIconName[0] = 0;
-
-  for (i=0; i<pref.iconItems; i++)
-    if (pref.icon[i].hicon)
-      DestroyIcon ((HICON)pref.icon[i].hicon);
-  free (pref.icon);
-  pref.icon = NULL;
-  pref.iconItems = 0;
-  
-  /* Free global default X icon */
-  if (g_hIconX) 
-    DestroyIcon (g_hIconX);
-  if (g_hSmallIconX)
-    DestroyIcon (g_hSmallIconX);  
-
-  /* Reset the custom command IDs */
-  g_cmdid = STARTMENUID;
-
-  /* Load the updated resource file */
-  LoadPreferences();
-
-  g_hIconX = NULL;
-  g_hSmallIconX = NULL;
-
-#ifdef XWIN_MULTIWINDOW
-  winInitGlobalIcons();
-#endif
-  
-#ifdef XWIN_MULTIWINDOW
-  /* Rebuild the icons and menus */
-  EnumThreadWindows (g_dwCurrentThreadID, ReloadEnumWindowsProc, TRUE);
-#endif
-
-  /* Whew, done */
-}
-
-/*
- * Check/uncheck the ALWAYSONTOP items in this menu
- */
-void
-HandleCustomWM_INITMENU(unsigned long hwndIn,
-			unsigned long hmenuIn)
-{
-  HWND    hwnd;
-  HMENU   hmenu;
-  DWORD   dwExStyle;
-  int     i, j;
-
-  hwnd = (HWND)hwndIn;
-  hmenu = (HMENU)hmenuIn;
-  if (!hwnd || !hmenu) 
-    return;
-  
-  if (GetWindowLongPtr(hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST)
-    dwExStyle = MF_BYCOMMAND | MF_CHECKED;
-  else
-    dwExStyle = MF_BYCOMMAND | MF_UNCHECKED;
-
-  for (i=0; i<pref.menuItems; i++)
-    for (j=0; j<pref.menu[i].menuItems; j++)
-      if (pref.menu[i].menuItem[j].cmd==CMD_ALWAYSONTOP)
-	CheckMenuItem (hmenu, pref.menu[i].menuItem[j].commandID, dwExStyle );
-  
-}
-    
-/*
- * Searches for the custom WM_COMMAND command ID and performs action.
- * Return TRUE if command is proccessed, FALSE otherwise.
- */
-Bool
-HandleCustomWM_COMMAND (unsigned long hwndIn,
-			int           command)
-{
-  HWND hwnd;
-  int i, j;
-  MENUPARSED *m;
-  DWORD			dwExStyle;
-
-  hwnd = (HWND)hwndIn;
-
-  if (!command)
-    return FALSE;
-
-  for (i=0; i<pref.menuItems; i++)
-    {
-      m = &(pref.menu[i]);
-      for (j=0; j<m->menuItems; j++)
-	{
-	  if (command==m->menuItem[j].commandID)
-	    {
-	      /* Match! */
-	      switch(m->menuItem[j].cmd)
-		{
-#ifdef __CYGWIN__
-		case CMD_EXEC:
-		  if (fork()==0)
-		    {
-		      struct rlimit rl;
-		      unsigned long i;
-
-		      /* Close any open descriptors except for STD* */
-		      getrlimit (RLIMIT_NOFILE, &rl);
-		      for (i = STDERR_FILENO+1; i < rl.rlim_cur; i++)
-			close(i);
-
-		      /* Disassociate any TTYs */
-		      setsid();
-
-		      execl ("/bin/sh",
-			     "/bin/sh",
-			     "-c",
-			     m->menuItem[j].param,
-			     NULL);
-		      exit (0);
-		    }
-		  else
-		    return TRUE;
-		  break;
-#else
-		case CMD_EXEC:
-                  {
-		    /* Start process without console window */
-		    STARTUPINFO start;
-		    PROCESS_INFORMATION child;
-
-		    memset (&start, 0, sizeof (start));
-		    start.cb = sizeof (start);
-		    //start.dwFlags = STARTF_USESHOWWINDOW;
-		    //start.wShowWindow = SW_HIDE;
-
-		    memset (&child, 0, sizeof (child));
-
-		    if (CreateProcess (NULL, m->menuItem[j].param, NULL, NULL, FALSE, 0,
-				       NULL, NULL, &start, &child))
-		    {
-			CloseHandle (child.hThread);
-			CloseHandle (child.hProcess);
-		    }
-		    else
-			MessageBox(NULL, m->menuItem[j].param, "VcXsrv Exec Command Error!", MB_OK | MB_ICONEXCLAMATION);
-                  }
-		  return TRUE;
-#endif
-		case CMD_ALWAYSONTOP:
-		  if (!hwnd)
-		    return FALSE;
-
-		  /* Get extended window style */
-		  dwExStyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
-		  
-		  /* Handle topmost windows */
-		  if (dwExStyle & WS_EX_TOPMOST)
-		    SetWindowPos (hwnd,
-				  HWND_NOTOPMOST,
-				  0, 0,
-				  0, 0,
-				  SWP_NOSIZE | SWP_NOMOVE);
-		  else
-		    SetWindowPos (hwnd,
-				  HWND_TOPMOST,
-				  0, 0,
-				  0, 0,
-				  SWP_NOSIZE | SWP_NOMOVE);
-#if XWIN_MULTIWINDOW
-		  /* Reflect the changed Z order */
-		  winReorderWindowsMultiWindow ();
-#endif
-		  return TRUE;
-		  
-		case CMD_RELOAD:
-		  ReloadPrefs();
-		  return TRUE;
-
-		default:
-		  return FALSE;
-	      }
-	    } /* match */
-	} /* for j */
-    } /* for i */
-
-  return FALSE;
-}
-
-
-#ifdef XWIN_MULTIWINDOW
-/*
- * Add the default or a custom menu depending on the class match
- */
-void
-SetupSysMenu (unsigned long hwndIn)
-{
-  HWND    hwnd;
-  HMENU	  sys;
-  int     i;
-  WindowPtr pWin;
-  char *res_name, *res_class;
-
-  hwnd = (HWND)hwndIn;
-  if (!hwnd)
-    return;
-
-  pWin = GetProp (hwnd, WIN_WINDOW_PROP);
-  
-  sys = GetSystemMenu (hwnd, FALSE);
-  if (!sys)
-    return;
-
-  if (pWin)
-    {
-      /* First see if there's a class match... */
-      if (winMultiWindowGetClassHint (pWin, &res_name, &res_class))
-	{
-	  for (i=0; i<pref.sysMenuItems; i++)
-	    {
-	      if (!strcmp(pref.sysMenu[i].match, res_name) ||
-		  !strcmp(pref.sysMenu[i].match, res_class) ) 
-		{
-		  free(res_name);
-		  free(res_class);
-  
-		  MakeMenu (pref.sysMenu[i].menuName, sys,
-			    pref.sysMenu[i].menuPos==AT_START?0:-1);
-		  return;
-		}
-	    }
-	  
-	  /* No match, just free alloc'd strings */
-	  free(res_name);
-	  free(res_class);
-	} /* Found wm_class */
-    } /* if pwin */
-
-  /* Fallback to system default */
-  if (pref.defaultSysMenuName[0])
-    {
-      if (pref.defaultSysMenuPos==AT_START)
-	MakeMenu (pref.defaultSysMenuName, sys, 0);
-      else
-	MakeMenu (pref.defaultSysMenuName, sys, -1);
-    }
-}
-#endif
-
-
-/*
- * Possibly add a menu to the toolbar icon
- */
-void
-SetupRootMenu (unsigned long hmenuRoot)
-{
-  HMENU root;
-
-  root = (HMENU)hmenuRoot;
-  if (!root)
-    return;
-
-  if (pref.rootMenuName[0])
-    {
-      MakeMenu(pref.rootMenuName, root, 0);
-    }
-}
-
-
-/*
- * Check for and return an overridden default ICON specified in the prefs
- */
-HICON
-winOverrideDefaultIcon(int size)
-{
-  HICON hicon;
-  
-  if (pref.defaultIconName[0])
-    {
-      hicon = LoadImageComma (pref.defaultIconName, size, size, 0);
-      if (hicon==NULL)
-        ErrorF ("winOverrideDefaultIcon: LoadImageComma(%s) failed\n",
-		pref.defaultIconName);
-
-      return hicon;
-    }
-
-  return 0;
-}
-
-
-/*
- * Return the HICON to use in the taskbar notification area
- */
-HICON
-winTaskbarIcon(void)
-{
-  HICON hicon;
-
-  hicon = 0;
-  /* First try and load an overridden, if success then return it */
-  if (pref.trayIconName[0])
-    {
-      hicon = LoadImageComma (pref.trayIconName,
-			      GetSystemMetrics (SM_CXSMICON),
-			      GetSystemMetrics (SM_CYSMICON),
-			      0 );
-    }
-
-  /* Otherwise return the default */
-  if (!hicon)
-    hicon =  (HICON) LoadImage (g_hInstance,
-				MAKEINTRESOURCE(IDI_XWIN),
-				IMAGE_ICON,
-				GetSystemMetrics (SM_CXSMICON),
-				GetSystemMetrics (SM_CYSMICON),
-				0);
-
-  return hicon;
-}
-
-
-/*
- * Parse a filename to extract an icon:
- *  If fname is exactly ",nnn" then extract icon from our resource
- *  else if it is "file,nnn" then extract icon nnn from that file
- *  else try to load it as an .ico file and if that fails return NULL
- */
-static HICON
-LoadImageComma (char *fname, int sx, int sy, int flags)
-{
-  HICON  hicon;
-  int    index;
-  char   file[PATH_MAX+NAME_MAX+2];
-
-  /* Some input error checking */
-  if (!fname || !fname[0])
-    return NULL;
-
-  index = 0;
-  hicon = NULL;
-
-  if (fname[0]==',')
-    {
-      /* It's the XWIN.EXE resource they want */
-      index = atoi (fname+1);
-      hicon = LoadImage (g_hInstance,
-                        MAKEINTRESOURCE(index),
-                        IMAGE_ICON,
-                        sx,
-                        sy,
-                        flags);
-    }
-  else
-    {
-      file[0] = 0;
-      /* Prepend path if not given a "X:\" filename */
-      if ( !(fname[0] && fname[1]==':' && fname[2]=='\\') )
-        {
-         strcpy (file, pref.iconDirectory);
-         if (pref.iconDirectory[0])
-           if (fname[strlen(fname)-1]!='\\')
-             strcat (file, "\\");
-        }
-      strcat (file, fname);
-
-      if (strrchr (file, ','))
-       {
-         /* Specified as <fname>,<index> */
-
-         *(strrchr (file, ',')) = 0; /* End string at comma */
-         index = atoi (strrchr (fname, ',') + 1);
-         hicon = ExtractIcon (g_hInstance, file, index);
-       }
-      else
-       {
-         /* Just an .ico file... */
-
-         hicon = (HICON)LoadImage (NULL,
-                                   file,
-                                   IMAGE_ICON,
-                                   sx,
-                                   sy,
-                                   LR_LOADFROMFILE|flags);
-       }
-    }
-  return hicon;
-}
-
-/*
- * Check for a match of the window class to one specified in the
- * ICONS{} section in the prefs file, and load the icon from a file
- */
-HICON
-winOverrideIcon (unsigned long longWin)
-{
-  WindowPtr pWin = (WindowPtr) longWin;
-  char *res_name, *res_class;
-  int i;
-  HICON hicon;
-  char *wmName;
-
-  if (pWin==NULL)
-    return 0;
-
-  /* If we can't find the class, we can't override from default! */
-  if (!winMultiWindowGetClassHint (pWin, &res_name, &res_class))
-    return 0;
-
-  winMultiWindowGetWMName (pWin, &wmName);
-  
-  for (i=0; i<pref.iconItems; i++) {
-    if (!strcmp(pref.icon[i].match, res_name) ||
-	!strcmp(pref.icon[i].match, res_class) ||
-	(wmName && strstr(wmName, pref.icon[i].match))) 
-      {
-	free (res_name);
-	free (res_class);
-	if (wmName)
-	  free (wmName);
-
-	if (pref.icon[i].hicon)
-	  return pref.icon[i].hicon;
-
-       hicon = LoadImageComma (pref.icon[i].iconFile, 0, 0, LR_DEFAULTSIZE);
-       if (hicon==NULL)
-         ErrorF ("winOverrideIcon: LoadImageComma(%s) failed\n",
-                  pref.icon[i].iconFile);
-
-	pref.icon[i].hicon = hicon;
-	return hicon;
-      }
-  }
-  
-  /* Didn't find the icon, fail gracefully */
-  free (res_name);
-  free (res_class);
-  if (wmName)
-    free (wmName);
-
-  return 0;
-}
-
-
-/*
- * Should we free this icon or leave it in memory (is it part of our
- * ICONS{} overrides)?
- */
-int
-winIconIsOverride(unsigned hiconIn)
-{
-  HICON hicon;
-  int i;
-
-  hicon = (HICON)hiconIn;
-
-  if (!hicon)
-    return 0;
-  
-  for (i=0; i<pref.iconItems; i++)
-    if ((HICON)pref.icon[i].hicon == hicon)
-      return 1;
-  
-  return 0;
-}
-
-
-
-/*
- * Try and open ~/.XWinrc and system.XWinrc
- * Load it into prefs structure for use by other functions
- */
-void
-LoadPreferences (void)
-{
-  char *home;
-  char fname[PATH_MAX+NAME_MAX+2];
-  FILE *prefFile;
-  char szDisplay[512];
-  char *szEnvDisplay;
-  int i, j;
-  char param[PARAM_MAX+1];
-  char *srcParam, *dstParam;
-
-  /* First, clear all preference settings */
-  memset (&pref, 0, sizeof(pref));
-  prefFile = NULL;
-
-  /* Now try and find a ~/.xwinrc file */
-  home = getenv ("HOME");
-  if (home)
-    {
-      strcpy (fname, home);
-      if (fname[strlen(fname)-1]!='/')
-	strcat (fname, "/");
-      strcat (fname, ".XWinrc");
-      
-      prefFile = fopen (fname, "r");
-      if (prefFile)
-      {
-	winDebug ("winPrefsLoadPreferences: %s\n", fname);
-      }
-    }
-
-  /* No home file found, check system default */
-  if (!prefFile)
-    {
-      char buffer[MAX_PATH];
-#ifdef RELOCATE_PROJECTROOT
-      snprintf(buffer, sizeof(buffer), "%s\\system.XWinrc", winGetBaseDir());
-#else
-      strncpy(buffer, SYSCONFDIR"/X11/system.XWinrc", sizeof(buffer));
-#endif
-      buffer[sizeof(buffer)-1] = 0;
-      prefFile = fopen (buffer, "r");
-      if (prefFile)
-      {
-	winDebug ("winPrefsLoadPreferences: %s\n", buffer);
-      }
-    }
-
-  /* If we could open it, then read the settings and close it */
-  if (prefFile)
-    {
-      parse_file (prefFile);
-      fclose (prefFile);
-    }
-
-  /* Setup a DISPLAY environment variable, need to allocate on heap */
-  /* because putenv doesn't copy the argument... Always use screen 0 */
-  winGetDisplayName(szDisplay, 0);
-  szEnvDisplay = (char *)(malloc(strlen(szDisplay)+9/*strlen("DISPLAY=")+1*/));
-  snprintf(szEnvDisplay, 512, "DISPLAY=%s", szDisplay);
-  putenv (szEnvDisplay);
-
-  /* Replace any "%display%" in menu commands with display string */
-  for (i=0; i<pref.menuItems; i++)
-    {
-      for (j=0; j<pref.menu[i].menuItems; j++)
-	{
-	  if (pref.menu[i].menuItem[j].cmd==CMD_EXEC)
-	    {
-	      srcParam = pref.menu[i].menuItem[j].param;
-	      dstParam = param;
-	      while (*srcParam) {
-		if (!strncmp(srcParam, "%display%", 9))
-		  {
-		    memcpy (dstParam, szDisplay, strlen(szDisplay));
-		    dstParam += strlen(szDisplay);
-		    srcParam += 9;
-		  }
-		else if (!strncmp(srcParam, "%logfile%", 9))
-		  {
-		    memcpy (dstParam, g_pszLogFile, strlen(g_pszLogFile));
-		    dstParam += strlen(g_pszLogFile);
-		    srcParam += 9;
-		  }
-		else
-		  {
-		    *dstParam = *srcParam;
-		    dstParam++;
-		    srcParam++;
-		  }
-	      }
-	      *dstParam = 0;
-	      strcpy (pref.menu[i].menuItem[j].param, param);
-	    } /* cmd==cmd_exec */
-	} /* for all menuitems */
-    } /* for all menus */
-
-}
-
-
-/*
- * Check for a match of the window class to one specified in the
- * STYLES{} section in the prefs file, and return the style type
- */
-unsigned long
-winOverrideStyle (unsigned long longpWin)
-{
-  WindowPtr pWin = (WindowPtr) longpWin;
-  char *res_name, *res_class;
-  int i;
-  char *wmName;
-
-  if (pWin==NULL)
-    return STYLE_NONE;
-
-  /* If we can't find the class, we can't override from default! */
-  if (!winMultiWindowGetClassHint (pWin, &res_name, &res_class))
-    return STYLE_NONE;
-
-  winMultiWindowGetWMName (pWin, &wmName);
-
-  for (i=0; i<pref.styleItems; i++) {
-    if (!strcmp(pref.style[i].match, res_name) ||
-	!strcmp(pref.style[i].match, res_class) ||
-	(wmName && strstr(wmName, pref.style[i].match)))
-      {
-	free (res_name);
-	free (res_class);
-	if (wmName)
-	  free (wmName);
-
-	if (pref.style[i].type)
-	  return pref.style[i].type;
-      }
-  }
-
-  /* Didn't find the style, fail gracefully */
-  free (res_name);
-  free (res_class);
-  if (wmName)
-    free (wmName);
-
-  return STYLE_NONE;
-}
+/*

+ * Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ * Copyright (C) Colin Harrison 2005-2008

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation the rights to use, copy, modify, merge, publish,

+ * distribute, sublicense, and/or sell copies of the Software, and to

+ * permit persons to whom the Software is furnished to do so, subject to

+ * the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be

+ * included in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of the XFree86 Project

+ * shall not be used in advertising or otherwise to promote the sale, use

+ * or other dealings in this Software without prior written authorization

+ * from the XFree86 Project.

+ *

+ * Authors:     Earle F. Philhower, III

+ *              Colin Harrison

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include <stdio.h>

+#include <stdlib.h>

+#ifdef __CYGWIN__

+#include <sys/resource.h>

+#endif

+#include "win.h"

+

+#include <X11/Xwindows.h>

+#include <shellapi.h>

+

+#include "winprefs.h"

+#include "winmultiwindowclass.h"

+

+/* Where will the custom menu commands start counting from? */

+#define STARTMENUID WM_USER

+

+/* External global variables */

+#ifdef XWIN_MULTIWINDOW

+extern DWORD g_dwCurrentThreadID;

+#endif

+

+extern const char *winGetBaseDir(void);

+

+extern const char *g_pszLogFile;

+

+/* From winmultiwindowflex.l, the real parser */

+extern void parse_file (FILE *fp);

+

+/* From winprefyacc.y, the pref structure loaded by the parser */

+extern WINPREFS pref;

+

+/* The global X default icon */

+extern HICON		g_hIconX;

+extern HICON		g_hSmallIconX;

+

+/* Currently in use command ID, incremented each new menu item created */

+static int g_cmdid = STARTMENUID;

+

+

+/* Defined in DIX */

+extern char *display;

+

+/* Local function to handle comma-ified icon names */

+static HICON

+LoadImageComma (char *fname, int sx, int sy, int flags);

+

+

+/*

+ * Creates or appends a menu from a MENUPARSED structure

+ */

+static HMENU

+MakeMenu (char *name,

+	  HMENU editMenu,

+	  int editItem)

+{

+  int i;

+  int item;

+  MENUPARSED *m;

+  HMENU hmenu, hsub;

+

+  for (i=0; i<pref.menuItems; i++)

+    {

+      if (!strcmp(name, pref.menu[i].menuName))

+	break;

+    }

+  

+  /* Didn't find a match, bummer */

+  if (i==pref.menuItems)

+    {

+      ErrorF("MakeMenu: Can't find menu %s\n", name);

+      return NULL;

+    }

+  

+  m = &(pref.menu[i]);

+

+  if (editMenu)

+    {

+      hmenu = editMenu;

+      item = editItem;

+    }

+  else

+    {

+      hmenu = CreatePopupMenu();

+      if (!hmenu)

+	{

+	  ErrorF("MakeMenu: Unable to CreatePopupMenu() %s\n", name);

+	  return NULL;

+	}

+      item = 0;

+    }

+

+  /* Add the menu items */

+  for (i=0; i<m->menuItems; i++)

+    {

+      /* Only assign IDs one time... */

+      if ( m->menuItem[i].commandID == 0 )

+	m->menuItem[i].commandID = g_cmdid++;

+

+      switch (m->menuItem[i].cmd)

+	{

+	case CMD_EXEC:

+	case CMD_ALWAYSONTOP:

+	case CMD_RELOAD:

+	  InsertMenu (hmenu,

+		      item,

+		      MF_BYPOSITION|MF_ENABLED|MF_STRING,

+		      m->menuItem[i].commandID,

+		      m->menuItem[i].text);

+	  break;

+	  

+	case CMD_SEPARATOR:

+	  InsertMenu (hmenu,

+		      item,

+		      MF_BYPOSITION|MF_SEPARATOR,

+		      0,

+		      NULL);

+	  break;

+	  

+	case CMD_MENU:

+	  /* Recursive! */

+	  hsub = MakeMenu (m->menuItem[i].param, 0, 0);

+	  if (hsub)

+	    InsertMenu (hmenu,

+			item,

+			MF_BYPOSITION|MF_POPUP|MF_ENABLED|MF_STRING,

+			(UINT_PTR)hsub,

+			m->menuItem[i].text);

+	  break;

+	}

+

+      /* If item==-1 (means to add at end of menu) don't increment) */

+      if (item>=0)

+	item++;

+    }

+

+  return hmenu;

+}

+

+

+#ifdef XWIN_MULTIWINDOW

+/*

+ * Callback routine that is executed once per window class.

+ * Removes or creates custom window settings depending on LPARAM

+ */

+static wBOOL CALLBACK

+ReloadEnumWindowsProc (HWND hwnd, LPARAM lParam)

+{

+  HICON   hicon;

+  Window  wid;

+

+  if (!hwnd) {

+    ErrorF("ReloadEnumWindowsProc: hwnd==NULL!\n");

+    return FALSE;

+  }

+

+  /* It's our baby, either clean or dirty it */

+  if (lParam==FALSE) 

+    {

+      /* Reset the window's icon to undefined. */

+      hicon = (HICON)SendMessage(hwnd, WM_SETICON, ICON_BIG, 0);

+

+      /* If the old icon is generated on-the-fly, get rid of it, will regen */

+      winDestroyIcon (hicon);

+

+      /* Same for the small icon */

+      hicon = (HICON)SendMessage(hwnd, WM_SETICON, ICON_SMALL, 0);

+      winDestroyIcon (hicon);

+

+      /* Remove any menu additions; bRevert=TRUE destroys any modified menus */

+      GetSystemMenu (hwnd, TRUE);

+      

+      /* This window is now clean of our taint (but with undefined icons) */

+    }

+  else

+    {

+      /* winUpdateIcon() will set the icon default, dynamic, or from xwinrc */

+      wid = (Window)GetProp (hwnd, WIN_WID_PROP);

+      if (wid)

+	winUpdateIcon (wid);

+

+      /* Update the system menu for this window */

+      SetupSysMenu ((unsigned long)hwnd);

+

+      /* That was easy... */

+    }

+

+  return TRUE;

+}

+#endif

+

+

+/*

+ * Removes any custom icons in classes, custom menus, etc.

+ * Frees all members in pref structure.

+ * Reloads the preferences file.

+ * Set custom icons and menus again.

+ */

+static void

+ReloadPrefs (void)

+{

+  int i;

+

+#ifdef XWIN_MULTIWINDOW

+  /* First, iterate over all windows, deleting their icons and custom menus.

+   * This is really only needed because winDestroyIcon() will try to

+   * destroy the old global icons, which will have changed.

+   * It is probably better to set a windows USER_DATA to flag locally defined

+   * icons, and use that to accurately know when to destroy old icons.

+   */

+  EnumThreadWindows (g_dwCurrentThreadID, ReloadEnumWindowsProc, FALSE);

+#endif

+  

+  /* Now, free/clear all info from our prefs structure */

+  for (i=0; i<pref.menuItems; i++)

+    free (pref.menu[i].menuItem);

+  free (pref.menu);

+  pref.menu = NULL;

+  pref.menuItems = 0;

+

+  pref.rootMenuName[0] = 0;

+

+  free (pref.sysMenu);

+  pref.sysMenuItems = 0;

+

+  pref.defaultSysMenuName[0] = 0;

+  pref.defaultSysMenuPos = 0;

+

+  pref.iconDirectory[0] = 0;

+  pref.defaultIconName[0] = 0;

+  pref.trayIconName[0] = 0;

+

+  for (i=0; i<pref.iconItems; i++)

+    if (pref.icon[i].hicon)

+      DestroyIcon ((HICON)pref.icon[i].hicon);

+  free (pref.icon);

+  pref.icon = NULL;

+  pref.iconItems = 0;

+  

+  /* Free global default X icon */

+  if (g_hIconX) 

+    DestroyIcon (g_hIconX);

+  if (g_hSmallIconX)

+    DestroyIcon (g_hSmallIconX);  

+

+  /* Reset the custom command IDs */

+  g_cmdid = STARTMENUID;

+

+  /* Load the updated resource file */

+  LoadPreferences();

+

+  g_hIconX = NULL;

+  g_hSmallIconX = NULL;

+

+#ifdef XWIN_MULTIWINDOW

+  winInitGlobalIcons();

+#endif

+  

+#ifdef XWIN_MULTIWINDOW

+  /* Rebuild the icons and menus */

+  EnumThreadWindows (g_dwCurrentThreadID, ReloadEnumWindowsProc, TRUE);

+#endif

+

+  /* Whew, done */

+}

+

+/*

+ * Check/uncheck the ALWAYSONTOP items in this menu

+ */

+void

+HandleCustomWM_INITMENU(unsigned long hwndIn,

+			unsigned long hmenuIn)

+{

+  HWND    hwnd;

+  HMENU   hmenu;

+  DWORD   dwExStyle;

+  int     i, j;

+

+  hwnd = (HWND)hwndIn;

+  hmenu = (HMENU)hmenuIn;

+  if (!hwnd || !hmenu) 

+    return;

+  

+  if (GetWindowLongPtr(hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST)

+    dwExStyle = MF_BYCOMMAND | MF_CHECKED;

+  else

+    dwExStyle = MF_BYCOMMAND | MF_UNCHECKED;

+

+  for (i=0; i<pref.menuItems; i++)

+    for (j=0; j<pref.menu[i].menuItems; j++)

+      if (pref.menu[i].menuItem[j].cmd==CMD_ALWAYSONTOP)

+	CheckMenuItem (hmenu, pref.menu[i].menuItem[j].commandID, dwExStyle );

+  

+}

+    

+/*

+ * Searches for the custom WM_COMMAND command ID and performs action.

+ * Return TRUE if command is proccessed, FALSE otherwise.

+ */

+Bool

+HandleCustomWM_COMMAND (unsigned long hwndIn,

+			int           command)

+{

+  HWND hwnd;

+  int i, j;

+  MENUPARSED *m;

+  DWORD			dwExStyle;

+

+  hwnd = (HWND)hwndIn;

+

+  if (!command)

+    return FALSE;

+

+  for (i=0; i<pref.menuItems; i++)

+    {

+      m = &(pref.menu[i]);

+      for (j=0; j<m->menuItems; j++)

+	{

+	  if (command==m->menuItem[j].commandID)

+	    {

+	      /* Match! */

+	      switch(m->menuItem[j].cmd)

+		{

+#ifdef __CYGWIN__

+		case CMD_EXEC:

+		  if (fork()==0)

+		    {

+		      struct rlimit rl;

+		      unsigned long i;

+

+		      /* Close any open descriptors except for STD* */

+		      getrlimit (RLIMIT_NOFILE, &rl);

+		      for (i = STDERR_FILENO+1; i < rl.rlim_cur; i++)

+			close(i);

+

+		      /* Disassociate any TTYs */

+		      setsid();

+

+		      execl ("/bin/sh",

+			     "/bin/sh",

+			     "-c",

+			     m->menuItem[j].param,

+			     NULL);

+		      exit (0);

+		    }

+		  else

+		    return TRUE;

+		  break;

+#else

+		case CMD_EXEC:

+                  {

+		    /* Start process without console window */

+		    STARTUPINFO start;

+		    PROCESS_INFORMATION child;

+

+		    memset (&start, 0, sizeof (start));

+		    start.cb = sizeof (start);

+		    //start.dwFlags = STARTF_USESHOWWINDOW;

+		    //start.wShowWindow = SW_HIDE;

+

+		    memset (&child, 0, sizeof (child));

+

+		    if (CreateProcess (NULL, m->menuItem[j].param, NULL, NULL, FALSE, 0,

+				       NULL, NULL, &start, &child))

+		    {

+			CloseHandle (child.hThread);

+			CloseHandle (child.hProcess);

+		    }

+		    else

+			MessageBox(NULL, m->menuItem[j].param, "VcXsrv Exec Command Error!", MB_OK | MB_ICONEXCLAMATION);

+                  }

+		  return TRUE;

+#endif

+		case CMD_ALWAYSONTOP:

+		  if (!hwnd)

+		    return FALSE;

+

+		  /* Get extended window style */

+		  dwExStyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE);

+		  

+		  /* Handle topmost windows */

+		  if (dwExStyle & WS_EX_TOPMOST)

+		    SetWindowPos (hwnd,

+				  HWND_NOTOPMOST,

+				  0, 0,

+				  0, 0,

+				  SWP_NOSIZE | SWP_NOMOVE);

+		  else

+		    SetWindowPos (hwnd,

+				  HWND_TOPMOST,

+				  0, 0,

+				  0, 0,

+				  SWP_NOSIZE | SWP_NOMOVE);

+#if XWIN_MULTIWINDOW

+		  /* Reflect the changed Z order */

+		  winReorderWindowsMultiWindow ();

+#endif

+		  return TRUE;

+		  

+		case CMD_RELOAD:

+		  ReloadPrefs();

+		  return TRUE;

+

+		default:

+		  return FALSE;

+	      }

+	    } /* match */

+	} /* for j */

+    } /* for i */

+

+  return FALSE;

+}

+

+

+#ifdef XWIN_MULTIWINDOW

+/*

+ * Add the default or a custom menu depending on the class match

+ */

+void

+SetupSysMenu (unsigned long hwndIn)

+{

+  HWND    hwnd;

+  HMENU	  sys;

+  int     i;

+  WindowPtr pWin;

+  char *res_name, *res_class;

+

+  hwnd = (HWND)hwndIn;

+  if (!hwnd)

+    return;

+

+  pWin = GetProp (hwnd, WIN_WINDOW_PROP);

+  

+  sys = GetSystemMenu (hwnd, FALSE);

+  if (!sys)

+    return;

+

+  if (pWin)

+    {

+      /* First see if there's a class match... */

+      if (winMultiWindowGetClassHint (pWin, &res_name, &res_class))

+	{

+	  for (i=0; i<pref.sysMenuItems; i++)

+	    {

+	      if (!strcmp(pref.sysMenu[i].match, res_name) ||

+		  !strcmp(pref.sysMenu[i].match, res_class) ) 

+		{

+		  free(res_name);

+		  free(res_class);

+  

+		  MakeMenu (pref.sysMenu[i].menuName, sys,

+			    pref.sysMenu[i].menuPos==AT_START?0:-1);

+		  return;

+		}

+	    }

+	  

+	  /* No match, just free alloc'd strings */

+	  free(res_name);

+	  free(res_class);

+	} /* Found wm_class */

+    } /* if pwin */

+

+  /* Fallback to system default */

+  if (pref.defaultSysMenuName[0])

+    {

+      if (pref.defaultSysMenuPos==AT_START)

+	MakeMenu (pref.defaultSysMenuName, sys, 0);

+      else

+	MakeMenu (pref.defaultSysMenuName, sys, -1);

+    }

+}

+#endif

+

+

+/*

+ * Possibly add a menu to the toolbar icon

+ */

+void

+SetupRootMenu (unsigned long hmenuRoot)

+{

+  HMENU root;

+

+  root = (HMENU)hmenuRoot;

+  if (!root)

+    return;

+

+  if (pref.rootMenuName[0])

+    {

+      MakeMenu(pref.rootMenuName, root, 0);

+    }

+}

+

+

+/*

+ * Check for and return an overridden default ICON specified in the prefs

+ */

+HICON

+winOverrideDefaultIcon(int size)

+{

+  HICON hicon;

+  

+  if (pref.defaultIconName[0])

+    {

+      hicon = LoadImageComma (pref.defaultIconName, size, size, 0);

+      if (hicon==NULL)

+        ErrorF ("winOverrideDefaultIcon: LoadImageComma(%s) failed\n",

+		pref.defaultIconName);

+

+      return hicon;

+    }

+

+  return 0;

+}

+

+

+/*

+ * Return the HICON to use in the taskbar notification area

+ */

+HICON

+winTaskbarIcon(void)

+{

+  HICON hicon;

+

+  hicon = 0;

+  /* First try and load an overridden, if success then return it */

+  if (pref.trayIconName[0])

+    {

+      hicon = LoadImageComma (pref.trayIconName,

+			      GetSystemMetrics (SM_CXSMICON),

+			      GetSystemMetrics (SM_CYSMICON),

+			      0 );

+    }

+

+  /* Otherwise return the default */

+  if (!hicon)

+    hicon =  (HICON) LoadImage (g_hInstance,

+				MAKEINTRESOURCE(IDI_XWIN),

+				IMAGE_ICON,

+				GetSystemMetrics (SM_CXSMICON),

+				GetSystemMetrics (SM_CYSMICON),

+				0);

+

+  return hicon;

+}

+

+

+/*

+ * Parse a filename to extract an icon:

+ *  If fname is exactly ",nnn" then extract icon from our resource

+ *  else if it is "file,nnn" then extract icon nnn from that file

+ *  else try to load it as an .ico file and if that fails return NULL

+ */

+static HICON

+LoadImageComma (char *fname, int sx, int sy, int flags)

+{

+  HICON  hicon;

+  int    index;

+  char   file[PATH_MAX+NAME_MAX+2];

+

+  /* Some input error checking */

+  if (!fname || !fname[0])

+    return NULL;

+

+  index = 0;

+  hicon = NULL;

+

+  if (fname[0]==',')

+    {

+      /* It's the XWIN.EXE resource they want */

+      index = atoi (fname+1);

+      hicon = LoadImage (g_hInstance,

+                        MAKEINTRESOURCE(index),

+                        IMAGE_ICON,

+                        sx,

+                        sy,

+                        flags);

+    }

+  else

+    {

+      file[0] = 0;

+      /* Prepend path if not given a "X:\" filename */

+      if ( !(fname[0] && fname[1]==':' && fname[2]=='\\') )

+        {

+         strcpy (file, pref.iconDirectory);

+         if (pref.iconDirectory[0])

+           if (fname[strlen(fname)-1]!='\\')

+             strcat (file, "\\");

+        }

+      strcat (file, fname);

+

+      if (strrchr (file, ','))

+       {

+         /* Specified as <fname>,<index> */

+

+         *(strrchr (file, ',')) = 0; /* End string at comma */

+         index = atoi (strrchr (fname, ',') + 1);

+         hicon = ExtractIcon (g_hInstance, file, index);

+       }

+      else

+       {

+         /* Just an .ico file... */

+

+         hicon = (HICON)LoadImage (NULL,

+                                   file,

+                                   IMAGE_ICON,

+                                   sx,

+                                   sy,

+                                   LR_LOADFROMFILE|flags);

+       }

+    }

+  return hicon;

+}

+

+/*

+ * Check for a match of the window class to one specified in the

+ * ICONS{} section in the prefs file, and load the icon from a file

+ */

+HICON

+winOverrideIcon (unsigned long longWin)

+{

+  WindowPtr pWin = (WindowPtr) longWin;

+  char *res_name, *res_class;

+  int i;

+  HICON hicon;

+  char *wmName;

+

+  if (pWin==NULL)

+    return 0;

+

+  /* If we can't find the class, we can't override from default! */

+  if (!winMultiWindowGetClassHint (pWin, &res_name, &res_class))

+    return 0;

+

+  winMultiWindowGetWMName (pWin, &wmName);

+  

+  for (i=0; i<pref.iconItems; i++) {

+    if (!strcmp(pref.icon[i].match, res_name) ||

+	!strcmp(pref.icon[i].match, res_class) ||

+	(wmName && strstr(wmName, pref.icon[i].match))) 

+      {

+	free (res_name);

+	free (res_class);

+	free(wmName);

+

+	if (pref.icon[i].hicon)

+	  return pref.icon[i].hicon;

+

+       hicon = LoadImageComma (pref.icon[i].iconFile, 0, 0, LR_DEFAULTSIZE);

+       if (hicon==NULL)

+         ErrorF ("winOverrideIcon: LoadImageComma(%s) failed\n",

+                  pref.icon[i].iconFile);

+

+	pref.icon[i].hicon = hicon;

+	return hicon;

+      }

+  }

+  

+  /* Didn't find the icon, fail gracefully */

+  free (res_name);

+  free (res_class);

+  free(wmName);

+

+  return 0;

+}

+

+

+/*

+ * Should we free this icon or leave it in memory (is it part of our

+ * ICONS{} overrides)?

+ */

+int

+winIconIsOverride(unsigned hiconIn)

+{

+  HICON hicon;

+  int i;

+

+  hicon = (HICON)hiconIn;

+

+  if (!hicon)

+    return 0;

+  

+  for (i=0; i<pref.iconItems; i++)

+    if ((HICON)pref.icon[i].hicon == hicon)

+      return 1;

+  

+  return 0;

+}

+

+

+

+/*

+ * Try and open ~/.XWinrc and system.XWinrc

+ * Load it into prefs structure for use by other functions

+ */

+void

+LoadPreferences (void)

+{

+  char *home;

+  char fname[PATH_MAX+NAME_MAX+2];

+  FILE *prefFile;

+  char szDisplay[512];

+  char *szEnvDisplay;

+  int i, j;

+  char param[PARAM_MAX+1];

+  char *srcParam, *dstParam;

+

+  /* First, clear all preference settings */

+  memset (&pref, 0, sizeof(pref));

+  prefFile = NULL;

+

+  /* Now try and find a ~/.xwinrc file */

+  home = getenv ("HOME");

+  if (home)

+    {

+      strcpy (fname, home);

+      if (fname[strlen(fname)-1]!='/')

+	strcat (fname, "/");

+      strcat (fname, ".XWinrc");

+      

+      prefFile = fopen (fname, "r");

+      if (prefFile)

+      {

+	winDebug ("winPrefsLoadPreferences: %s\n", fname);

+      }

+    }

+

+  /* No home file found, check system default */

+  if (!prefFile)

+    {

+      char buffer[MAX_PATH];

+#ifdef RELOCATE_PROJECTROOT

+      snprintf(buffer, sizeof(buffer), "%s\\system.XWinrc", winGetBaseDir());

+#else

+      strncpy(buffer, SYSCONFDIR"/X11/system.XWinrc", sizeof(buffer));

+#endif

+      buffer[sizeof(buffer)-1] = 0;

+      prefFile = fopen (buffer, "r");

+      if (prefFile)

+      {

+	winDebug ("winPrefsLoadPreferences: %s\n", buffer);

+      }

+    }

+

+  /* If we could open it, then read the settings and close it */

+  if (prefFile)

+    {

+      parse_file (prefFile);

+      fclose (prefFile);

+    }

+

+  /* Setup a DISPLAY environment variable, need to allocate on heap */

+  /* because putenv doesn't copy the argument... Always use screen 0 */

+  winGetDisplayName(szDisplay, 0);

+  szEnvDisplay = (char *)(malloc(strlen(szDisplay)+9/*strlen("DISPLAY=")+1*/));

+  snprintf(szEnvDisplay, 512, "DISPLAY=%s", szDisplay);

+  putenv (szEnvDisplay);

+

+  /* Replace any "%display%" in menu commands with display string */

+  for (i=0; i<pref.menuItems; i++)

+    {

+      for (j=0; j<pref.menu[i].menuItems; j++)

+	{

+	  if (pref.menu[i].menuItem[j].cmd==CMD_EXEC)

+	    {

+	      srcParam = pref.menu[i].menuItem[j].param;

+	      dstParam = param;

+	      while (*srcParam) {

+		if (!strncmp(srcParam, "%display%", 9))

+		  {

+		    memcpy (dstParam, szDisplay, strlen(szDisplay));

+		    dstParam += strlen(szDisplay);

+		    srcParam += 9;

+		  }

+		else if (!strncmp(srcParam, "%logfile%", 9))

+		  {

+		    memcpy (dstParam, g_pszLogFile, strlen(g_pszLogFile));

+		    dstParam += strlen(g_pszLogFile);

+		    srcParam += 9;

+		  }

+		else

+		  {

+		    *dstParam = *srcParam;

+		    dstParam++;

+		    srcParam++;

+		  }

+	      }

+	      *dstParam = 0;

+	      strcpy (pref.menu[i].menuItem[j].param, param);

+	    } /* cmd==cmd_exec */

+	} /* for all menuitems */

+    } /* for all menus */

+

+}

+

+

+/*

+ * Check for a match of the window class to one specified in the

+ * STYLES{} section in the prefs file, and return the style type

+ */

+unsigned long

+winOverrideStyle (unsigned long longpWin)

+{

+  WindowPtr pWin = (WindowPtr) longpWin;

+  char *res_name, *res_class;

+  int i;

+  char *wmName;

+

+  if (pWin==NULL)

+    return STYLE_NONE;

+

+  /* If we can't find the class, we can't override from default! */

+  if (!winMultiWindowGetClassHint (pWin, &res_name, &res_class))

+    return STYLE_NONE;

+

+  winMultiWindowGetWMName (pWin, &wmName);

+

+  for (i=0; i<pref.styleItems; i++) {

+    if (!strcmp(pref.style[i].match, res_name) ||

+	!strcmp(pref.style[i].match, res_class) ||

+	(wmName && strstr(wmName, pref.style[i].match)))

+      {

+	free (res_name);

+	free (res_class);

+	free(wmName);

+

+	if (pref.style[i].type)

+	  return pref.style[i].type;

+      }

+  }

+

+  /* Didn't find the style, fail gracefully */

+  free (res_name);

+  free (res_class);

+  free(wmName);

+

+  return STYLE_NONE;

+}

diff --git a/xorg-server/hw/xwin/winscrinit.c b/xorg-server/hw/xwin/winscrinit.c
index 501a999a4..5273460a4 100644
--- a/xorg-server/hw/xwin/winscrinit.c
+++ b/xorg-server/hw/xwin/winscrinit.c
@@ -1,775 +1,775 @@
-/*
- *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of the XFree86 Project
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from the XFree86 Project.
- *
- * Authors:	Dakshinamurthy Karra
- *		Suhaib M Siddiqi
- *		Peter Busch
- *		Harold L Hunt II
- *		Kensuke Matsuzaki
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-#include "winmsg.h"
-
-
-#ifdef XWIN_MULTIWINDOWEXTWM
-static RootlessFrameProcsRec
-winMWExtWMProcs = {	
-  winMWExtWMCreateFrame,
-  winMWExtWMDestroyFrame,
-  
-  winMWExtWMMoveFrame,
-  winMWExtWMResizeFrame,
-  winMWExtWMRestackFrame,
-  winMWExtWMReshapeFrame,
-  winMWExtWMUnmapFrame,
-  
-  winMWExtWMStartDrawing,
-  winMWExtWMStopDrawing,
-  winMWExtWMUpdateRegion,
-#ifndef ROOTLESS_TRACK_DAMAGE
-  winMWExtWMDamageRects,
-#endif
-  winMWExtWMRootlessSwitchWindow,
-  NULL,//winMWExtWMDoReorderWindow,
-  NULL,//winMWExtWMHideWindow,
-  NULL,//winMWExtWMUpdateColorMap,
-
-  NULL,//winMWExtWMCopyBytes,
-  NULL,//winMWExtWMFillBytes,
-  NULL,//winMWExtWMCompositePixels,
-  winMWExtWMCopyWindow
-};
-#endif
-
-
-/*
- * References to external symbols
- */
-
-extern Bool                     g_fSoftwareCursor;
-
-
-/*
- * Prototypes
- */
-
-Bool
-winRandRInit (ScreenPtr pScreen);
-
-
-/*
- * Local functions
- */
-
-static Bool
-winSaveScreen (ScreenPtr pScreen, int on);
-
-
-/*
- * Determine what type of screen we are initializing
- * and call the appropriate procedure to intiailize
- * that type of screen.
- */
-
-Bool
-winScreenInit (int index,
-	       ScreenPtr pScreen,
-	       int argc, char **argv)
-{
-  winScreenInfoPtr      pScreenInfo = &g_ScreenInfo[index];
-  winPrivScreenPtr	pScreenPriv;
-  HDC			hdc;
-
-  winDebug ("winScreenInit - dwWidth: %ld dwHeight: %ld\n",
-	  pScreenInfo->dwWidth, pScreenInfo->dwHeight);
-
-  /* Allocate privates for this screen */
-  if (!winAllocatePrivates (pScreen))
-    {
-      ErrorF ("winScreenInit - Couldn't allocate screen privates\n");
-      return FALSE;
-    }
-
-  /* Get a pointer to the privates structure that was allocated */
-  pScreenPriv = winGetScreenPriv (pScreen);
-
-  /* Save a pointer to this screen in the screen info structure */
-  pScreenInfo->pScreen = pScreen;
-
-  /* Save a pointer to the screen info in the screen privates structure */
-  /* This allows us to get back to the screen info from a screen pointer */
-  pScreenPriv->pScreenInfo = pScreenInfo;
-
-  /*
-   * Determine which engine to use.
-   *
-   * NOTE: This is done once per screen because each screen possibly has
-   * a preferred engine specified on the command line.
-   */
-  if (!winSetEngine (pScreen))
-    {
-      ErrorF ("winScreenInit - winSetEngine () failed\n");
-      return FALSE;
-    }
-
-  /* Adjust the video mode for our engine type */
-  if (pScreenPriv->pwinAdjustVideoMode && !(*pScreenPriv->pwinAdjustVideoMode) (pScreen))
-    {
-      ErrorF ("winScreenInit - winAdjustVideoMode () failed\n");
-      return FALSE;
-    }
-
-  /* Check for supported display depth */
-  if (!(WIN_SUPPORTED_BPPS & (1 << (pScreenInfo->dwBPP - 1))))
-    {
-      ErrorF ("winScreenInit - Unsupported display depth: %d\n" \
-	      "Change your Windows display depth to 15, 16, 24, or 32 bits "
-	      "per pixel.\n",
-	      (int) pScreenInfo->dwBPP);
-      ErrorF ("winScreenInit - Supported depths: %08x\n",
-	      WIN_SUPPORTED_BPPS);
-#if WIN_CHECK_DEPTH
-      return FALSE;
-#endif
-    }
-
-  /*
-   * Check that all monitors have the same display depth if we are using
-   * multiple monitors
-   */
-  if (pScreenInfo->fMultipleMonitors 
-      && !GetSystemMetrics (SM_SAMEDISPLAYFORMAT))
-    {
-      ErrorF ("winScreenInit - Monitors do not all have same pixel format / "
-	      "display depth.\n"
-	      "Using primary display only.\n");
-      pScreenInfo->fMultipleMonitors = FALSE;
-    }
-
-  /* Create display window */
-  if (pScreenPriv->pwinCreateBoundingWindow && !(*pScreenPriv->pwinCreateBoundingWindow) (pScreen))
-    {
-      ErrorF ("winScreenInit - pwinCreateBoundingWindow () "
-	      "failed\n");
-      return FALSE;
-    }
-
-  /* Get a device context */
-  hdc = GetDC (pScreenPriv->hwndScreen);
-
-  /* Store the initial height, width, and depth of the display */
-  /* Are we using multiple monitors? */
-  if (pScreenInfo->fMultipleMonitors)
-    {
-      pScreenPriv->dwLastWindowsWidth = GetSystemMetrics (SM_CXVIRTUALSCREEN);
-      pScreenPriv->dwLastWindowsHeight = GetSystemMetrics (SM_CYVIRTUALSCREEN);
-
-      /* 
-       * In this case, some of the defaults set in
-       * winInitializeScreenDefaults() are not correct ...
-       */
-      if (!pScreenInfo->fUserGaveHeightAndWidth)
-	{
-	  pScreenInfo->dwWidth = GetSystemMetrics (SM_CXVIRTUALSCREEN);
-	  pScreenInfo->dwHeight = GetSystemMetrics (SM_CYVIRTUALSCREEN);
-	  pScreenInfo->dwWidth_mm = (pScreenInfo->dwWidth /
-				     WIN_DEFAULT_DPI) * 25.4;
-	  pScreenInfo->dwHeight_mm = (pScreenInfo->dwHeight /
-				      WIN_DEFAULT_DPI) * 25.4;
-	}
-    }
-  else
-    {
-      pScreenPriv->dwLastWindowsWidth = GetSystemMetrics (SM_CXSCREEN);
-      pScreenPriv->dwLastWindowsHeight = GetSystemMetrics (SM_CYSCREEN);
-    }
-
-  /* Save the original bits per pixel */
-  pScreenPriv->dwLastWindowsBitsPixel = GetDeviceCaps (hdc, BITSPIXEL);
-
-  /* Release the device context */
-  ReleaseDC (pScreenPriv->hwndScreen, hdc);
-    
-  /* Clear the visuals list */
-  miClearVisualTypes ();
-  
-  /* Set the padded screen width */
-  pScreenInfo->dwPaddedWidth = PixmapBytePad (pScreenInfo->dwWidth,
-					      pScreenInfo->dwBPP);
-
-  /* Call the engine dependent screen initialization procedure */
-  if (pScreenPriv->pwinFinishScreenInit && !((*pScreenPriv->pwinFinishScreenInit) (index, pScreen, argc, argv)))
-    {
-      ErrorF ("winScreenInit - winFinishScreenInit () failed\n");
-      return FALSE;
-    }
-
-  if (!g_fSoftwareCursor)
-    winInitCursor(pScreen);
-#ifdef WINDBG
-  else
-    winDebug("winScreenInit - Using software cursor\n");  
-#endif
-
-  /*
-     Note the screen origin in a normalized coordinate space where (0,0) is at the top left
-     of the native virtual desktop area
-  */
-  dixScreenOrigins[index].x = pScreenInfo->dwInitialX - GetSystemMetrics(SM_XVIRTUALSCREEN);
-  dixScreenOrigins[index].y = pScreenInfo->dwInitialY - GetSystemMetrics(SM_YVIRTUALSCREEN);
-
-  winDebug("Screen %d added at virtual desktop coordinate (%d,%d).\n",
-            index, dixScreenOrigins[index].x, dixScreenOrigins[index].y);
-  winDebug ("winScreenInit - returning\n");
-
-  return TRUE;
-}
-
-static Bool
-winCreateScreenResources(ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  Bool result;
-
-  result = pScreenPriv->pwinCreateScreenResources(pScreen);
-
-  /* Now the screen bitmap has been wrapped in a pixmap,
-     add that to the Shadow framebuffer */
-  if (!shadowAdd(pScreen, pScreen->devPrivate,
-		 pScreenPriv->pwinShadowUpdate, NULL, 0, 0))
-    {
-      ErrorF ("winCreateScreenResources - shadowAdd () failed\n");
-      return FALSE;
-    }
-
-  return result;
-}
-
-/* See Porting Layer Definition - p. 20 */
-Bool
-winFinishScreenInitFB (int index,
-		       ScreenPtr pScreen,
-		       int argc, char **argv)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  VisualPtr		pVisual = NULL;
-  char			*pbits = NULL;
-#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
-  int			iReturn;
-#endif
-
-  /* Create framebuffer */
-  if (!(*pScreenPriv->pwinAllocateFB) (pScreen))
-    {
-      ErrorF ("winFinishScreenInitFB - Could not allocate framebuffer\n");
-      return FALSE;
-    }
-
-  /*
-   * Grab the number of bits that are used to represent color in each pixel.
-   */
-  if (pScreenInfo->dwBPP == 8)
-    pScreenInfo->dwDepth = 8;
-  else
-    pScreenInfo->dwDepth = winCountBits (pScreenPriv->dwRedMask)
-      + winCountBits (pScreenPriv->dwGreenMask)
-      + winCountBits (pScreenPriv->dwBlueMask);
-  
-  winDebug ("winFinishScreenInitFB - Masks: %08x %08x %08x\n",
-	  (unsigned int) pScreenPriv->dwRedMask,
-	  (unsigned int) pScreenPriv->dwGreenMask,
-	  (unsigned int) pScreenPriv->dwBlueMask);
-
-  /* Init visuals */
-  if (!(*pScreenPriv->pwinInitVisuals) (pScreen))
-    {
-      ErrorF ("winFinishScreenInitFB - winInitVisuals failed\n");
-      return FALSE;
-    }
-
-  /* Setup a local variable to point to the framebuffer */
-  pbits = pScreenInfo->pfb;
-  
-  /* Apparently we need this for the render extension */
-  miSetPixmapDepths ();
-
-  /* Start fb initialization */
-  if (!fbSetupScreen (pScreen,
-		      pScreenInfo->pfb,
-		      pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-		      monitorResolution, monitorResolution,
-		      pScreenInfo->dwStride,
-		      pScreenInfo->dwBPP))
-    {
-      ErrorF ("winFinishScreenInitFB - fbSetupScreen failed\n");
-      return FALSE;
-    }
-
-  /* Override default colormap routines if visual class is dynamic */
-  if (pScreenInfo->dwDepth == 8
-      && (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI
-	  || (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL
-	      && pScreenInfo->fFullScreen)
-	  || (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD
-	      && pScreenInfo->fFullScreen)))
-    {
-      winSetColormapFunctions (pScreen);
-
-      /*
-       * NOTE: Setting whitePixel to 255 causes Magic 7.1 to allocate its
-       * own colormap, as it cannot allocate 7 planes in the default
-       * colormap.  Setting whitePixel to 1 allows Magic to get 7
-       * planes in the default colormap, so it doesn't create its
-       * own colormap.  This latter situation is highly desireable,
-       * as it keeps the Magic window viewable when switching to
-       * other X clients that use the default colormap.
-       */
-      pScreen->blackPixel = 0;
-      pScreen->whitePixel = 1;
-    }
-
-  /* Place our save screen function */
-  pScreen->SaveScreen = winSaveScreen;
-
-  /* Finish fb initialization */
-  if (!fbFinishScreenInit (pScreen,
-			   pScreenInfo->pfb,
-			   pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-			   monitorResolution, monitorResolution,
-			   pScreenInfo->dwStride,
-			   pScreenInfo->dwBPP))
-    {
-      ErrorF ("winFinishScreenInitFB - fbFinishScreenInit failed\n");
-      return FALSE;
-    }
-
-  /* Save a pointer to the root visual */
-  for (pVisual = pScreen->visuals;
-       pVisual->vid != pScreen->rootVisual;
-       pVisual++);
-  pScreenPriv->pRootVisual = pVisual;
-
-  /* 
-   * Setup points to the block and wakeup handlers.  Pass a pointer
-   * to the current screen as pWakeupdata.
-   */
-  pScreen->BlockHandler = winBlockHandler;
-  pScreen->WakeupHandler = winWakeupHandler;
-  pScreen->blockData = pScreen;
-  pScreen->wakeupData = pScreen;
-
-  /* Render extension initialization, calls miPictureInit */
-  if (!fbPictureInit (pScreen, NULL, 0))
-    {
-      ErrorF ("winFinishScreenInitFB - fbPictureInit () failed\n");
-      return FALSE;
-    }
-
-#ifdef RANDR
-  /* Initialize resize and rotate support */
-  if (!winRandRInit (pScreen))
-    {
-      ErrorF ("winFinishScreenInitFB - winRandRInit () failed\n");
-      return FALSE;
-    }
-#endif
-
-  /*
-   * Backing store support should reduce network traffic and increase
-   * performance.
-   */
-  miInitializeBackingStore (pScreen);
-
-  /* KDrive does miDCInitialize right after miInitializeBackingStore */
-  /* Setup the cursor routines */
-  winDebug ("winFinishScreenInitFB - Calling miDCInitialize ()\n");
-  miDCInitialize (pScreen, &g_winPointerCursorFuncs);
-
-  /* KDrive does winCreateDefColormap right after miDCInitialize */
-  /* Create a default colormap */
-  winDebug ("winFinishScreenInitFB - Calling winCreateDefColormap ()\n");
-  if (!winCreateDefColormap (pScreen))
-    {
-      ErrorF ("winFinishScreenInitFB - Could not create colormap\n");
-      return FALSE;
-    }
-
-  /* Initialize the shadow framebuffer layer */
-  if ((pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI
-       || pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD
-       || pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL)
-#ifdef XWIN_MULTIWINDOWEXTWM
-      && !pScreenInfo->fMWExtWM
-#endif
-      )
-    {
-      winDebug ("winFinishScreenInitFB - Calling shadowSetup ()\n");
-      if (!shadowSetup(pScreen))
-	{
-	  ErrorF ("winFinishScreenInitFB - shadowSetup () failed\n");
-	  return FALSE;
-	}
-
-      /* Wrap CreateScreenResources so we can add the screen pixmap
-         to the Shadow framebuffer after it's been created */
-      pScreenPriv->pwinCreateScreenResources = pScreen->CreateScreenResources;
-      pScreen->CreateScreenResources = winCreateScreenResources;
-    }
-
-#ifdef XWIN_MULTIWINDOWEXTWM
-  /* Handle multi-window external window manager mode */
-  if (pScreenInfo->fMWExtWM)
-    {
-      winDebug ("winScreenInit - MultiWindowExtWM - Calling RootlessInit\n");
-      
-      RootlessInit(pScreen, &winMWExtWMProcs);
-      
-      winDebug ("winScreenInit - MultiWindowExtWM - RootlessInit returned\n");
-      
-      rootless_CopyBytes_threshold = 0;
-      rootless_FillBytes_threshold = 0;
-      rootless_CompositePixels_threshold = 0;
-      /* FIXME: How many? Profiling needed? */
-      rootless_CopyWindow_threshold = 1;
-
-      winWindowsWMExtensionInit ();
-    }
-#endif
-
-  /* Handle rootless mode */
-  if (pScreenInfo->fRootless)
-    {
-      /* Define the WRAP macro temporarily for local use */
-#define WRAP(a) \
-    if (pScreen->a) { \
-        pScreenPriv->a = pScreen->a; \
-    } else { \
-        ErrorF("null screen fn " #a "\n"); \
-        pScreenPriv->a = NULL; \
-    }
-
-      /* Save a pointer to each lower-level window procedure */
-      WRAP(CreateWindow);
-      WRAP(DestroyWindow);
-      WRAP(RealizeWindow);
-      WRAP(UnrealizeWindow);
-      WRAP(PositionWindow);
-      WRAP(ChangeWindowAttributes);
-      WRAP(SetShape);
-
-      /* Assign rootless window procedures to be top level procedures */
-      pScreen->CreateWindow = winCreateWindowRootless;
-      pScreen->DestroyWindow = winDestroyWindowRootless;
-      pScreen->PositionWindow = winPositionWindowRootless;
-      /*pScreen->ChangeWindowAttributes = winChangeWindowAttributesRootless;*/
-      pScreen->RealizeWindow = winMapWindowRootless;
-      pScreen->UnrealizeWindow = winUnmapWindowRootless;
-      pScreen->SetShape = winSetShapeRootless;
-
-      /* Undefine the WRAP macro, as it is not needed elsewhere */
-#undef WRAP
-    }
-
-
-#ifdef XWIN_MULTIWINDOW
-  /* Handle multi window mode */
-  else if (pScreenInfo->fMultiWindow)
-    {
-      /* Define the WRAP macro temporarily for local use */
-#define WRAP(a) \
-    if (pScreen->a) { \
-        pScreenPriv->a = pScreen->a; \
-    } else { \
-        ErrorF("null screen fn " #a "\n"); \
-        pScreenPriv->a = NULL; \
-    }
-
-      /* Save a pointer to each lower-level window procedure */
-      WRAP(CreateWindow);
-      WRAP(DestroyWindow);
-      WRAP(RealizeWindow);
-      WRAP(UnrealizeWindow);
-      WRAP(PositionWindow);
-      WRAP(ChangeWindowAttributes);
-      WRAP(ReparentWindow);
-      WRAP(RestackWindow);
-      WRAP(ResizeWindow);
-      WRAP(MoveWindow);
-      WRAP(CopyWindow);
-      WRAP(SetShape);
-
-      /* Assign multi-window window procedures to be top level procedures */
-      pScreen->CreateWindow = winCreateWindowMultiWindow;
-      pScreen->DestroyWindow = winDestroyWindowMultiWindow;
-      pScreen->PositionWindow = winPositionWindowMultiWindow;
-      /*pScreen->ChangeWindowAttributes = winChangeWindowAttributesMultiWindow;*/
-      pScreen->RealizeWindow = winMapWindowMultiWindow;
-      pScreen->UnrealizeWindow = winUnmapWindowMultiWindow;
-      pScreen->ReparentWindow = winReparentWindowMultiWindow;
-      pScreen->RestackWindow = winRestackWindowMultiWindow;
-      pScreen->ResizeWindow = winResizeWindowMultiWindow;
-      pScreen->MoveWindow = winMoveWindowMultiWindow;
-      pScreen->CopyWindow = winCopyWindowMultiWindow;
-      pScreen->SetShape = winSetShapeMultiWindow;
-
-      /* Undefine the WRAP macro, as it is not needed elsewhere */
-#undef WRAP
-    }
-#endif
-
-  /* Wrap either fb's or shadow's CloseScreen with our CloseScreen */
-  pScreenPriv->CloseScreen = pScreen->CloseScreen;
-  pScreen->CloseScreen = pScreenPriv->pwinCloseScreen;
-
-#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
-  /* Create a mutex for modules in separate threads to wait for */
-  iReturn = pthread_mutex_init (&pScreenPriv->pmServerStarted, NULL);
-  if (iReturn != 0)
-    {
-      ErrorF ("winFinishScreenInitFB - pthread_mutex_init () failed: %d\n",
-	      iReturn);
-      return FALSE;
-    }
-
-  /* Own the mutex for modules in separate threads */
-  iReturn = pthread_mutex_lock (&pScreenPriv->pmServerStarted);
-  if (iReturn != 0)
-    {
-      ErrorF ("winFinishScreenInitFB - pthread_mutex_lock () failed: %d\n",
-	      iReturn);
-      return FALSE;
-    }
-
-  /* Set the ServerStarted flag to false */
-  pScreenPriv->fServerStarted = FALSE;
-#endif
-
-#ifdef XWIN_MULTIWINDOWEXTWM
-  pScreenPriv->fRestacking = FALSE;
-#endif
-
-#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
-  if (FALSE
-#ifdef XWIN_MULTIWINDOW
-      || pScreenInfo->fMultiWindow
-#endif
-#ifdef XWIN_MULTIWINDOWEXTWM
-      || pScreenInfo->fInternalWM
-#endif
-      )
-    { 
-      winDebug ("winFinishScreenInitFB - Calling winInitWM.\n");
-
-      /* Initialize multi window mode */
-      if (!winInitWM (&pScreenPriv->pWMInfo,
-		      &pScreenPriv->ptWMProc,
-		      &pScreenPriv->ptXMsgProc,
-		      &pScreenPriv->pmServerStarted,
-		      pScreenInfo->dwScreen,
-		      (HWND)&pScreenPriv->hwndScreen,
-#ifdef XWIN_MULTIWINDOWEXTWM
-		      pScreenInfo->fInternalWM ||
-#endif
-		      FALSE))
-        {
-          ErrorF ("winFinishScreenInitFB - winInitWM () failed.\n");
-          return FALSE;
-        }
-    }      
-#endif
-
-  /* Tell the server that we are enabled */
-  pScreenPriv->fEnabled = TRUE;
-
-  /* Tell the server that we have a valid depth */
-  pScreenPriv->fBadDepth = FALSE;
-
-  winDebug ("winFinishScreenInitFB - returning\n");
-
-  return TRUE;
-}
-
-#ifdef XWIN_NATIVEGDI
-/* See Porting Layer Definition - p. 20 */
-
-Bool
-winFinishScreenInitNativeGDI (int index,
-			      ScreenPtr pScreen,
-			      int argc, char **argv)
-{
-  winScreenPriv(pScreen);
-  winScreenInfoPtr      pScreenInfo = &g_ScreenInfo[index];
-  VisualPtr		pVisuals = NULL;
-  DepthPtr		pDepths = NULL;
-  VisualID		rootVisual = 0;
-  int			nVisuals = 0, nDepths = 0, nRootDepth = 0;
-
-  /* Ignore user input (mouse, keyboard) */
-  pScreenInfo->fIgnoreInput = FALSE;
-
-  /* Get device contexts for the screen and shadow bitmap */
-  pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);
-  if (pScreenPriv->hdcScreen == NULL)
-    FatalError ("winFinishScreenInitNativeGDI - Couldn't get a DC\n");
-
-  /* Init visuals */
-  if (!(*pScreenPriv->pwinInitVisuals) (pScreen))
-    {
-      ErrorF ("winFinishScreenInitNativeGDI - pwinInitVisuals failed\n");
-      return FALSE;
-    }
-
-  /* Initialize the mi visuals */
-  if (!miInitVisuals (&pVisuals, &pDepths, &nVisuals, &nDepths, &nRootDepth,
-		      &rootVisual,
-		      ((unsigned long)1 << (pScreenInfo->dwDepth - 1)), 8,
-		      TrueColor))
-    {
-      ErrorF ("winFinishScreenInitNativeGDI - miInitVisuals () failed\n");
-      return FALSE;
-    }
-
-  /* Initialize the CloseScreen procedure pointer */
-  pScreen->CloseScreen = NULL;
-
-  /* Initialize the mi code */
-  if (!miScreenInit (pScreen,
-		     NULL, /* No framebuffer */
-		     pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-		     monitorResolution, monitorResolution,
-		     pScreenInfo->dwStride,
-		     nRootDepth, nDepths, pDepths, rootVisual,
-		     nVisuals, pVisuals))
-    {
-      ErrorF ("winFinishScreenInitNativeGDI - miScreenInit failed\n");
-      return FALSE;
-    }
-
-  pScreen->defColormap = FakeClientID(0);
-
-  /*
-   * Register our block and wakeup handlers; these procedures
-   * process messages in our Windows message queue; specifically,
-   * they process mouse and keyboard input.
-   */
-  pScreen->BlockHandler = winBlockHandler;
-  pScreen->WakeupHandler = winWakeupHandler;
-  pScreen->blockData = pScreen;
-  pScreen->wakeupData = pScreen;
-
-  /* Place our save screen function */
-  pScreen->SaveScreen = winSaveScreen;
-
-  /* Pixmaps */
-  pScreen->CreatePixmap = winCreatePixmapNativeGDI;
-  pScreen->DestroyPixmap = winDestroyPixmapNativeGDI;
-
-  /* Other Screen Routines */
-  pScreen->QueryBestSize = winQueryBestSizeNativeGDI;
-  pScreen->SaveScreen = winSaveScreen;  
-  pScreen->GetImage = miGetImage;
-  pScreen->GetSpans = winGetSpansNativeGDI;
-
-  /* Window Procedures */
-  pScreen->CreateWindow = winCreateWindowNativeGDI;
-  pScreen->DestroyWindow = winDestroyWindowNativeGDI;
-  pScreen->PositionWindow = winPositionWindowNativeGDI;
-  /*pScreen->ChangeWindowAttributes = winChangeWindowAttributesNativeGDI;*/
-  pScreen->RealizeWindow = winMapWindowNativeGDI;
-  pScreen->UnrealizeWindow = winUnmapWindowNativeGDI;
-
-  /* Paint window */
-  pScreen->CopyWindow = winCopyWindowNativeGDI;
-
-  /* Fonts */
-  pScreen->RealizeFont = winRealizeFontNativeGDI;
-  pScreen->UnrealizeFont = winUnrealizeFontNativeGDI;
-
-  /* GC */
-  pScreen->CreateGC = winCreateGCNativeGDI;
-
-  /* Colormap Routines */
-  pScreen->CreateColormap = miInitializeColormap;
-  pScreen->DestroyColormap = (DestroyColormapProcPtr) (void (*)(void)) NoopDDA;
-  pScreen->InstallColormap = miInstallColormap;
-  pScreen->UninstallColormap = miUninstallColormap;
-  pScreen->ListInstalledColormaps = miListInstalledColormaps;
-  pScreen->StoreColors = (StoreColorsProcPtr) (void (*)(void)) NoopDDA;
-  pScreen->ResolveColor = miResolveColor;
-
-  /* Bitmap */
-  pScreen->BitmapToRegion = winPixmapToRegionNativeGDI;
-
-  winDebug ("winFinishScreenInitNativeGDI - calling miDCInitialize\n");
-
-  /* Set the default white and black pixel positions */
-  pScreen->whitePixel = pScreen->blackPixel = (Pixel) 0;
-
-  /* Initialize the cursor */
-  if (!miDCInitialize (pScreen, &g_winPointerCursorFuncs))
-    {
-      ErrorF ("winFinishScreenInitNativeGDI - miDCInitialize failed\n");
-      return FALSE;
-    }
-  
-  /* Create a default colormap */
-  if (!miCreateDefColormap (pScreen))
-    {
-        ErrorF ("winFinishScreenInitNativeGDI - miCreateDefColormap () "
-		"failed\n");
-	return FALSE;
-    }
-
-  winDebug ("winFinishScreenInitNativeGDI - miCreateDefColormap () "
-	  "returned\n");
-  
-  /* mi doesn't use a CloseScreen procedure, so no need to wrap */
-  pScreen->CloseScreen = pScreenPriv->pwinCloseScreen;
-
-  /* Tell the server that we are enabled */
-  pScreenPriv->fEnabled = TRUE;
-
-  winDebug ("winFinishScreenInitNativeGDI - Successful addition of "
-	  "screen %08x\n",
-	  (unsigned int) pScreen);
-
-  return TRUE;
-}
-#endif
-
-
-/* See Porting Layer Definition - p. 33 */
-static Bool
-winSaveScreen (ScreenPtr pScreen, int on)
-{
-  return TRUE;
-}
+/*

+ *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of the XFree86 Project

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from the XFree86 Project.

+ *

+ * Authors:	Dakshinamurthy Karra

+ *		Suhaib M Siddiqi

+ *		Peter Busch

+ *		Harold L Hunt II

+ *		Kensuke Matsuzaki

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+#include "winmsg.h"

+

+

+#ifdef XWIN_MULTIWINDOWEXTWM

+static RootlessFrameProcsRec

+winMWExtWMProcs = {	

+  winMWExtWMCreateFrame,

+  winMWExtWMDestroyFrame,

+  

+  winMWExtWMMoveFrame,

+  winMWExtWMResizeFrame,

+  winMWExtWMRestackFrame,

+  winMWExtWMReshapeFrame,

+  winMWExtWMUnmapFrame,

+  

+  winMWExtWMStartDrawing,

+  winMWExtWMStopDrawing,

+  winMWExtWMUpdateRegion,

+#ifndef ROOTLESS_TRACK_DAMAGE

+  winMWExtWMDamageRects,

+#endif

+  winMWExtWMRootlessSwitchWindow,

+  NULL,//winMWExtWMDoReorderWindow,

+  NULL,//winMWExtWMHideWindow,

+  NULL,//winMWExtWMUpdateColorMap,

+

+  NULL,//winMWExtWMCopyBytes,

+  NULL,//winMWExtWMFillBytes,

+  NULL,//winMWExtWMCompositePixels,

+  winMWExtWMCopyWindow

+};

+#endif

+

+

+/*

+ * References to external symbols

+ */

+

+extern Bool                     g_fSoftwareCursor;

+

+

+/*

+ * Prototypes

+ */

+

+Bool

+winRandRInit (ScreenPtr pScreen);

+

+

+/*

+ * Local functions

+ */

+

+static Bool

+winSaveScreen (ScreenPtr pScreen, int on);

+

+

+/*

+ * Determine what type of screen we are initializing

+ * and call the appropriate procedure to intiailize

+ * that type of screen.

+ */

+

+Bool

+winScreenInit (int index,

+	       ScreenPtr pScreen,

+	       int argc, char **argv)

+{

+  winScreenInfoPtr      pScreenInfo = &g_ScreenInfo[index];

+  winPrivScreenPtr	pScreenPriv;

+  HDC			hdc;

+

+  winDebug ("winScreenInit - dwWidth: %ld dwHeight: %ld\n",

+	  pScreenInfo->dwWidth, pScreenInfo->dwHeight);

+

+  /* Allocate privates for this screen */

+  if (!winAllocatePrivates (pScreen))

+    {

+      ErrorF ("winScreenInit - Couldn't allocate screen privates\n");

+      return FALSE;

+    }

+

+  /* Get a pointer to the privates structure that was allocated */

+  pScreenPriv = winGetScreenPriv (pScreen);

+

+  /* Save a pointer to this screen in the screen info structure */

+  pScreenInfo->pScreen = pScreen;

+

+  /* Save a pointer to the screen info in the screen privates structure */

+  /* This allows us to get back to the screen info from a screen pointer */

+  pScreenPriv->pScreenInfo = pScreenInfo;

+

+  /*

+   * Determine which engine to use.

+   *

+   * NOTE: This is done once per screen because each screen possibly has

+   * a preferred engine specified on the command line.

+   */

+  if (!winSetEngine (pScreen))

+    {

+      ErrorF ("winScreenInit - winSetEngine () failed\n");

+      return FALSE;

+    }

+

+  /* Adjust the video mode for our engine type */

+  if (pScreenPriv->pwinAdjustVideoMode && !(*pScreenPriv->pwinAdjustVideoMode) (pScreen))

+    {

+      ErrorF ("winScreenInit - winAdjustVideoMode () failed\n");

+      return FALSE;

+    }

+

+  /* Check for supported display depth */

+  if (!(WIN_SUPPORTED_BPPS & (1 << (pScreenInfo->dwBPP - 1))))

+    {

+      ErrorF ("winScreenInit - Unsupported display depth: %d\n" \

+	      "Change your Windows display depth to 15, 16, 24, or 32 bits "

+	      "per pixel.\n",

+	      (int) pScreenInfo->dwBPP);

+      ErrorF ("winScreenInit - Supported depths: %08x\n",

+	      WIN_SUPPORTED_BPPS);

+#if WIN_CHECK_DEPTH

+      return FALSE;

+#endif

+    }

+

+  /*

+   * Check that all monitors have the same display depth if we are using

+   * multiple monitors

+   */

+  if (pScreenInfo->fMultipleMonitors 

+      && !GetSystemMetrics (SM_SAMEDISPLAYFORMAT))

+    {

+      ErrorF ("winScreenInit - Monitors do not all have same pixel format / "

+	      "display depth.\n"

+	      "Using primary display only.\n");

+      pScreenInfo->fMultipleMonitors = FALSE;

+    }

+

+  /* Create display window */

+  if (pScreenPriv->pwinCreateBoundingWindow && !(*pScreenPriv->pwinCreateBoundingWindow) (pScreen))

+    {

+      ErrorF ("winScreenInit - pwinCreateBoundingWindow () "

+	      "failed\n");

+      return FALSE;

+    }

+

+  /* Get a device context */

+  hdc = GetDC (pScreenPriv->hwndScreen);

+

+  /* Store the initial height, width, and depth of the display */

+  /* Are we using multiple monitors? */

+  if (pScreenInfo->fMultipleMonitors)

+    {

+      pScreenPriv->dwLastWindowsWidth = GetSystemMetrics (SM_CXVIRTUALSCREEN);

+      pScreenPriv->dwLastWindowsHeight = GetSystemMetrics (SM_CYVIRTUALSCREEN);

+

+      /* 

+       * In this case, some of the defaults set in

+       * winInitializeScreenDefaults() are not correct ...

+       */

+      if (!pScreenInfo->fUserGaveHeightAndWidth)

+	{

+	  pScreenInfo->dwWidth = GetSystemMetrics (SM_CXVIRTUALSCREEN);

+	  pScreenInfo->dwHeight = GetSystemMetrics (SM_CYVIRTUALSCREEN);

+	  pScreenInfo->dwWidth_mm = (pScreenInfo->dwWidth /

+				     WIN_DEFAULT_DPI) * 25.4;

+	  pScreenInfo->dwHeight_mm = (pScreenInfo->dwHeight /

+				      WIN_DEFAULT_DPI) * 25.4;

+	}

+    }

+  else

+    {

+      pScreenPriv->dwLastWindowsWidth = GetSystemMetrics (SM_CXSCREEN);

+      pScreenPriv->dwLastWindowsHeight = GetSystemMetrics (SM_CYSCREEN);

+    }

+

+  /* Save the original bits per pixel */

+  pScreenPriv->dwLastWindowsBitsPixel = GetDeviceCaps (hdc, BITSPIXEL);

+

+  /* Release the device context */

+  ReleaseDC (pScreenPriv->hwndScreen, hdc);

+    

+  /* Clear the visuals list */

+  miClearVisualTypes ();

+  

+  /* Set the padded screen width */

+  pScreenInfo->dwPaddedWidth = PixmapBytePad (pScreenInfo->dwWidth,

+					      pScreenInfo->dwBPP);

+

+  /* Call the engine dependent screen initialization procedure */

+  if (pScreenPriv->pwinFinishScreenInit && !((*pScreenPriv->pwinFinishScreenInit) (index, pScreen, argc, argv)))

+    {

+      ErrorF ("winScreenInit - winFinishScreenInit () failed\n");

+      return FALSE;

+    }

+

+  if (!g_fSoftwareCursor)

+    winInitCursor(pScreen);

+#ifdef WINDBG

+  else

+    winDebug("winScreenInit - Using software cursor\n");  

+#endif

+

+  /*

+     Note the screen origin in a normalized coordinate space where (0,0) is at the top left

+     of the native virtual desktop area

+  */

+  pScreen->x = pScreenInfo->dwInitialX - GetSystemMetrics(SM_XVIRTUALSCREEN);

+  pScreen->y = pScreenInfo->dwInitialY - GetSystemMetrics(SM_YVIRTUALSCREEN);

+

+  winDebug("Screen %d added at virtual desktop coordinate (%d,%d).\n",

+         index, pScreen->x, pScreen->y);

+  winDebug ("winScreenInit - returning\n");

+

+  return TRUE;

+}

+

+static Bool

+winCreateScreenResources(ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  Bool result;

+

+  result = pScreenPriv->pwinCreateScreenResources(pScreen);

+

+  /* Now the screen bitmap has been wrapped in a pixmap,

+     add that to the Shadow framebuffer */

+  if (!shadowAdd(pScreen, pScreen->devPrivate,

+		 pScreenPriv->pwinShadowUpdate, NULL, 0, 0))

+    {

+      ErrorF ("winCreateScreenResources - shadowAdd () failed\n");

+      return FALSE;

+    }

+

+  return result;

+}

+

+/* See Porting Layer Definition - p. 20 */

+Bool

+winFinishScreenInitFB (int index,

+		       ScreenPtr pScreen,

+		       int argc, char **argv)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  VisualPtr		pVisual = NULL;

+  char			*pbits = NULL;

+#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)

+  int			iReturn;

+#endif

+

+  /* Create framebuffer */

+  if (!(*pScreenPriv->pwinAllocateFB) (pScreen))

+    {

+      ErrorF ("winFinishScreenInitFB - Could not allocate framebuffer\n");

+      return FALSE;

+    }

+

+  /*

+   * Grab the number of bits that are used to represent color in each pixel.

+   */

+  if (pScreenInfo->dwBPP == 8)

+    pScreenInfo->dwDepth = 8;

+  else

+    pScreenInfo->dwDepth = winCountBits (pScreenPriv->dwRedMask)

+      + winCountBits (pScreenPriv->dwGreenMask)

+      + winCountBits (pScreenPriv->dwBlueMask);

+  

+  winDebug ("winFinishScreenInitFB - Masks: %08x %08x %08x\n",

+	  (unsigned int) pScreenPriv->dwRedMask,

+	  (unsigned int) pScreenPriv->dwGreenMask,

+	  (unsigned int) pScreenPriv->dwBlueMask);

+

+  /* Init visuals */

+  if (!(*pScreenPriv->pwinInitVisuals) (pScreen))

+    {

+      ErrorF ("winFinishScreenInitFB - winInitVisuals failed\n");

+      return FALSE;

+    }

+

+  /* Setup a local variable to point to the framebuffer */

+  pbits = pScreenInfo->pfb;

+  

+  /* Apparently we need this for the render extension */

+  miSetPixmapDepths ();

+

+  /* Start fb initialization */

+  if (!fbSetupScreen (pScreen,

+		      pScreenInfo->pfb,

+		      pScreenInfo->dwWidth, pScreenInfo->dwHeight,

+		      monitorResolution, monitorResolution,

+		      pScreenInfo->dwStride,

+		      pScreenInfo->dwBPP))

+    {

+      ErrorF ("winFinishScreenInitFB - fbSetupScreen failed\n");

+      return FALSE;

+    }

+

+  /* Override default colormap routines if visual class is dynamic */

+  if (pScreenInfo->dwDepth == 8

+      && (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI

+	  || (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL

+	      && pScreenInfo->fFullScreen)

+	  || (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD

+	      && pScreenInfo->fFullScreen)))

+    {

+      winSetColormapFunctions (pScreen);

+

+      /*

+       * NOTE: Setting whitePixel to 255 causes Magic 7.1 to allocate its

+       * own colormap, as it cannot allocate 7 planes in the default

+       * colormap.  Setting whitePixel to 1 allows Magic to get 7

+       * planes in the default colormap, so it doesn't create its

+       * own colormap.  This latter situation is highly desireable,

+       * as it keeps the Magic window viewable when switching to

+       * other X clients that use the default colormap.

+       */

+      pScreen->blackPixel = 0;

+      pScreen->whitePixel = 1;

+    }

+

+  /* Place our save screen function */

+  pScreen->SaveScreen = winSaveScreen;

+

+  /* Finish fb initialization */

+  if (!fbFinishScreenInit (pScreen,

+			   pScreenInfo->pfb,

+			   pScreenInfo->dwWidth, pScreenInfo->dwHeight,

+			   monitorResolution, monitorResolution,

+			   pScreenInfo->dwStride,

+			   pScreenInfo->dwBPP))

+    {

+      ErrorF ("winFinishScreenInitFB - fbFinishScreenInit failed\n");

+      return FALSE;

+    }

+

+  /* Save a pointer to the root visual */

+  for (pVisual = pScreen->visuals;

+       pVisual->vid != pScreen->rootVisual;

+       pVisual++);

+  pScreenPriv->pRootVisual = pVisual;

+

+  /* 

+   * Setup points to the block and wakeup handlers.  Pass a pointer

+   * to the current screen as pWakeupdata.

+   */

+  pScreen->BlockHandler = winBlockHandler;

+  pScreen->WakeupHandler = winWakeupHandler;

+  pScreen->blockData = pScreen;

+  pScreen->wakeupData = pScreen;

+

+  /* Render extension initialization, calls miPictureInit */

+  if (!fbPictureInit (pScreen, NULL, 0))

+    {

+      ErrorF ("winFinishScreenInitFB - fbPictureInit () failed\n");

+      return FALSE;

+    }

+

+#ifdef RANDR

+  /* Initialize resize and rotate support */

+  if (!winRandRInit (pScreen))

+    {

+      ErrorF ("winFinishScreenInitFB - winRandRInit () failed\n");

+      return FALSE;

+    }

+#endif

+

+  /*

+   * Backing store support should reduce network traffic and increase

+   * performance.

+   */

+  miInitializeBackingStore (pScreen);

+

+  /* KDrive does miDCInitialize right after miInitializeBackingStore */

+  /* Setup the cursor routines */

+  winDebug ("winFinishScreenInitFB - Calling miDCInitialize ()\n");

+  miDCInitialize (pScreen, &g_winPointerCursorFuncs);

+

+  /* KDrive does winCreateDefColormap right after miDCInitialize */

+  /* Create a default colormap */

+  winDebug ("winFinishScreenInitFB - Calling winCreateDefColormap ()\n");

+  if (!winCreateDefColormap (pScreen))

+    {

+      ErrorF ("winFinishScreenInitFB - Could not create colormap\n");

+      return FALSE;

+    }

+

+  /* Initialize the shadow framebuffer layer */

+  if ((pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI

+       || pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD

+       || pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL)

+#ifdef XWIN_MULTIWINDOWEXTWM

+      && !pScreenInfo->fMWExtWM

+#endif

+      )

+    {

+      winDebug ("winFinishScreenInitFB - Calling shadowSetup ()\n");

+      if (!shadowSetup(pScreen))

+	{

+	  ErrorF ("winFinishScreenInitFB - shadowSetup () failed\n");

+	  return FALSE;

+	}

+

+      /* Wrap CreateScreenResources so we can add the screen pixmap

+         to the Shadow framebuffer after it's been created */

+      pScreenPriv->pwinCreateScreenResources = pScreen->CreateScreenResources;

+      pScreen->CreateScreenResources = winCreateScreenResources;

+    }

+

+#ifdef XWIN_MULTIWINDOWEXTWM

+  /* Handle multi-window external window manager mode */

+  if (pScreenInfo->fMWExtWM)

+    {

+      winDebug ("winScreenInit - MultiWindowExtWM - Calling RootlessInit\n");

+      

+      RootlessInit(pScreen, &winMWExtWMProcs);

+      

+      winDebug ("winScreenInit - MultiWindowExtWM - RootlessInit returned\n");

+      

+      rootless_CopyBytes_threshold = 0;

+      rootless_FillBytes_threshold = 0;

+      rootless_CompositePixels_threshold = 0;

+      /* FIXME: How many? Profiling needed? */

+      rootless_CopyWindow_threshold = 1;

+

+      winWindowsWMExtensionInit ();

+    }

+#endif

+

+  /* Handle rootless mode */

+  if (pScreenInfo->fRootless)

+    {

+      /* Define the WRAP macro temporarily for local use */

+#define WRAP(a) \

+    if (pScreen->a) { \

+        pScreenPriv->a = pScreen->a; \

+    } else { \

+        ErrorF("null screen fn " #a "\n"); \

+        pScreenPriv->a = NULL; \

+    }

+

+      /* Save a pointer to each lower-level window procedure */

+      WRAP(CreateWindow);

+      WRAP(DestroyWindow);

+      WRAP(RealizeWindow);

+      WRAP(UnrealizeWindow);

+      WRAP(PositionWindow);

+      WRAP(ChangeWindowAttributes);

+      WRAP(SetShape);

+

+      /* Assign rootless window procedures to be top level procedures */

+      pScreen->CreateWindow = winCreateWindowRootless;

+      pScreen->DestroyWindow = winDestroyWindowRootless;

+      pScreen->PositionWindow = winPositionWindowRootless;

+      /*pScreen->ChangeWindowAttributes = winChangeWindowAttributesRootless;*/

+      pScreen->RealizeWindow = winMapWindowRootless;

+      pScreen->UnrealizeWindow = winUnmapWindowRootless;

+      pScreen->SetShape = winSetShapeRootless;

+

+      /* Undefine the WRAP macro, as it is not needed elsewhere */

+#undef WRAP

+    }

+

+

+#ifdef XWIN_MULTIWINDOW

+  /* Handle multi window mode */

+  else if (pScreenInfo->fMultiWindow)

+    {

+      /* Define the WRAP macro temporarily for local use */

+#define WRAP(a) \

+    if (pScreen->a) { \

+        pScreenPriv->a = pScreen->a; \

+    } else { \

+        ErrorF("null screen fn " #a "\n"); \

+        pScreenPriv->a = NULL; \

+    }

+

+      /* Save a pointer to each lower-level window procedure */

+      WRAP(CreateWindow);

+      WRAP(DestroyWindow);

+      WRAP(RealizeWindow);

+      WRAP(UnrealizeWindow);

+      WRAP(PositionWindow);

+      WRAP(ChangeWindowAttributes);

+      WRAP(ReparentWindow);

+      WRAP(RestackWindow);

+      WRAP(ResizeWindow);

+      WRAP(MoveWindow);

+      WRAP(CopyWindow);

+      WRAP(SetShape);

+

+      /* Assign multi-window window procedures to be top level procedures */

+      pScreen->CreateWindow = winCreateWindowMultiWindow;

+      pScreen->DestroyWindow = winDestroyWindowMultiWindow;

+      pScreen->PositionWindow = winPositionWindowMultiWindow;

+      /*pScreen->ChangeWindowAttributes = winChangeWindowAttributesMultiWindow;*/

+      pScreen->RealizeWindow = winMapWindowMultiWindow;

+      pScreen->UnrealizeWindow = winUnmapWindowMultiWindow;

+      pScreen->ReparentWindow = winReparentWindowMultiWindow;

+      pScreen->RestackWindow = winRestackWindowMultiWindow;

+      pScreen->ResizeWindow = winResizeWindowMultiWindow;

+      pScreen->MoveWindow = winMoveWindowMultiWindow;

+      pScreen->CopyWindow = winCopyWindowMultiWindow;

+      pScreen->SetShape = winSetShapeMultiWindow;

+

+      /* Undefine the WRAP macro, as it is not needed elsewhere */

+#undef WRAP

+    }

+#endif

+

+  /* Wrap either fb's or shadow's CloseScreen with our CloseScreen */

+  pScreenPriv->CloseScreen = pScreen->CloseScreen;

+  pScreen->CloseScreen = pScreenPriv->pwinCloseScreen;

+

+#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)

+  /* Create a mutex for modules in separate threads to wait for */

+  iReturn = pthread_mutex_init (&pScreenPriv->pmServerStarted, NULL);

+  if (iReturn != 0)

+    {

+      ErrorF ("winFinishScreenInitFB - pthread_mutex_init () failed: %d\n",

+	      iReturn);

+      return FALSE;

+    }

+

+  /* Own the mutex for modules in separate threads */

+  iReturn = pthread_mutex_lock (&pScreenPriv->pmServerStarted);

+  if (iReturn != 0)

+    {

+      ErrorF ("winFinishScreenInitFB - pthread_mutex_lock () failed: %d\n",

+	      iReturn);

+      return FALSE;

+    }

+

+  /* Set the ServerStarted flag to false */

+  pScreenPriv->fServerStarted = FALSE;

+#endif

+

+#ifdef XWIN_MULTIWINDOWEXTWM

+  pScreenPriv->fRestacking = FALSE;

+#endif

+

+#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)

+  if (FALSE

+#ifdef XWIN_MULTIWINDOW

+      || pScreenInfo->fMultiWindow

+#endif

+#ifdef XWIN_MULTIWINDOWEXTWM

+      || pScreenInfo->fInternalWM

+#endif

+      )

+    { 

+      winDebug ("winFinishScreenInitFB - Calling winInitWM.\n");

+

+      /* Initialize multi window mode */

+      if (!winInitWM (&pScreenPriv->pWMInfo,

+		      &pScreenPriv->ptWMProc,

+		      &pScreenPriv->ptXMsgProc,

+		      &pScreenPriv->pmServerStarted,

+		      pScreenInfo->dwScreen,

+		      (HWND)&pScreenPriv->hwndScreen,

+#ifdef XWIN_MULTIWINDOWEXTWM

+		      pScreenInfo->fInternalWM ||

+#endif

+		      FALSE))

+        {

+          ErrorF ("winFinishScreenInitFB - winInitWM () failed.\n");

+          return FALSE;

+        }

+    }      

+#endif

+

+  /* Tell the server that we are enabled */

+  pScreenPriv->fEnabled = TRUE;

+

+  /* Tell the server that we have a valid depth */

+  pScreenPriv->fBadDepth = FALSE;

+

+  winDebug ("winFinishScreenInitFB - returning\n");

+

+  return TRUE;

+}

+

+#ifdef XWIN_NATIVEGDI

+/* See Porting Layer Definition - p. 20 */

+

+Bool

+winFinishScreenInitNativeGDI (int index,

+			      ScreenPtr pScreen,

+			      int argc, char **argv)

+{

+  winScreenPriv(pScreen);

+  winScreenInfoPtr      pScreenInfo = &g_ScreenInfo[index];

+  VisualPtr		pVisuals = NULL;

+  DepthPtr		pDepths = NULL;

+  VisualID		rootVisual = 0;

+  int			nVisuals = 0, nDepths = 0, nRootDepth = 0;

+

+  /* Ignore user input (mouse, keyboard) */

+  pScreenInfo->fIgnoreInput = FALSE;

+

+  /* Get device contexts for the screen and shadow bitmap */

+  pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);

+  if (pScreenPriv->hdcScreen == NULL)

+    FatalError ("winFinishScreenInitNativeGDI - Couldn't get a DC\n");

+

+  /* Init visuals */

+  if (!(*pScreenPriv->pwinInitVisuals) (pScreen))

+    {

+      ErrorF ("winFinishScreenInitNativeGDI - pwinInitVisuals failed\n");

+      return FALSE;

+    }

+

+  /* Initialize the mi visuals */

+  if (!miInitVisuals (&pVisuals, &pDepths, &nVisuals, &nDepths, &nRootDepth,

+		      &rootVisual,

+		      ((unsigned long)1 << (pScreenInfo->dwDepth - 1)), 8,

+		      TrueColor))

+    {

+      ErrorF ("winFinishScreenInitNativeGDI - miInitVisuals () failed\n");

+      return FALSE;

+    }

+

+  /* Initialize the CloseScreen procedure pointer */

+  pScreen->CloseScreen = NULL;

+

+  /* Initialize the mi code */

+  if (!miScreenInit (pScreen,

+		     NULL, /* No framebuffer */

+		     pScreenInfo->dwWidth, pScreenInfo->dwHeight,

+		     monitorResolution, monitorResolution,

+		     pScreenInfo->dwStride,

+		     nRootDepth, nDepths, pDepths, rootVisual,

+		     nVisuals, pVisuals))

+    {

+      ErrorF ("winFinishScreenInitNativeGDI - miScreenInit failed\n");

+      return FALSE;

+    }

+

+  pScreen->defColormap = FakeClientID(0);

+

+  /*

+   * Register our block and wakeup handlers; these procedures

+   * process messages in our Windows message queue; specifically,

+   * they process mouse and keyboard input.

+   */

+  pScreen->BlockHandler = winBlockHandler;

+  pScreen->WakeupHandler = winWakeupHandler;

+  pScreen->blockData = pScreen;

+  pScreen->wakeupData = pScreen;

+

+  /* Place our save screen function */

+  pScreen->SaveScreen = winSaveScreen;

+

+  /* Pixmaps */

+  pScreen->CreatePixmap = winCreatePixmapNativeGDI;

+  pScreen->DestroyPixmap = winDestroyPixmapNativeGDI;

+

+  /* Other Screen Routines */

+  pScreen->QueryBestSize = winQueryBestSizeNativeGDI;

+  pScreen->SaveScreen = winSaveScreen;  

+  pScreen->GetImage = miGetImage;

+  pScreen->GetSpans = winGetSpansNativeGDI;

+

+  /* Window Procedures */

+  pScreen->CreateWindow = winCreateWindowNativeGDI;

+  pScreen->DestroyWindow = winDestroyWindowNativeGDI;

+  pScreen->PositionWindow = winPositionWindowNativeGDI;

+  /*pScreen->ChangeWindowAttributes = winChangeWindowAttributesNativeGDI;*/

+  pScreen->RealizeWindow = winMapWindowNativeGDI;

+  pScreen->UnrealizeWindow = winUnmapWindowNativeGDI;

+

+  /* Paint window */

+  pScreen->CopyWindow = winCopyWindowNativeGDI;

+

+  /* Fonts */

+  pScreen->RealizeFont = winRealizeFontNativeGDI;

+  pScreen->UnrealizeFont = winUnrealizeFontNativeGDI;

+

+  /* GC */

+  pScreen->CreateGC = winCreateGCNativeGDI;

+

+  /* Colormap Routines */

+  pScreen->CreateColormap = miInitializeColormap;

+  pScreen->DestroyColormap = (DestroyColormapProcPtr) (void (*)(void)) NoopDDA;

+  pScreen->InstallColormap = miInstallColormap;

+  pScreen->UninstallColormap = miUninstallColormap;

+  pScreen->ListInstalledColormaps = miListInstalledColormaps;

+  pScreen->StoreColors = (StoreColorsProcPtr) (void (*)(void)) NoopDDA;

+  pScreen->ResolveColor = miResolveColor;

+

+  /* Bitmap */

+  pScreen->BitmapToRegion = winPixmapToRegionNativeGDI;

+

+  winDebug ("winFinishScreenInitNativeGDI - calling miDCInitialize\n");

+

+  /* Set the default white and black pixel positions */

+  pScreen->whitePixel = pScreen->blackPixel = (Pixel) 0;

+

+  /* Initialize the cursor */

+  if (!miDCInitialize (pScreen, &g_winPointerCursorFuncs))

+    {

+      ErrorF ("winFinishScreenInitNativeGDI - miDCInitialize failed\n");

+      return FALSE;

+    }

+  

+  /* Create a default colormap */

+  if (!miCreateDefColormap (pScreen))

+    {

+        ErrorF ("winFinishScreenInitNativeGDI - miCreateDefColormap () "

+		"failed\n");

+	return FALSE;

+    }

+

+  winDebug ("winFinishScreenInitNativeGDI - miCreateDefColormap () "

+	  "returned\n");

+  

+  /* mi doesn't use a CloseScreen procedure, so no need to wrap */

+  pScreen->CloseScreen = pScreenPriv->pwinCloseScreen;

+

+  /* Tell the server that we are enabled */

+  pScreenPriv->fEnabled = TRUE;

+

+  winDebug ("winFinishScreenInitNativeGDI - Successful addition of "

+	  "screen %08x\n",

+	  (unsigned int) pScreen);

+

+  return TRUE;

+}

+#endif

+

+

+/* See Porting Layer Definition - p. 33 */

+static Bool

+winSaveScreen (ScreenPtr pScreen, int on)

+{

+  return TRUE;

+}

diff --git a/xorg-server/hw/xwin/winsetsp.c b/xorg-server/hw/xwin/winsetsp.c
index 674e147d4..d1803489a 100644
--- a/xorg-server/hw/xwin/winsetsp.c
+++ b/xorg-server/hw/xwin/winsetsp.c
@@ -1,191 +1,191 @@
-/*
- *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of the XFree86 Project
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from the XFree86 Project.
- *
- * Authors:	Harold L Hunt II
- * 		Alan Hourihane <alanh@fairlite.demon.co.uk>
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-
-typedef struct mybitmap
-{
+/*

+ *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of the XFree86 Project

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from the XFree86 Project.

+ *

+ * Authors:	Harold L Hunt II

+ * 		Alan Hourihane <alanh@fairlite.demon.co.uk>

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+

+typedef struct mybitmap

+{

   BITMAPINFOHEADER bmiHeader;

   RGBQUAD          bmiColors[256];  /* Maximum palette used in case of 8-bit per pixel */

-} mybitmap_t;
-
-/* See Porting Layer Definition - p. 55 */
-void
-winSetSpansNativeGDI (DrawablePtr	pDrawable,
-		      GCPtr		pGC,
-		      char		*pSrcs,
-		      DDXPointPtr	pPoints,
-		      int		*piWidths,
-		      int		iSpans,
-		      int		fSorted)
-{
-  winGCPriv(pGC);
-  PixmapPtr		pPixmap = NULL;
-  winPrivPixmapPtr	pPixmapPriv = NULL;
-  HBITMAP		hbmpOrig = NULL;
-  mybitmap_t		bmi;
-  HRGN			hrgn = NULL, combined = NULL;
-  int			nbox;
-  BoxPtr	 	pbox;
-
-  nbox = REGION_NUM_RECTS (pGC->pCompositeClip);
-  pbox = REGION_RECTS (pGC->pCompositeClip);
-
-  if (!nbox) return;
-
-  combined = CreateRectRgn (pbox->x1, pbox->y1, pbox->x2, pbox->y2);
-  nbox--; pbox++;
-  while (nbox--)
-    {
-      hrgn = CreateRectRgn (pbox->x1, pbox->y1, pbox->x2, pbox->y2);
-      CombineRgn (combined, combined, hrgn, RGN_OR);
-      DeleteObject (hrgn);
-      hrgn = NULL;
-      pbox++;
-    }
-
-  /* Branch on the drawable type */
-  switch (pDrawable->type)
-    {
-    case DRAWABLE_PIXMAP:
-
-      SelectClipRgn (pGCPriv->hdcMem, combined);
-      DeleteObject (combined);
-      combined = NULL;
-
-      pPixmap = (PixmapPtr) pDrawable;
-      pPixmapPriv = winGetPixmapPriv (pPixmap);
-      
-      /* Select the drawable pixmap into a DC */
-      hbmpOrig = SelectObject (pGCPriv->hdcMem, pPixmapPriv->hBitmap);
-      if (hbmpOrig == NULL)
-	FatalError ("winSetSpans - DRAWABLE_PIXMAP - SelectObject () "
-		    "failed on pPixmapPriv->hBitmap\n");
-
-      while (iSpans--)
-        {
-	  ZeroMemory (&bmi, sizeof (mybitmap_t));
-	  bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
-	  bmi.bmiHeader.biWidth = *piWidths;
-	  bmi.bmiHeader.biHeight = 1;
-	  bmi.bmiHeader.biPlanes = 1;
-	  bmi.bmiHeader.biBitCount = pDrawable->depth;
-	  bmi.bmiHeader.biCompression = BI_RGB;
-
-  	  /* Setup color table for mono DIBs */
-  	  if (pDrawable->depth == 1)
-    	    {
-      	      bmi.bmiColors[1].rgbBlue = 255;
-      	      bmi.bmiColors[1].rgbGreen = 255;
-      	      bmi.bmiColors[1].rgbRed = 255;
-    	    }
-
-	  StretchDIBits (pGCPriv->hdcMem, 
-			 pPoints->x, pPoints->y,
-			 *piWidths, 1,
-			 0, 0,
-			 *piWidths, 1,
-			 pSrcs,
-			 (BITMAPINFO*)&bmi,
-			 DIB_RGB_COLORS,
-			 g_copyROP[pGC->alu]);
-
-	  pSrcs += PixmapBytePad (*piWidths, pDrawable->depth);
-	  pPoints++;
-	  piWidths++;
-        }
-      
-      /* Reset the clip region */
-      SelectClipRgn (pGCPriv->hdcMem, NULL);
-
-      /* Push the drawable pixmap out of the GC HDC */
-      SelectObject (pGCPriv->hdcMem, hbmpOrig);
-      break;
-
-    case DRAWABLE_WINDOW:
-
-      SelectClipRgn (pGCPriv->hdc, combined);
-      DeleteObject (combined);
-      combined = NULL;
-
-      while (iSpans--)
-        {
-	  ZeroMemory (&bmi, sizeof (mybitmap_t));
-	  bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
-	  bmi.bmiHeader.biWidth = *piWidths;
-	  bmi.bmiHeader.biHeight = 1;
-	  bmi.bmiHeader.biPlanes = 1;
-	  bmi.bmiHeader.biBitCount = pDrawable->depth;
-	  bmi.bmiHeader.biCompression = BI_RGB;
-
-  	  /* Setup color table for mono DIBs */
-  	  if (pDrawable->depth == 1)
-    	    {
-      	      bmi.bmiColors[1].rgbBlue = 255;
-      	      bmi.bmiColors[1].rgbGreen = 255;
-      	      bmi.bmiColors[1].rgbRed = 255;
-    	    }
-
-	  StretchDIBits (pGCPriv->hdc, 
-			 pPoints->x, pPoints->y,
-			 *piWidths, 1,
-			 0, 0,
-			 *piWidths, 1,
-			 pSrcs,
-			 (BITMAPINFO *) &bmi,
-			 DIB_RGB_COLORS,
-			 g_copyROP[pGC->alu]);
-
-	  pSrcs += PixmapBytePad (*piWidths, pDrawable->depth);
-	  pPoints++;
-	  piWidths++;
-        }
-
-      /* Reset the clip region */
-      SelectClipRgn (pGCPriv->hdc, NULL);
-      break;
-
-    case UNDRAWABLE_WINDOW:
-      FatalError ("\nwinSetSpansNativeGDI - UNDRAWABLE_WINDOW\n\n");
-      break;
-
-    case DRAWABLE_BUFFER:
-      FatalError ("\nwinSetSpansNativeGDI - DRAWABLE_BUFFER\n\n");
-      break;
-      
-    default:
-      FatalError ("\nwinSetSpansNativeGDI - Unknown drawable type\n\n");
-      break;
-    }
-}
+} mybitmap_t;

+

+/* See Porting Layer Definition - p. 55 */

+void

+winSetSpansNativeGDI (DrawablePtr	pDrawable,

+		      GCPtr		pGC,

+		      char		*pSrcs,

+		      DDXPointPtr	pPoints,

+		      int		*piWidths,

+		      int		iSpans,

+		      int		fSorted)

+{

+  winGCPriv(pGC);

+  PixmapPtr		pPixmap = NULL;

+  winPrivPixmapPtr	pPixmapPriv = NULL;

+  HBITMAP		hbmpOrig = NULL;

+  mybitmap_t		bmi;

+  HRGN			hrgn = NULL, combined = NULL;

+  int			nbox;

+  BoxPtr	 	pbox;

+

+  nbox = RegionNumRects (pGC->pCompositeClip);

+  pbox = RegionRects (pGC->pCompositeClip);

+

+  if (!nbox) return;

+

+  combined = CreateRectRgn (pbox->x1, pbox->y1, pbox->x2, pbox->y2);

+  nbox--; pbox++;

+  while (nbox--)

+    {

+      hrgn = CreateRectRgn (pbox->x1, pbox->y1, pbox->x2, pbox->y2);

+      CombineRgn (combined, combined, hrgn, RGN_OR);

+      DeleteObject (hrgn);

+      hrgn = NULL;

+      pbox++;

+    }

+

+  /* Branch on the drawable type */

+  switch (pDrawable->type)

+    {

+    case DRAWABLE_PIXMAP:

+

+      SelectClipRgn (pGCPriv->hdcMem, combined);

+      DeleteObject (combined);

+      combined = NULL;

+

+      pPixmap = (PixmapPtr) pDrawable;

+      pPixmapPriv = winGetPixmapPriv (pPixmap);

+      

+      /* Select the drawable pixmap into a DC */

+      hbmpOrig = SelectObject (pGCPriv->hdcMem, pPixmapPriv->hBitmap);

+      if (hbmpOrig == NULL)

+	FatalError ("winSetSpans - DRAWABLE_PIXMAP - SelectObject () "

+		    "failed on pPixmapPriv->hBitmap\n");

+

+      while (iSpans--)

+        {

+	  ZeroMemory (&bmi, sizeof (mybitmap_t));

+	  bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);

+	  bmi.bmiHeader.biWidth = *piWidths;

+	  bmi.bmiHeader.biHeight = 1;

+	  bmi.bmiHeader.biPlanes = 1;

+	  bmi.bmiHeader.biBitCount = pDrawable->depth;

+	  bmi.bmiHeader.biCompression = BI_RGB;

+

+  	  /* Setup color table for mono DIBs */

+  	  if (pDrawable->depth == 1)

+    	    {

+      	      bmi.bmiColors[1].rgbBlue = 255;

+      	      bmi.bmiColors[1].rgbGreen = 255;

+      	      bmi.bmiColors[1].rgbRed = 255;

+    	    }

+

+	  StretchDIBits (pGCPriv->hdcMem, 

+			 pPoints->x, pPoints->y,

+			 *piWidths, 1,

+			 0, 0,

+			 *piWidths, 1,

+			 pSrcs,

+			 (BITMAPINFO*)&bmi,

+			 DIB_RGB_COLORS,

+			 g_copyROP[pGC->alu]);

+

+	  pSrcs += PixmapBytePad (*piWidths, pDrawable->depth);

+	  pPoints++;

+	  piWidths++;

+        }

+      

+      /* Reset the clip region */

+      SelectClipRgn (pGCPriv->hdcMem, NULL);

+

+      /* Push the drawable pixmap out of the GC HDC */

+      SelectObject (pGCPriv->hdcMem, hbmpOrig);

+      break;

+

+    case DRAWABLE_WINDOW:

+

+      SelectClipRgn (pGCPriv->hdc, combined);

+      DeleteObject (combined);

+      combined = NULL;

+

+      while (iSpans--)

+        {

+	  ZeroMemory (&bmi, sizeof (mybitmap_t));

+	  bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);

+	  bmi.bmiHeader.biWidth = *piWidths;

+	  bmi.bmiHeader.biHeight = 1;

+	  bmi.bmiHeader.biPlanes = 1;

+	  bmi.bmiHeader.biBitCount = pDrawable->depth;

+	  bmi.bmiHeader.biCompression = BI_RGB;

+

+  	  /* Setup color table for mono DIBs */

+  	  if (pDrawable->depth == 1)

+    	    {

+      	      bmi.bmiColors[1].rgbBlue = 255;

+      	      bmi.bmiColors[1].rgbGreen = 255;

+      	      bmi.bmiColors[1].rgbRed = 255;

+    	    }

+

+	  StretchDIBits (pGCPriv->hdc, 

+			 pPoints->x, pPoints->y,

+			 *piWidths, 1,

+			 0, 0,

+			 *piWidths, 1,

+			 pSrcs,

+			 (BITMAPINFO *) &bmi,

+			 DIB_RGB_COLORS,

+			 g_copyROP[pGC->alu]);

+

+	  pSrcs += PixmapBytePad (*piWidths, pDrawable->depth);

+	  pPoints++;

+	  piWidths++;

+        }

+

+      /* Reset the clip region */

+      SelectClipRgn (pGCPriv->hdc, NULL);

+      break;

+

+    case UNDRAWABLE_WINDOW:

+      FatalError ("\nwinSetSpansNativeGDI - UNDRAWABLE_WINDOW\n\n");

+      break;

+

+    case DRAWABLE_BUFFER:

+      FatalError ("\nwinSetSpansNativeGDI - DRAWABLE_BUFFER\n\n");

+      break;

+      

+    default:

+      FatalError ("\nwinSetSpansNativeGDI - Unknown drawable type\n\n");

+      break;

+    }

+}

diff --git a/xorg-server/hw/xwin/winshaddd.c b/xorg-server/hw/xwin/winshaddd.c
index 4d82ef714..4644a8493 100644
--- a/xorg-server/hw/xwin/winshaddd.c
+++ b/xorg-server/hw/xwin/winshaddd.c
@@ -1,1413 +1,1413 @@
-/*
- *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of the XFree86 Project
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from the XFree86 Project.
- *
- * Authors:	Dakshinamurthy Karra
- *		Suhaib M Siddiqi
- *		Peter Busch
- *		Harold L Hunt II
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-
-
-/*
- * External symbols
- */
-
-extern HWND			g_hDlgExit;
-extern const char *g_pszLogFile;
-
-
-
-/*
- * Local prototypes
- */
-
-static Bool
-winAllocateFBShadowDD (ScreenPtr pScreen);
-
-static void
-winShadowUpdateDD (ScreenPtr pScreen, 
-		   shadowBufPtr pBuf);
-
-static Bool
-winCloseScreenShadowDD (int nIndex, ScreenPtr pScreen);
-
-static Bool
-winInitVisualsShadowDD (ScreenPtr pScreen);
-
-static Bool
-winAdjustVideoModeShadowDD (ScreenPtr pScreen);
-
-static Bool
-winBltExposedRegionsShadowDD (ScreenPtr pScreen);
-
-static Bool
-winActivateAppShadowDD (ScreenPtr pScreen);
-
-static Bool
-winRedrawScreenShadowDD (ScreenPtr pScreen);
-
-static Bool
-winRealizeInstalledPaletteShadowDD (ScreenPtr pScreen);
-
-static Bool
-winInstallColormapShadowDD (ColormapPtr pColormap);
-
-static Bool
-winStoreColorsShadowDD (ColormapPtr pmap, 
-			int ndef,
-			xColorItem *pdefs);
-
-static Bool
-winCreateColormapShadowDD (ColormapPtr pColormap);
-
-static Bool
-winDestroyColormapShadowDD (ColormapPtr pColormap);
-
-static Bool
-winCreatePrimarySurfaceShadowDD (ScreenPtr pScreen);
-
-static Bool
-winReleasePrimarySurfaceShadowDD (ScreenPtr pScreen);
-
-
-/*
- * Create the primary surface and attach the clipper.
- * Used for both the initial surface creation and during
- * WM_DISPLAYCHANGE messages.
- */
-
-static Bool
-winCreatePrimarySurfaceShadowDD (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  HRESULT		ddrval = DD_OK;
-  DDSURFACEDESC		ddsd;
-
-  /* Describe the primary surface */
-  ZeroMemory (&ddsd, sizeof (ddsd));
-  ddsd.dwSize = sizeof (ddsd);
-  ddsd.dwFlags = DDSD_CAPS;
-  ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
-  
-  /* Create the primary surface */
-  ddrval = IDirectDraw2_CreateSurface (pScreenPriv->pdd2,
-				       &ddsd,
-				       &pScreenPriv->pddsPrimary,
-				       NULL);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winCreatePrimarySurfaceShadowDD - Could not create primary "
-	      "surface: %08x\n", (unsigned int) ddrval);
-      return FALSE;
-    }
-  
-  winDebug ("winCreatePrimarySurfaceShadowDD - Created primary surface\n");
-
-  /*
-   * Attach a clipper to the primary surface that will clip our blits to our
-   * display window.
-   */
-  ddrval = IDirectDrawSurface2_SetClipper (pScreenPriv->pddsPrimary,
-					   pScreenPriv->pddcPrimary);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winCreatePrimarySurfaceShadowDD - Primary attach clipper "
-	      "failed: %08x\n",
-	      (unsigned int) ddrval);
-      return FALSE;
-    }
-
-  winDebug ("winCreatePrimarySurfaceShadowDD - Attached clipper to "
-	  "primary surface\n");
-
-  /* Everything was correct */
-  return TRUE;
-}
-
-
-/*
- * Detach the clipper and release the primary surface.
- * Called from WM_DISPLAYCHANGE.
- */
-
-static Bool
-winReleasePrimarySurfaceShadowDD (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-
-  winDebug ("winReleasePrimarySurfaceShadowDD - Hello\n");
-
-  /* Release the primary surface and clipper, if they exist */
-  if (pScreenPriv->pddsPrimary)
-    {
-      /*
-       * Detach the clipper from the primary surface.
-       * NOTE: We do this explicity for clarity.  The Clipper is not released.
-       */
-      IDirectDrawSurface2_SetClipper (pScreenPriv->pddsPrimary,
-				      NULL);
-
-      winDebug ("winReleasePrimarySurfaceShadowDD - Detached clipper\n");
-
-      /* Release the primary surface */
-      IDirectDrawSurface2_Release (pScreenPriv->pddsPrimary);
-      pScreenPriv->pddsPrimary = NULL;
-    }
-
-  winDebug ("winReleasePrimarySurfaceShadowDD - Released primary surface\n");
-
-  return TRUE;
-}
-
-
-/*
- * Create a DirectDraw surface for the shadow framebuffer; also create
- * a primary surface object so we can blit to the display.
- * 
- * Install a DirectDraw clipper on our primary surface object
- * that clips our blits to the unobscured client area of our display window.
- */
-
-static Bool
-winAllocateFBShadowDD (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;  
-  HRESULT		ddrval = DD_OK;
-  DDSURFACEDESC		ddsd;
-  DDSURFACEDESC		*pddsdShadow = NULL;
-
-  winDebug ("winAllocateFBShadowDD\n");
-
-  /* Create a clipper */
-  ddrval = (*g_fpDirectDrawCreateClipper) (0,
-					   &pScreenPriv->pddcPrimary,
-					   NULL);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winAllocateFBShadowDD - Could not create clipper: %08x\n",
-	      (unsigned int) ddrval);
-      return FALSE;
-    }
-
-  winDebug ("winAllocateFBShadowDD - Created a clipper\n");
-
-  /* Get a device context for the screen  */
-  pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);
-
-  /* Attach the clipper to our display window */
-  ddrval = IDirectDrawClipper_SetHWnd (pScreenPriv->pddcPrimary,
-				       0,
-				       pScreenPriv->hwndScreen);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winAllocateFBShadowDD - Clipper not attached to "
-	      "window: %08x\n",
-	      (unsigned int) ddrval);
-      return FALSE;
-    }
-
-  winDebug ("winAllocateFBShadowDD - Attached clipper to window\n");
-
-  /* Create a DirectDraw object, store the address at lpdd */
-  ddrval = (*g_fpDirectDrawCreate) (NULL, &pScreenPriv->pdd, NULL);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winAllocateFBShadowDD - Could not start DirectDraw: %08x\n",
-	      (unsigned int) ddrval);
-      return FALSE;
-    }
-
-  winDebug ("winAllocateFBShadowDD () - Created and initialized DD\n");
-
-  /* Get a DirectDraw2 interface pointer */
-  ddrval = IDirectDraw_QueryInterface (pScreenPriv->pdd,
-				       &IID_IDirectDraw2,
-				       (LPVOID*) &pScreenPriv->pdd2);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winAllocateFBShadowDD - Failed DD2 query: %08x\n",
-	      (unsigned int) ddrval);
-      return FALSE;
-    }
-
-  /* Are we full screen? */
-  if (pScreenInfo->fFullScreen)
-    {
-      DDSURFACEDESC	ddsdCurrent;
-      DWORD		dwRefreshRateCurrent = 0;
-      HDC		hdc = NULL;
-
-      /* Set the cooperative level to full screen */
-      ddrval = IDirectDraw2_SetCooperativeLevel (pScreenPriv->pdd2,
-						 pScreenPriv->hwndScreen,
-						 DDSCL_EXCLUSIVE
-						 | DDSCL_FULLSCREEN);
-      if (FAILED (ddrval))
-	{
-	  ErrorF ("winAllocateFBShadowDD - Could not set "
-		  "cooperative level: %08x\n",
-		  (unsigned int) ddrval);
-	  return FALSE;
-	}
-
-      /*
-       * We only need to get the current refresh rate for comparison
-       * if a refresh rate has been passed on the command line.
-       */
-      if (pScreenInfo->dwRefreshRate != 0)
-	{
-	  ZeroMemory (&ddsdCurrent, sizeof (ddsdCurrent));
-	  ddsdCurrent.dwSize = sizeof (ddsdCurrent);
-	  
-	  /* Get information about current display settings */
-	  ddrval = IDirectDraw2_GetDisplayMode (pScreenPriv->pdd2,
-						&ddsdCurrent);
-	  if (FAILED (ddrval))
-	    {
-	      ErrorF ("winAllocateFBShadowDD - Could not get current "
-		      "refresh rate: %08x.  Continuing.\n",
-		      (unsigned int) ddrval);
-	      dwRefreshRateCurrent = 0;
-	    }
-	  else
-	    {
-	      /* Grab the current refresh rate */
-	      dwRefreshRateCurrent = ddsdCurrent.u2.dwRefreshRate;
-	    }
-	}
-
-      /* Clean up the refresh rate */
-      if (dwRefreshRateCurrent == pScreenInfo->dwRefreshRate)
-	{
-	  /*
-	   * Refresh rate is non-specified or equal to current.
-	   */
-	  pScreenInfo->dwRefreshRate = 0;
-	}
-
-      /* Grab a device context for the screen */
-      hdc = GetDC (NULL);
-      if (hdc == NULL)
-	{
-	  ErrorF ("winAllocateFBShadowDD - GetDC () failed\n");
-	  return FALSE;
-	}
-
-      /* Only change the video mode when different than current mode */
-      if (!pScreenInfo->fMultipleMonitors
-	  && (pScreenInfo->dwWidth != GetSystemMetrics (SM_CXSCREEN)
-	      || pScreenInfo->dwHeight != GetSystemMetrics (SM_CYSCREEN)
-	      || pScreenInfo->dwBPP != GetDeviceCaps (hdc, BITSPIXEL)
-	      || pScreenInfo->dwRefreshRate != 0))
-	{
-	  winDebug ("winAllocateFBShadowDD - Changing video mode\n");
-
-	  /* Change the video mode to the mode requested, and use the driver default refresh rate on failure */
-	  ddrval = IDirectDraw2_SetDisplayMode (pScreenPriv->pdd2,
-						pScreenInfo->dwWidth,
-						pScreenInfo->dwHeight,
-						pScreenInfo->dwBPP,
-						pScreenInfo->dwRefreshRate,
-						0);
-	  if (FAILED (ddrval))
-	    {
-	      ErrorF ("winAllocateFBShadowDD - Could not set "\
-		      "full screen display mode: %08x\n",
-		      (unsigned int) ddrval);
-	      ErrorF ("winAllocateFBShadowDD - Using default driver refresh rate\n");
-	      ddrval = IDirectDraw2_SetDisplayMode (pScreenPriv->pdd2,
-						    pScreenInfo->dwWidth,
-						    pScreenInfo->dwHeight,
-						    pScreenInfo->dwBPP,
-						    0,
-						    0);
-	      if (FAILED(ddrval))
-		{
-			ErrorF ("winAllocateFBShadowDD - Could not set default refresh rate "
-				"full screen display mode: %08x\n",
-				(unsigned int) ddrval);
-			return FALSE;
-		}
-	    }
-	}
-      else
-	{
-	  winDebug ("winAllocateFBShadowDD - Not changing video mode\n");
-	}
-
-      /* Release our DC */
-      ReleaseDC (NULL, hdc);
-      hdc = NULL;
-    }
-  else
-    {
-      /* Set the cooperative level for windowed mode */
-      ddrval = IDirectDraw2_SetCooperativeLevel (pScreenPriv->pdd2,
-						 pScreenPriv->hwndScreen,
-						 DDSCL_NORMAL);
-      if (FAILED (ddrval))
-	{
-	  ErrorF ("winAllocateFBShadowDD - Could not set "\
-		  "cooperative level: %08x\n",
-		  (unsigned int) ddrval);
-	  return FALSE;
-	}
-    }
-
-  /* Create the primary surface */
-  if (!winCreatePrimarySurfaceShadowDD (pScreen))
-    {
-      ErrorF ("winAllocateFBShadowDD - winCreatePrimarySurfaceShadowDD "
-	      "failed\n");
-      return FALSE;
-    }
-
-  /* Describe the shadow surface to be created */
-  /* NOTE: Do not use a DDSCAPS_VIDEOMEMORY surface,
-   * as drawing, locking, and unlocking take forever
-   * with video memory surfaces.  In addition,
-   * video memory is a somewhat scarce resource,
-   * so you shouldn't be allocating video memory when
-   * you have the option of using system memory instead.
-   */
-  ZeroMemory (&ddsd, sizeof (ddsd));
-  ddsd.dwSize = sizeof (ddsd);
-  ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
-  ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
-  ddsd.dwHeight = pScreenInfo->dwHeight;
-  ddsd.dwWidth = pScreenInfo->dwWidth;
-
-  /* Create the shadow surface */
-  ddrval = IDirectDraw2_CreateSurface (pScreenPriv->pdd2,
-				       &ddsd,
-				       &pScreenPriv->pddsShadow,
-				       NULL);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winAllocateFBShadowDD - Could not create shadow "\
-	      "surface: %08x\n", (unsigned int) ddrval);
-      return FALSE;
-    }
-  
-  winDebug ("winAllocateFBShadowDD - Created shadow\n");
-
-  /* Allocate a DD surface description for our screen privates */
-  pddsdShadow = pScreenPriv->pddsdShadow = malloc (sizeof (DDSURFACEDESC));
-  if (pddsdShadow == NULL)
-    {
-      ErrorF ("winAllocateFBShadowDD - Could not allocate surface "\
-	      "description memory\n");
-      return FALSE;
-    }
-  ZeroMemory (pddsdShadow, sizeof (*pddsdShadow));
-  pddsdShadow->dwSize = sizeof (*pddsdShadow);
-
-  winDebug ("winAllocateFBShadowDD - Locking shadow\n");
-
-  /* Lock the shadow surface */
-  ddrval = IDirectDrawSurface2_Lock (pScreenPriv->pddsShadow,
-				     NULL,
-				     pddsdShadow,
-				     DDLOCK_WAIT,
-				     NULL);
-  if (FAILED (ddrval) || pddsdShadow->lpSurface == NULL)
-    {
-      ErrorF ("winAllocateFBShadowDD - Could not lock shadow "\
-	      "surface: %08x\n", (unsigned int) ddrval);
-      return FALSE;
-    }
-
-  winDebug ("winAllocateFBShadowDD - Locked shadow\n");
-
-  /* We don't know how to deal with anything other than RGB */
-  if (!(pddsdShadow->ddpfPixelFormat.dwFlags & DDPF_RGB))
-    {
-      ErrorF ("winAllocateFBShadowDD - Color format other than RGB\n");
-      return FALSE;
-    }
-
-  /* Grab the pitch from the surface desc */
-  pScreenInfo->dwStride = (pddsdShadow->u1.lPitch * 8)
-    / pScreenInfo->dwBPP;
-
-  /* Save the pointer to our surface memory */
-  pScreenInfo->pfb = pddsdShadow->lpSurface;
-  
-  /* Grab the color depth and masks from the surface description */
-  pScreenPriv->dwRedMask = pddsdShadow->ddpfPixelFormat.u2.dwRBitMask;
-  pScreenPriv->dwGreenMask = pddsdShadow->ddpfPixelFormat.u3.dwGBitMask;
-  pScreenPriv->dwBlueMask = pddsdShadow->ddpfPixelFormat.u4.dwBBitMask;
-
-  winDebug ("winAllocateFBShadowDD - Returning\n");
-
-  return TRUE;
-}
-
-
-/*
- * Transfer the damaged regions of the shadow framebuffer to the display.
- */
-
-static void
-winShadowUpdateDD (ScreenPtr pScreen, 
-		   shadowBufPtr pBuf)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  RegionPtr		damage = shadowDamage(pBuf);
-  HRESULT		ddrval = DD_OK;
-  RECT			rcDest, rcSrc;
-  POINT			ptOrigin;
-  DWORD			dwBox = REGION_NUM_RECTS (damage);
-  BoxPtr		pBox = REGION_RECTS (damage);
-  HRGN			hrgnTemp = NULL, hrgnCombined = NULL;
-
-  /*
-   * Return immediately if the app is not active
-   * and we are fullscreen, or if we have a bad display depth
-   */
-  if ((!pScreenPriv->fActive && pScreenInfo->fFullScreen)
-      || pScreenPriv->fBadDepth) return;
-
-  /* Get the origin of the window in the screen coords */
-  ptOrigin.x = pScreenInfo->dwXOffset;
-  ptOrigin.y = pScreenInfo->dwYOffset;
-  MapWindowPoints (pScreenPriv->hwndScreen,
-		   HWND_DESKTOP,
-		   (LPPOINT)&ptOrigin, 1);
-
-  /* Unlock the shadow surface, so we can blit */
-  ddrval = IDirectDrawSurface2_Unlock (pScreenPriv->pddsShadow, NULL);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winShadowUpdateDD - Unlock failed\n");
-      return;
-    }
-
-  /*
-   * Handle small regions with multiple blits,
-   * handle large regions by creating a clipping region and 
-   * doing a single blit constrained to that clipping region.
-   */
-  if (pScreenInfo->dwClipUpdatesNBoxes == 0
-      || dwBox < pScreenInfo->dwClipUpdatesNBoxes)
-    {
-      /* Loop through all boxes in the damaged region */
-      while (dwBox--)
-	{
-	  /* Assign damage box to source rectangle */
-	  rcSrc.left = pBox->x1;
-	  rcSrc.top = pBox->y1;
-	  rcSrc.right = pBox->x2;
-	  rcSrc.bottom = pBox->y2;
-	  
-	  /* Calculate destination rectange */
-	  rcDest.left = ptOrigin.x + rcSrc.left;
-	  rcDest.top = ptOrigin.y + rcSrc.top;
-	  rcDest.right = ptOrigin.x + rcSrc.right;
-	  rcDest.bottom = ptOrigin.y + rcSrc.bottom;
-	  
-	  /* Blit the damaged areas */
-	  ddrval = IDirectDrawSurface2_Blt (pScreenPriv->pddsPrimary,
-					    &rcDest,
-					    pScreenPriv->pddsShadow,
-					    &rcSrc,
-					    DDBLT_WAIT,
-					    NULL);
-	  
-	  /* Get a pointer to the next box */
-	  ++pBox;
-	}
-    }
-  else
-    {
-      BoxPtr		pBoxExtents = REGION_EXTENTS (pScreen, damage);
-
-      /* Compute a GDI region from the damaged region */
-      hrgnCombined = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);
-      dwBox--;
-      pBox++;
-      while (dwBox--)
-	{
-	  hrgnTemp = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);
-	  CombineRgn (hrgnCombined, hrgnCombined, hrgnTemp, RGN_OR);
-	  DeleteObject (hrgnTemp);
-	  pBox++;
-	}  
-
-      /* Install the GDI region as a clipping region */
-      SelectClipRgn (pScreenPriv->hdcScreen, hrgnCombined);
-      DeleteObject (hrgnCombined);
-      hrgnCombined = NULL;
-
-      /* Calculating a bounding box for the source is easy */
-      rcSrc.left = pBoxExtents->x1;
-      rcSrc.top = pBoxExtents->y1;
-      rcSrc.right = pBoxExtents->x2;
-      rcSrc.bottom = pBoxExtents->y2;
-
-      /* Calculating a bounding box for the destination is trickier */
-      rcDest.left = ptOrigin.x + rcSrc.left;
-      rcDest.top = ptOrigin.y + rcSrc.top;
-      rcDest.right = ptOrigin.x + rcSrc.right;
-      rcDest.bottom = ptOrigin.y + rcSrc.bottom;
-      
-      /* Our Blt should be clipped to the invalidated region */
-      ddrval = IDirectDrawSurface2_Blt (pScreenPriv->pddsPrimary,
-					&rcDest,
-					pScreenPriv->pddsShadow,
-					&rcSrc,
-					DDBLT_WAIT,
-					NULL);
-
-      /* Reset the clip region */
-      SelectClipRgn (pScreenPriv->hdcScreen, NULL);
-    }
-
-  /* Relock the shadow surface */
-  ddrval = IDirectDrawSurface2_Lock (pScreenPriv->pddsShadow,
-				     NULL,
-				     pScreenPriv->pddsdShadow,
-				     DDLOCK_WAIT,
-				     NULL);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winShadowUpdateDD - Lock failed\n");
-      return;
-    }
-
-  /* Has our memory pointer changed? */
-  if (pScreenInfo->pfb != pScreenPriv->pddsdShadow->lpSurface)
-    {
-      extern const char *g_pszLogFile;
-      ErrorF ("winShadowUpdateDD - Memory location of the shadow "
-	      "surface has changed, trying to update the root window "
-	      "pixmap header to point to the new address.  If you get "
-	      "this message and "PROJECT_NAME" freezes or crashes "
-	      "after this message then send a problem report and your "
-	      "%s file to " BUILDERADDR "\n", g_pszLogFile);
-
-      /* Location of shadow framebuffer has changed */
-      pScreenInfo->pfb = pScreenPriv->pddsdShadow->lpSurface;
-      
-      /* Update the screen pixmap */
-      if (!(*pScreen->ModifyPixmapHeader)(pScreen->devPrivate,
-					  pScreen->width,
-					  pScreen->height,
-					  pScreen->rootDepth,
-					  BitsPerPixel (pScreen->rootDepth),
-					  PixmapBytePad (pScreenInfo->dwStride,
-							 pScreenInfo->dwBPP),
-					  pScreenInfo->pfb))
-	{
-	  ErrorF ("winShadowUpdateDD - Bits changed, could not "
-		  "notify fb.\n");
-	  return;
-	}
-    }
-}
-
-
-/*
- * Call the wrapped CloseScreen function.
- * 
- * Free our resources and private structures.
- */
-
-static Bool
-winCloseScreenShadowDD (int nIndex, ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  Bool			fReturn;
-  
-  winDebug ("winCloseScreenShadowDD - Freeing screen resources\n");
-
-  /* Flag that the screen is closed */
-  pScreenPriv->fClosed = TRUE;
-  pScreenPriv->fActive = FALSE;
-
-  /* Call the wrapped CloseScreen procedure */
-  WIN_UNWRAP(CloseScreen);
-  fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);
-
-  /* Free the screen DC */
-  ReleaseDC (pScreenPriv->hwndScreen, pScreenPriv->hdcScreen);
-
-  /* Delete the window property */
-  RemoveProp (pScreenPriv->hwndScreen, WIN_SCR_PROP);
-
-  /* Free the shadow surface, if there is one */
-  if (pScreenPriv->pddsShadow)
-    {
-      IDirectDrawSurface2_Unlock (pScreenPriv->pddsShadow, NULL);
-      IDirectDrawSurface2_Release (pScreenPriv->pddsShadow);
-      pScreenPriv->pddsShadow = NULL;
-    }
-
-  /* Detach the clipper from the primary surface and release the clipper. */
-  if (pScreenPriv->pddcPrimary)
-    {
-      /* Detach the clipper */
-      IDirectDrawSurface2_SetClipper (pScreenPriv->pddsPrimary,
-				      NULL);
-
-      /* Release the clipper object */
-      IDirectDrawClipper_Release (pScreenPriv->pddcPrimary);
-      pScreenPriv->pddcPrimary = NULL;
-    }
-
-  /* Release the primary surface, if there is one */
-  if (pScreenPriv->pddsPrimary)
-    {
-      IDirectDrawSurface2_Release (pScreenPriv->pddsPrimary);
-      pScreenPriv->pddsPrimary = NULL;
-    }
-
-  /* Free the DirectDraw2 object, if there is one */
-  if (pScreenPriv->pdd2)
-    {
-      IDirectDraw2_RestoreDisplayMode (pScreenPriv->pdd2);
-      IDirectDraw2_Release (pScreenPriv->pdd2);
-      pScreenPriv->pdd2 = NULL;
-    }
-
-  /* Free the DirectDraw object, if there is one */
-  if (pScreenPriv->pdd)
-    {
-      IDirectDraw_Release (pScreenPriv->pdd);
-      pScreenPriv->pdd = NULL;
-    }
-
-  /* Delete tray icon, if we have one */
-  if (!pScreenInfo->fNoTrayIcon)
-    winDeleteNotifyIcon (pScreenPriv);
-  
-  /* Free the exit confirmation dialog box, if it exists */
-  if (g_hDlgExit != NULL)
-    {
-      DestroyWindow (g_hDlgExit);
-      g_hDlgExit = NULL;
-    }
-
-  /* Kill our window */
-  if (pScreenPriv->hwndScreen)
-    {
-      DestroyWindow (pScreenPriv->hwndScreen);
-      pScreenPriv->hwndScreen = NULL;
-    }
-
-#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
-  /* Destroy the thread startup mutex */
-  pthread_mutex_destroy (&pScreenPriv->pmServerStarted);
-#endif
-
-  /* Kill our screeninfo's pointer to the screen */
-  pScreenInfo->pScreen = NULL;
-
-  /* Invalidate the ScreenInfo's fb pointer */
-  pScreenInfo->pfb = NULL;
-
-  /* Free the screen privates for this screen */
-  free ((pointer) pScreenPriv);
-
-  return fReturn;
-}
-
-
-/*
- * Tell mi what sort of visuals we need.
- * 
- * Generally we only need one visual, as our screen can only
- * handle one format at a time, I believe.  You may want
- * to verify that last sentence.
- */
-
-static Bool
-winInitVisualsShadowDD (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  DWORD			dwRedBits, dwGreenBits, dwBlueBits;
-
-  /* Count the number of ones in each color mask */
-  dwRedBits = winCountBits (pScreenPriv->dwRedMask);
-  dwGreenBits = winCountBits (pScreenPriv->dwGreenMask);
-  dwBlueBits = winCountBits (pScreenPriv->dwBlueMask);
-  
-  /* Store the maximum number of ones in a color mask as the bitsPerRGB */
-  if (dwRedBits == 0 || dwGreenBits == 0 || dwBlueBits == 0)
-    pScreenPriv->dwBitsPerRGB = 8;
-  else if (dwRedBits > dwGreenBits && dwRedBits > dwBlueBits)
-    pScreenPriv->dwBitsPerRGB = dwRedBits;
-  else if (dwGreenBits > dwRedBits && dwGreenBits > dwBlueBits)
-    pScreenPriv->dwBitsPerRGB = dwGreenBits;
-  else
-    pScreenPriv->dwBitsPerRGB = dwBlueBits;
-  
-  winDebug ("winInitVisualsShadowDD - Masks %08x %08x %08x BPRGB %d d %d "
-	  "bpp %d\n",
-	  (unsigned int) pScreenPriv->dwRedMask,
-	  (unsigned int) pScreenPriv->dwGreenMask,
-	  (unsigned int) pScreenPriv->dwBlueMask,
-	  (int) pScreenPriv->dwBitsPerRGB,
-	  (int) pScreenInfo->dwDepth,
-	  (int) pScreenInfo->dwBPP);
-
-  /* Create a single visual according to the Windows screen depth */
-  switch (pScreenInfo->dwDepth)
-    {
-    case 24:
-    case 16:
-    case 15:
-#if defined(XFree86Server)
-      /* Create the real visual */
-      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     TrueColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     TrueColor,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowDD - miSetVisualTypesAndMasks "
-		  "failed for TrueColor\n");
-	  return FALSE;
-	}
-
-#ifdef XWIN_EMULATEPSEUDO
-      if (!pScreenInfo->fEmulatePseudo)
-	break;
-
-      /* Setup a pseudocolor visual */
-      if (!miSetVisualTypesAndMasks (8,
-				     PseudoColorMask,
-				     8,
-				     -1,
-				     0,
-				     0,
-				     0))
-	{
-	  ErrorF ("winInitVisualsShadowDD - miSetVisualTypesAndMasks "
-		  "failed for PseudoColor\n");
-	  return FALSE;
-	}
-#endif
-#else /* XFree86Server */
-      /* Create the real visual */
-      if (!fbSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     TrueColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowDD - fbSetVisualTypesAndMasks "
-		  "failed for TrueColor\n");
-	  return FALSE;
-	}
-
-#ifdef XWIN_EMULATEPSEUDO
-      if (!pScreenInfo->fEmulatePseudo)
-	break;
-
-      /* Setup a pseudocolor visual */
-      if (!fbSetVisualTypesAndMasks (8,
-				     PseudoColorMask,
-				     8,
-				     0,
-				     0,
-				     0))
-	{
-	  ErrorF ("winInitVisualsShadowDD - fbSetVisualTypesAndMasks "
-		  "failed for PseudoColor\n");
-	  return FALSE;
-	}
-#endif
-#endif /* XFree86Server */
-      break;
-
-    case 8:
-#if defined(XFree86Server)
-      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     pScreenInfo->fFullScreen 
-				     ? PseudoColorMask : StaticColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     pScreenInfo->fFullScreen 
-				     ? PseudoColor : StaticColor,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowDD - miSetVisualTypesAndMasks "
-		  "failed\n");
-	  return FALSE;
-	}
-#else /* XFree86Server */
-      if (!fbSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     pScreenInfo->fFullScreen 
-				     ? PseudoColorMask : StaticColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowDD - fbSetVisualTypesAndMasks "
-		  "failed\n");
-	  return FALSE;
-	}
-#endif /* XFree86Server */
-      break;
-
-    default:
-      ErrorF ("winInitVisualsShadowDD - Unknown screen depth\n");
-      return FALSE;
-    }
-
-  winDebug ("winInitVisualsShadowDD - Returning\n");
-
-  return TRUE;
-}
-
-
-/*
- * Adjust the user proposed video mode
- */
-
-static Bool
-winAdjustVideoModeShadowDD (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  HDC			hdc = NULL;
-  DWORD			dwBPP;
-
-  /* We're in serious trouble if we can't get a DC */
-  hdc = GetDC (NULL);
-  if (hdc == NULL)
-    {
-      ErrorF ("winAdjustVideoModeShadowDD - GetDC () failed\n");
-      return FALSE;
-    }
-
-  /* Query GDI for current display depth */
-  dwBPP = GetDeviceCaps (hdc, BITSPIXEL);
-
-  /* DirectDraw can only change the depth in fullscreen mode */
-  if (pScreenInfo->dwBPP == WIN_DEFAULT_BPP)
-    {
-      /* No -depth parameter passed, let the user know the depth being used */
-      winDebug ("winAdjustVideoModeShadowDD - Using Windows display "
-	      "depth of %d bits per pixel\n", (int) dwBPP);
-
-      /* Use GDI's depth */
-      pScreenInfo->dwBPP = dwBPP;
-    }
-  else if (pScreenInfo->fFullScreen
-	   && pScreenInfo->dwBPP != dwBPP)
-    {
-      /* FullScreen, and GDI depth differs from -depth parameter */
-      winDebug ("winAdjustVideoModeShadowDD - FullScreen, using command line "
-	      "bpp: %d\n", (int) pScreenInfo->dwBPP);
-    }
-  else if (dwBPP != pScreenInfo->dwBPP)
-    {
-      /* Windowed, and GDI depth differs from -depth parameter */
-      winDebug ("winAdjustVideoModeShadowDD - Windowed, command line bpp: "
-	      "%d, using bpp: %d\n", (int) pScreenInfo->dwBPP, (int) dwBPP);
-
-      /* We'll use GDI's depth */
-      pScreenInfo->dwBPP = dwBPP;
-    }
-  
-  /* See if the shadow bitmap will be larger than the DIB size limit */
-  if (pScreenInfo->dwWidth * pScreenInfo->dwHeight * pScreenInfo->dwBPP
-      >= WIN_DIB_MAXIMUM_SIZE)
-    {
-      ErrorF ("winAdjustVideoModeShadowDD - Requested DirectDraw surface "
-	      "will be larger than %d MB.  The surface may fail to be "
-	      "allocated on Windows 95, 98, or Me, due to a %d MB limit in "
-	      "DIB size.  This limit does not apply to Windows NT/2000, and "
-	      "this message may be ignored on those platforms.\n",
-	      WIN_DIB_MAXIMUM_SIZE_MB, WIN_DIB_MAXIMUM_SIZE_MB);
-    }
-
-  /* Release our DC */
-  ReleaseDC (NULL, hdc);
-  return TRUE;
-}
-
-
-/*
- * Blt exposed regions to the screen
- */
-
-static Bool
-winBltExposedRegionsShadowDD (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  RECT			rcSrc, rcDest;
-  POINT			ptOrigin;
-  HDC			hdcUpdate = NULL;
-  PAINTSTRUCT		ps;
-  HRESULT		ddrval = DD_OK;
-  Bool			fReturn = TRUE;
-  Bool			fLocked = TRUE;
-  int			i;
-
-  /* BeginPaint gives us an hdc that clips to the invalidated region */
-  hdcUpdate = BeginPaint (pScreenPriv->hwndScreen, &ps);
-  if (hdcUpdate == NULL)
-    {
-      ErrorF ("winBltExposedRegionsShadowDD - BeginPaint () returned "
-	      "a NULL device context handle.  Aborting blit attempt.\n");
-      return FALSE;
-    }
-  
-  /* Unlock the shadow surface, so we can blit */
-  ddrval = IDirectDrawSurface2_Unlock (pScreenPriv->pddsShadow, NULL);
-  if (FAILED (ddrval))
-    {
-      fReturn = FALSE;
-      goto winBltExposedRegionsShadowDD_Exit;
-    }
-  else
-    {
-      /* Flag that we have unlocked the shadow surface */
-      fLocked = FALSE;
-    }
-
-  /* Get the origin of the window in the screen coords */
-  ptOrigin.x = pScreenInfo->dwXOffset;
-  ptOrigin.y = pScreenInfo->dwYOffset;
-
-  MapWindowPoints (pScreenPriv->hwndScreen,
-		   HWND_DESKTOP,
-		   (LPPOINT)&ptOrigin, 1);
-  rcDest.left = ptOrigin.x;
-  rcDest.right = ptOrigin.x + pScreenInfo->dwWidth;
-  rcDest.top = ptOrigin.y;
-  rcDest.bottom = ptOrigin.y + pScreenInfo->dwHeight;
-
-  /* Source can be enter shadow surface, as Blt should clip */
-  rcSrc.left = 0;
-  rcSrc.top = 0;
-  rcSrc.right = pScreenInfo->dwWidth;
-  rcSrc.bottom = pScreenInfo->dwHeight;
-
-  /* Try to regain the primary surface and blit again if we've lost it */
-  for (i = 0; i <= WIN_REGAIN_SURFACE_RETRIES; ++i)
-    {
-      /* Our Blt should be clipped to the invalidated region */
-      ddrval = IDirectDrawSurface2_Blt (pScreenPriv->pddsPrimary,
-					&rcDest,
-					pScreenPriv->pddsShadow,
-					&rcSrc,
-					DDBLT_WAIT,
-					NULL);
-      if (ddrval == DDERR_SURFACELOST)
-	{
-	  /* Surface was lost */
-	  ErrorF ("winBltExposedRegionsShadowDD - IDirectDrawSurface2_Blt "
-		  "reported that the primary surface was lost, "
-		  "trying to restore, retry: %d\n", i + 1);
-
-	  /* Try to restore the surface, once */
-	  ddrval = IDirectDrawSurface2_Restore (pScreenPriv->pddsPrimary);
-	  ErrorF ("winBltExposedRegionsShadowDD - "
-		  "IDirectDrawSurface2_Restore returned: ");
-	  if (ddrval == DD_OK)
-	    ErrorF ("DD_OK\n");
-	  else if (ddrval == DDERR_WRONGMODE)
-	    ErrorF ("DDERR_WRONGMODE\n");
-	  else if (ddrval == DDERR_INCOMPATIBLEPRIMARY)
-	    ErrorF ("DDERR_INCOMPATIBLEPRIMARY\n");
-	  else if (ddrval == DDERR_UNSUPPORTED)
-	    ErrorF ("DDERR_UNSUPPORTED\n");
-	  else if (ddrval == DDERR_INVALIDPARAMS)
-	    ErrorF ("DDERR_INVALIDPARAMS\n");
-	  else if (ddrval == DDERR_INVALIDOBJECT)
-	    ErrorF ("DDERR_INVALIDOBJECT\n");
-	  else
-	    ErrorF ("unknown error: %08x\n", (unsigned int) ddrval);
-
-	  /* Loop around to try the blit one more time */
-	  continue;
-	}
-      else if (FAILED (ddrval))
-	{
-	  fReturn = FALSE;
-	  ErrorF ("winBltExposedRegionsShadowDD - IDirectDrawSurface2_Blt "
-		  "failed, but surface not lost: %08x %d\n",
-		  (unsigned int) ddrval, (int) ddrval);
-	  goto winBltExposedRegionsShadowDD_Exit;
-	}
-      else
-	{
-	  /* Success, stop looping */
-	  break;
-	}
-    }
-
-  /* Relock the shadow surface */
-  ddrval = IDirectDrawSurface2_Lock (pScreenPriv->pddsShadow,
-				     NULL,
-				     pScreenPriv->pddsdShadow,
-				     DDLOCK_WAIT,
-				     NULL);
-  if (FAILED (ddrval))
-    {
-      fReturn = FALSE;
-      ErrorF ("winBltExposedRegionsShadowDD - IDirectDrawSurface2_Lock "
-	      "failed\n");
-      goto winBltExposedRegionsShadowDD_Exit;
-    }
-  else
-    {
-      /* Indicate that we have relocked the shadow surface */
-      fLocked = TRUE;
-    }
-
-  /* Has our memory pointer changed? */
-  if (pScreenInfo->pfb != pScreenPriv->pddsdShadow->lpSurface)
-    winUpdateFBPointer (pScreen,
-			pScreenPriv->pddsdShadow->lpSurface);
-
- winBltExposedRegionsShadowDD_Exit:
-  /* EndPaint frees the DC */
-  if (hdcUpdate != NULL)
-    EndPaint (pScreenPriv->hwndScreen, &ps);
-
-  /*
-   * Relock the surface if it is not locked.  We don't care if locking fails,
-   * as it will cause the server to shutdown within a few more operations.
-   */
-  if (!fLocked)
-    {
-      IDirectDrawSurface2_Lock (pScreenPriv->pddsShadow,
-				NULL,
-				pScreenPriv->pddsdShadow,
-				DDLOCK_WAIT,
-				NULL);
-
-      /* Has our memory pointer changed? */
-      if (pScreenInfo->pfb != pScreenPriv->pddsdShadow->lpSurface)
-	winUpdateFBPointer (pScreen,
-			    pScreenPriv->pddsdShadow->lpSurface);
-      
-      fLocked = TRUE;
-    }
-  return fReturn;
-}
-
-
-/*
- * Do any engine-specific appliation-activation processing
- */
-
-static Bool
-winActivateAppShadowDD (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-
-  /*
-   * Do we have a surface?
-   * Are we active?
-   * Are we fullscreen?
-   */
-  if (pScreenPriv != NULL
-      && pScreenPriv->pddsPrimary != NULL
-      && pScreenPriv->fActive)
-    {
-      /* Primary surface was lost, restore it */
-      IDirectDrawSurface2_Restore (pScreenPriv->pddsPrimary);
-    }
-
-  return TRUE;
-}
-
-
-/*
- * Reblit the shadow framebuffer to the screen.
- */
-
-static Bool
-winRedrawScreenShadowDD (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  HRESULT		ddrval = DD_OK;
-  RECT			rcSrc, rcDest;
-  POINT			ptOrigin;
-
-  /* Get the origin of the window in the screen coords */
-  ptOrigin.x = pScreenInfo->dwXOffset;
-  ptOrigin.y = pScreenInfo->dwYOffset;
-  MapWindowPoints (pScreenPriv->hwndScreen,
-		   HWND_DESKTOP,
-		   (LPPOINT)&ptOrigin, 1);
-  rcDest.left = ptOrigin.x;
-  rcDest.right = ptOrigin.x + pScreenInfo->dwWidth;
-  rcDest.top = ptOrigin.y;
-  rcDest.bottom = ptOrigin.y + pScreenInfo->dwHeight;
-
-  /* Source can be entire shadow surface, as Blt should clip for us */
-  rcSrc.left = 0;
-  rcSrc.top = 0;
-  rcSrc.right = pScreenInfo->dwWidth;
-  rcSrc.bottom = pScreenInfo->dwHeight;
-
-  /* Redraw the whole window, to take account for the new colors */
-  ddrval = IDirectDrawSurface2_Blt (pScreenPriv->pddsPrimary,
-				    &rcDest,
-				    pScreenPriv->pddsShadow,
-				    &rcSrc,
-				    DDBLT_WAIT,
-				    NULL);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winRedrawScreenShadowDD - IDirectDrawSurface_Blt () "
-	      "failed: %08x\n",
-	      (unsigned int) ddrval);
-    }
-
-  return TRUE;
-}
-
-
-/*
- * Realize the currently installed colormap
- */
-
-static Bool
-winRealizeInstalledPaletteShadowDD (ScreenPtr pScreen)
-{
-  return TRUE;
-}
-
-
-/*
- * Install the specified colormap
- */
-
-static Bool
-winInstallColormapShadowDD (ColormapPtr pColormap)
-{
-  ScreenPtr		pScreen = pColormap->pScreen;
-  winScreenPriv(pScreen);
-  winCmapPriv(pColormap);
-  HRESULT		ddrval = DD_OK;
-
-  /* Install the DirectDraw palette on the primary surface */
-  ddrval = IDirectDrawSurface2_SetPalette (pScreenPriv->pddsPrimary,
-					   pCmapPriv->lpDDPalette);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winInstallColormapShadowDD - Failed installing the "
-	      "DirectDraw palette.\n");
-      return FALSE;
-    }
-
-  /* Save a pointer to the newly installed colormap */
-  pScreenPriv->pcmapInstalled = pColormap;
-
-  return TRUE;
-}
-
-
-/*
- * Store the specified colors in the specified colormap
- */
-
-static Bool
-winStoreColorsShadowDD (ColormapPtr pColormap, 
-			int ndef,
-			xColorItem *pdefs)
-{
-  ScreenPtr		pScreen = pColormap->pScreen;
-  winScreenPriv(pScreen);
-  winCmapPriv(pColormap);
-  ColormapPtr		curpmap = pScreenPriv->pcmapInstalled;
-  HRESULT		ddrval = DD_OK;
-  
-  /* Put the X colormap entries into the Windows logical palette */
-  ddrval = IDirectDrawPalette_SetEntries (pCmapPriv->lpDDPalette,
-					  0,
-					  pdefs[0].pixel,
-					  ndef,
-					  pCmapPriv->peColors 
-					  + pdefs[0].pixel);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winStoreColorsShadowDD - SetEntries () failed\n");
-      return FALSE;
-    }
-
-  /* Don't install the DirectDraw palette if the colormap is not installed */
-  if (pColormap != curpmap)
-    {
-      return TRUE;
-    }
-
-  if (!winInstallColormapShadowDD (pColormap))
-    {
-      ErrorF ("winStoreColorsShadowDD - Failed installing colormap\n");
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-
-/*
- * Colormap initialization procedure
- */
-
-static Bool
-winCreateColormapShadowDD (ColormapPtr pColormap)
-{
-  HRESULT		ddrval = DD_OK;
-  ScreenPtr		pScreen = pColormap->pScreen;
-  winScreenPriv(pScreen);
-  winCmapPriv(pColormap);
-  
-  /* Create a DirectDraw palette */
-  ddrval = IDirectDraw2_CreatePalette (pScreenPriv->pdd,
-				       DDPCAPS_8BIT | DDPCAPS_ALLOW256,
-				       pCmapPriv->peColors,
-				       &pCmapPriv->lpDDPalette,
-				       NULL);
-  if (FAILED (ddrval))
-    {
-      ErrorF ("winCreateColormapShadowDD - CreatePalette failed\n");
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-
-/*
- * Colormap destruction procedure
- */
-
-static Bool
-winDestroyColormapShadowDD (ColormapPtr pColormap)
-{
-  winScreenPriv(pColormap->pScreen);
-  winCmapPriv(pColormap);
-  HRESULT		ddrval = DD_OK;
-
-  /*
-   * Is colormap to be destroyed the default?
-   *
-   * Non-default colormaps should have had winUninstallColormap
-   * called on them before we get here.  The default colormap
-   * will not have had winUninstallColormap called on it.  Thus,
-   * we need to handle the default colormap in a special way.
-   */
-  if (pColormap->flags & IsDefault)
-    {
-      winDebug ("winDestroyColormapShadowDD - Destroying default "
-	      "colormap\n");
-      
-      /*
-       * FIXME: Walk the list of all screens, popping the default
-       * palette out of each screen device context.
-       */
-      
-      /* Pop the palette out of the primary surface */
-      ddrval = IDirectDrawSurface2_SetPalette (pScreenPriv->pddsPrimary,
-					       NULL);
-      if (FAILED (ddrval))
-	{
-	  ErrorF ("winDestroyColormapShadowDD - Failed freeing the "
-		  "default colormap DirectDraw palette.\n");
-	  return FALSE;
-	}
-
-      /* Clear our private installed colormap pointer */
-      pScreenPriv->pcmapInstalled = NULL;
-    }
-  
-  /* Release the palette */
-  IDirectDrawPalette_Release (pCmapPriv->lpDDPalette);
- 
-  /* Invalidate the colormap privates */
-  pCmapPriv->lpDDPalette = NULL;
-
-  return TRUE;
-}
-
-
-/*
- * Set engine specific functions
- */
-
-Bool
-winSetEngineFunctionsShadowDD (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  
-  /* Set our pointers */
-  pScreenPriv->pwinAllocateFB = winAllocateFBShadowDD;
-  pScreenPriv->pwinShadowUpdate = winShadowUpdateDD;
-  pScreenPriv->pwinCloseScreen = winCloseScreenShadowDD;
-  pScreenPriv->pwinInitVisuals = winInitVisualsShadowDD;
-  pScreenPriv->pwinAdjustVideoMode = winAdjustVideoModeShadowDD;
-  if (pScreenInfo->fFullScreen)
-    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowFullScreen;
-  else
-    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowWindowed;
-  pScreenPriv->pwinFinishScreenInit = winFinishScreenInitFB;
-  pScreenPriv->pwinBltExposedRegions = winBltExposedRegionsShadowDD;
-  pScreenPriv->pwinActivateApp = winActivateAppShadowDD;
-  pScreenPriv->pwinRedrawScreen = winRedrawScreenShadowDD;
-  pScreenPriv->pwinRealizeInstalledPalette
-    = winRealizeInstalledPaletteShadowDD;
-  pScreenPriv->pwinInstallColormap = winInstallColormapShadowDD;
-  pScreenPriv->pwinStoreColors = winStoreColorsShadowDD;
-  pScreenPriv->pwinCreateColormap = winCreateColormapShadowDD;
-  pScreenPriv->pwinDestroyColormap = winDestroyColormapShadowDD;
-  pScreenPriv->pwinHotKeyAltTab = (winHotKeyAltTabProcPtr) (void (*)(void))NoopDDA;
-  pScreenPriv->pwinCreatePrimarySurface = winCreatePrimarySurfaceShadowDD;
-  pScreenPriv->pwinReleasePrimarySurface = winReleasePrimarySurfaceShadowDD;
-#ifdef XWIN_MULTIWINDOW
-  pScreenPriv->pwinFinishCreateWindowsWindow =
-    (winFinishCreateWindowsWindowProcPtr) (void (*)(void))NoopDDA;
-#endif
-
-  return TRUE;
-}
+/*

+ *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of the XFree86 Project

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from the XFree86 Project.

+ *

+ * Authors:	Dakshinamurthy Karra

+ *		Suhaib M Siddiqi

+ *		Peter Busch

+ *		Harold L Hunt II

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+

+

+/*

+ * External symbols

+ */

+

+extern HWND			g_hDlgExit;

+extern const char *g_pszLogFile;

+

+

+

+/*

+ * Local prototypes

+ */

+

+static Bool

+winAllocateFBShadowDD (ScreenPtr pScreen);

+

+static void

+winShadowUpdateDD (ScreenPtr pScreen, 

+		   shadowBufPtr pBuf);

+

+static Bool

+winCloseScreenShadowDD (int nIndex, ScreenPtr pScreen);

+

+static Bool

+winInitVisualsShadowDD (ScreenPtr pScreen);

+

+static Bool

+winAdjustVideoModeShadowDD (ScreenPtr pScreen);

+

+static Bool

+winBltExposedRegionsShadowDD (ScreenPtr pScreen);

+

+static Bool

+winActivateAppShadowDD (ScreenPtr pScreen);

+

+static Bool

+winRedrawScreenShadowDD (ScreenPtr pScreen);

+

+static Bool

+winRealizeInstalledPaletteShadowDD (ScreenPtr pScreen);

+

+static Bool

+winInstallColormapShadowDD (ColormapPtr pColormap);

+

+static Bool

+winStoreColorsShadowDD (ColormapPtr pmap, 

+			int ndef,

+			xColorItem *pdefs);

+

+static Bool

+winCreateColormapShadowDD (ColormapPtr pColormap);

+

+static Bool

+winDestroyColormapShadowDD (ColormapPtr pColormap);

+

+static Bool

+winCreatePrimarySurfaceShadowDD (ScreenPtr pScreen);

+

+static Bool

+winReleasePrimarySurfaceShadowDD (ScreenPtr pScreen);

+

+

+/*

+ * Create the primary surface and attach the clipper.

+ * Used for both the initial surface creation and during

+ * WM_DISPLAYCHANGE messages.

+ */

+

+static Bool

+winCreatePrimarySurfaceShadowDD (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  HRESULT		ddrval = DD_OK;

+  DDSURFACEDESC		ddsd;

+

+  /* Describe the primary surface */

+  ZeroMemory (&ddsd, sizeof (ddsd));

+  ddsd.dwSize = sizeof (ddsd);

+  ddsd.dwFlags = DDSD_CAPS;

+  ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

+  

+  /* Create the primary surface */

+  ddrval = IDirectDraw2_CreateSurface (pScreenPriv->pdd2,

+				       &ddsd,

+				       &pScreenPriv->pddsPrimary,

+				       NULL);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winCreatePrimarySurfaceShadowDD - Could not create primary "

+	      "surface: %08x\n", (unsigned int) ddrval);

+      return FALSE;

+    }

+  

+  winDebug ("winCreatePrimarySurfaceShadowDD - Created primary surface\n");

+

+  /*

+   * Attach a clipper to the primary surface that will clip our blits to our

+   * display window.

+   */

+  ddrval = IDirectDrawSurface2_SetClipper (pScreenPriv->pddsPrimary,

+					   pScreenPriv->pddcPrimary);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winCreatePrimarySurfaceShadowDD - Primary attach clipper "

+	      "failed: %08x\n",

+	      (unsigned int) ddrval);

+      return FALSE;

+    }

+

+  winDebug ("winCreatePrimarySurfaceShadowDD - Attached clipper to "

+	  "primary surface\n");

+

+  /* Everything was correct */

+  return TRUE;

+}

+

+

+/*

+ * Detach the clipper and release the primary surface.

+ * Called from WM_DISPLAYCHANGE.

+ */

+

+static Bool

+winReleasePrimarySurfaceShadowDD (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+

+  winDebug ("winReleasePrimarySurfaceShadowDD - Hello\n");

+

+  /* Release the primary surface and clipper, if they exist */

+  if (pScreenPriv->pddsPrimary)

+    {

+      /*

+       * Detach the clipper from the primary surface.

+       * NOTE: We do this explicity for clarity.  The Clipper is not released.

+       */

+      IDirectDrawSurface2_SetClipper (pScreenPriv->pddsPrimary,

+				      NULL);

+

+      winDebug ("winReleasePrimarySurfaceShadowDD - Detached clipper\n");

+

+      /* Release the primary surface */

+      IDirectDrawSurface2_Release (pScreenPriv->pddsPrimary);

+      pScreenPriv->pddsPrimary = NULL;

+    }

+

+  winDebug ("winReleasePrimarySurfaceShadowDD - Released primary surface\n");

+

+  return TRUE;

+}

+

+

+/*

+ * Create a DirectDraw surface for the shadow framebuffer; also create

+ * a primary surface object so we can blit to the display.

+ * 

+ * Install a DirectDraw clipper on our primary surface object

+ * that clips our blits to the unobscured client area of our display window.

+ */

+

+static Bool

+winAllocateFBShadowDD (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;  

+  HRESULT		ddrval = DD_OK;

+  DDSURFACEDESC		ddsd;

+  DDSURFACEDESC		*pddsdShadow = NULL;

+

+  winDebug ("winAllocateFBShadowDD\n");

+

+  /* Create a clipper */

+  ddrval = (*g_fpDirectDrawCreateClipper) (0,

+					   &pScreenPriv->pddcPrimary,

+					   NULL);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winAllocateFBShadowDD - Could not create clipper: %08x\n",

+	      (unsigned int) ddrval);

+      return FALSE;

+    }

+

+  winDebug ("winAllocateFBShadowDD - Created a clipper\n");

+

+  /* Get a device context for the screen  */

+  pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);

+

+  /* Attach the clipper to our display window */

+  ddrval = IDirectDrawClipper_SetHWnd (pScreenPriv->pddcPrimary,

+				       0,

+				       pScreenPriv->hwndScreen);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winAllocateFBShadowDD - Clipper not attached to "

+	      "window: %08x\n",

+	      (unsigned int) ddrval);

+      return FALSE;

+    }

+

+  winDebug ("winAllocateFBShadowDD - Attached clipper to window\n");

+

+  /* Create a DirectDraw object, store the address at lpdd */

+  ddrval = (*g_fpDirectDrawCreate) (NULL, &pScreenPriv->pdd, NULL);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winAllocateFBShadowDD - Could not start DirectDraw: %08x\n",

+	      (unsigned int) ddrval);

+      return FALSE;

+    }

+

+  winDebug ("winAllocateFBShadowDD () - Created and initialized DD\n");

+

+  /* Get a DirectDraw2 interface pointer */

+  ddrval = IDirectDraw_QueryInterface (pScreenPriv->pdd,

+				       &IID_IDirectDraw2,

+				       (LPVOID*) &pScreenPriv->pdd2);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winAllocateFBShadowDD - Failed DD2 query: %08x\n",

+	      (unsigned int) ddrval);

+      return FALSE;

+    }

+

+  /* Are we full screen? */

+  if (pScreenInfo->fFullScreen)

+    {

+      DDSURFACEDESC	ddsdCurrent;

+      DWORD		dwRefreshRateCurrent = 0;

+      HDC		hdc = NULL;

+

+      /* Set the cooperative level to full screen */

+      ddrval = IDirectDraw2_SetCooperativeLevel (pScreenPriv->pdd2,

+						 pScreenPriv->hwndScreen,

+						 DDSCL_EXCLUSIVE

+						 | DDSCL_FULLSCREEN);

+      if (FAILED (ddrval))

+	{

+	  ErrorF ("winAllocateFBShadowDD - Could not set "

+		  "cooperative level: %08x\n",

+		  (unsigned int) ddrval);

+	  return FALSE;

+	}

+

+      /*

+       * We only need to get the current refresh rate for comparison

+       * if a refresh rate has been passed on the command line.

+       */

+      if (pScreenInfo->dwRefreshRate != 0)

+	{

+	  ZeroMemory (&ddsdCurrent, sizeof (ddsdCurrent));

+	  ddsdCurrent.dwSize = sizeof (ddsdCurrent);

+	  

+	  /* Get information about current display settings */

+	  ddrval = IDirectDraw2_GetDisplayMode (pScreenPriv->pdd2,

+						&ddsdCurrent);

+	  if (FAILED (ddrval))

+	    {

+	      ErrorF ("winAllocateFBShadowDD - Could not get current "

+		      "refresh rate: %08x.  Continuing.\n",

+		      (unsigned int) ddrval);

+	      dwRefreshRateCurrent = 0;

+	    }

+	  else

+	    {

+	      /* Grab the current refresh rate */

+	      dwRefreshRateCurrent = ddsdCurrent.u2.dwRefreshRate;

+	    }

+	}

+

+      /* Clean up the refresh rate */

+      if (dwRefreshRateCurrent == pScreenInfo->dwRefreshRate)

+	{

+	  /*

+	   * Refresh rate is non-specified or equal to current.

+	   */

+	  pScreenInfo->dwRefreshRate = 0;

+	}

+

+      /* Grab a device context for the screen */

+      hdc = GetDC (NULL);

+      if (hdc == NULL)

+	{

+	  ErrorF ("winAllocateFBShadowDD - GetDC () failed\n");

+	  return FALSE;

+	}

+

+      /* Only change the video mode when different than current mode */

+      if (!pScreenInfo->fMultipleMonitors

+	  && (pScreenInfo->dwWidth != GetSystemMetrics (SM_CXSCREEN)

+	      || pScreenInfo->dwHeight != GetSystemMetrics (SM_CYSCREEN)

+	      || pScreenInfo->dwBPP != GetDeviceCaps (hdc, BITSPIXEL)

+	      || pScreenInfo->dwRefreshRate != 0))

+	{

+	  winDebug ("winAllocateFBShadowDD - Changing video mode\n");

+

+	  /* Change the video mode to the mode requested, and use the driver default refresh rate on failure */

+	  ddrval = IDirectDraw2_SetDisplayMode (pScreenPriv->pdd2,

+						pScreenInfo->dwWidth,

+						pScreenInfo->dwHeight,

+						pScreenInfo->dwBPP,

+						pScreenInfo->dwRefreshRate,

+						0);

+	  if (FAILED (ddrval))

+	    {

+	      ErrorF ("winAllocateFBShadowDD - Could not set "\

+		      "full screen display mode: %08x\n",

+		      (unsigned int) ddrval);

+	      ErrorF ("winAllocateFBShadowDD - Using default driver refresh rate\n");

+	      ddrval = IDirectDraw2_SetDisplayMode (pScreenPriv->pdd2,

+						    pScreenInfo->dwWidth,

+						    pScreenInfo->dwHeight,

+						    pScreenInfo->dwBPP,

+						    0,

+						    0);

+	      if (FAILED(ddrval))

+		{

+			ErrorF ("winAllocateFBShadowDD - Could not set default refresh rate "

+				"full screen display mode: %08x\n",

+				(unsigned int) ddrval);

+			return FALSE;

+		}

+	    }

+	}

+      else

+	{

+	  winDebug ("winAllocateFBShadowDD - Not changing video mode\n");

+	}

+

+      /* Release our DC */

+      ReleaseDC (NULL, hdc);

+      hdc = NULL;

+    }

+  else

+    {

+      /* Set the cooperative level for windowed mode */

+      ddrval = IDirectDraw2_SetCooperativeLevel (pScreenPriv->pdd2,

+						 pScreenPriv->hwndScreen,

+						 DDSCL_NORMAL);

+      if (FAILED (ddrval))

+	{

+	  ErrorF ("winAllocateFBShadowDD - Could not set "\

+		  "cooperative level: %08x\n",

+		  (unsigned int) ddrval);

+	  return FALSE;

+	}

+    }

+

+  /* Create the primary surface */

+  if (!winCreatePrimarySurfaceShadowDD (pScreen))

+    {

+      ErrorF ("winAllocateFBShadowDD - winCreatePrimarySurfaceShadowDD "

+	      "failed\n");

+      return FALSE;

+    }

+

+  /* Describe the shadow surface to be created */

+  /* NOTE: Do not use a DDSCAPS_VIDEOMEMORY surface,

+   * as drawing, locking, and unlocking take forever

+   * with video memory surfaces.  In addition,

+   * video memory is a somewhat scarce resource,

+   * so you shouldn't be allocating video memory when

+   * you have the option of using system memory instead.

+   */

+  ZeroMemory (&ddsd, sizeof (ddsd));

+  ddsd.dwSize = sizeof (ddsd);

+  ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;

+  ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;

+  ddsd.dwHeight = pScreenInfo->dwHeight;

+  ddsd.dwWidth = pScreenInfo->dwWidth;

+

+  /* Create the shadow surface */

+  ddrval = IDirectDraw2_CreateSurface (pScreenPriv->pdd2,

+				       &ddsd,

+				       &pScreenPriv->pddsShadow,

+				       NULL);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winAllocateFBShadowDD - Could not create shadow "\

+	      "surface: %08x\n", (unsigned int) ddrval);

+      return FALSE;

+    }

+  

+  winDebug ("winAllocateFBShadowDD - Created shadow\n");

+

+  /* Allocate a DD surface description for our screen privates */

+  pddsdShadow = pScreenPriv->pddsdShadow = malloc (sizeof (DDSURFACEDESC));

+  if (pddsdShadow == NULL)

+    {

+      ErrorF ("winAllocateFBShadowDD - Could not allocate surface "\

+	      "description memory\n");

+      return FALSE;

+    }

+  ZeroMemory (pddsdShadow, sizeof (*pddsdShadow));

+  pddsdShadow->dwSize = sizeof (*pddsdShadow);

+

+  winDebug ("winAllocateFBShadowDD - Locking shadow\n");

+

+  /* Lock the shadow surface */

+  ddrval = IDirectDrawSurface2_Lock (pScreenPriv->pddsShadow,

+				     NULL,

+				     pddsdShadow,

+				     DDLOCK_WAIT,

+				     NULL);

+  if (FAILED (ddrval) || pddsdShadow->lpSurface == NULL)

+    {

+      ErrorF ("winAllocateFBShadowDD - Could not lock shadow "\

+	      "surface: %08x\n", (unsigned int) ddrval);

+      return FALSE;

+    }

+

+  winDebug ("winAllocateFBShadowDD - Locked shadow\n");

+

+  /* We don't know how to deal with anything other than RGB */

+  if (!(pddsdShadow->ddpfPixelFormat.dwFlags & DDPF_RGB))

+    {

+      ErrorF ("winAllocateFBShadowDD - Color format other than RGB\n");

+      return FALSE;

+    }

+

+  /* Grab the pitch from the surface desc */

+  pScreenInfo->dwStride = (pddsdShadow->u1.lPitch * 8)

+    / pScreenInfo->dwBPP;

+

+  /* Save the pointer to our surface memory */

+  pScreenInfo->pfb = pddsdShadow->lpSurface;

+  

+  /* Grab the color depth and masks from the surface description */

+  pScreenPriv->dwRedMask = pddsdShadow->ddpfPixelFormat.u2.dwRBitMask;

+  pScreenPriv->dwGreenMask = pddsdShadow->ddpfPixelFormat.u3.dwGBitMask;

+  pScreenPriv->dwBlueMask = pddsdShadow->ddpfPixelFormat.u4.dwBBitMask;

+

+  winDebug ("winAllocateFBShadowDD - Returning\n");

+

+  return TRUE;

+}

+

+

+/*

+ * Transfer the damaged regions of the shadow framebuffer to the display.

+ */

+

+static void

+winShadowUpdateDD (ScreenPtr pScreen, 

+		   shadowBufPtr pBuf)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  RegionPtr		damage = shadowDamage(pBuf);

+  HRESULT		ddrval = DD_OK;

+  RECT			rcDest, rcSrc;

+  POINT			ptOrigin;

+  DWORD			dwBox = RegionNumRects (damage);

+  BoxPtr		pBox = RegionRects (damage);

+  HRGN			hrgnTemp = NULL, hrgnCombined = NULL;

+

+  /*

+   * Return immediately if the app is not active

+   * and we are fullscreen, or if we have a bad display depth

+   */

+  if ((!pScreenPriv->fActive && pScreenInfo->fFullScreen)

+      || pScreenPriv->fBadDepth) return;

+

+  /* Get the origin of the window in the screen coords */

+  ptOrigin.x = pScreenInfo->dwXOffset;

+  ptOrigin.y = pScreenInfo->dwYOffset;

+  MapWindowPoints (pScreenPriv->hwndScreen,

+		   HWND_DESKTOP,

+		   (LPPOINT)&ptOrigin, 1);

+

+  /* Unlock the shadow surface, so we can blit */

+  ddrval = IDirectDrawSurface2_Unlock (pScreenPriv->pddsShadow, NULL);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winShadowUpdateDD - Unlock failed\n");

+      return;

+    }

+

+  /*

+   * Handle small regions with multiple blits,

+   * handle large regions by creating a clipping region and 

+   * doing a single blit constrained to that clipping region.

+   */

+  if (pScreenInfo->dwClipUpdatesNBoxes == 0

+      || dwBox < pScreenInfo->dwClipUpdatesNBoxes)

+    {

+      /* Loop through all boxes in the damaged region */

+      while (dwBox--)

+	{

+	  /* Assign damage box to source rectangle */

+	  rcSrc.left = pBox->x1;

+	  rcSrc.top = pBox->y1;

+	  rcSrc.right = pBox->x2;

+	  rcSrc.bottom = pBox->y2;

+	  

+	  /* Calculate destination rectange */

+	  rcDest.left = ptOrigin.x + rcSrc.left;

+	  rcDest.top = ptOrigin.y + rcSrc.top;

+	  rcDest.right = ptOrigin.x + rcSrc.right;

+	  rcDest.bottom = ptOrigin.y + rcSrc.bottom;

+	  

+	  /* Blit the damaged areas */

+	  ddrval = IDirectDrawSurface2_Blt (pScreenPriv->pddsPrimary,

+					    &rcDest,

+					    pScreenPriv->pddsShadow,

+					    &rcSrc,

+					    DDBLT_WAIT,

+					    NULL);

+	  

+	  /* Get a pointer to the next box */

+	  ++pBox;

+	}

+    }

+  else

+    {

+      BoxPtr		pBoxExtents = RegionExtents(damage);

+

+      /* Compute a GDI region from the damaged region */

+      hrgnCombined = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);

+      dwBox--;

+      pBox++;

+      while (dwBox--)

+	{

+	  hrgnTemp = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);

+	  CombineRgn (hrgnCombined, hrgnCombined, hrgnTemp, RGN_OR);

+	  DeleteObject (hrgnTemp);

+	  pBox++;

+	}  

+

+      /* Install the GDI region as a clipping region */

+      SelectClipRgn (pScreenPriv->hdcScreen, hrgnCombined);

+      DeleteObject (hrgnCombined);

+      hrgnCombined = NULL;

+

+      /* Calculating a bounding box for the source is easy */

+      rcSrc.left = pBoxExtents->x1;

+      rcSrc.top = pBoxExtents->y1;

+      rcSrc.right = pBoxExtents->x2;

+      rcSrc.bottom = pBoxExtents->y2;

+

+      /* Calculating a bounding box for the destination is trickier */

+      rcDest.left = ptOrigin.x + rcSrc.left;

+      rcDest.top = ptOrigin.y + rcSrc.top;

+      rcDest.right = ptOrigin.x + rcSrc.right;

+      rcDest.bottom = ptOrigin.y + rcSrc.bottom;

+      

+      /* Our Blt should be clipped to the invalidated region */

+      ddrval = IDirectDrawSurface2_Blt (pScreenPriv->pddsPrimary,

+					&rcDest,

+					pScreenPriv->pddsShadow,

+					&rcSrc,

+					DDBLT_WAIT,

+					NULL);

+

+      /* Reset the clip region */

+      SelectClipRgn (pScreenPriv->hdcScreen, NULL);

+    }

+

+  /* Relock the shadow surface */

+  ddrval = IDirectDrawSurface2_Lock (pScreenPriv->pddsShadow,

+				     NULL,

+				     pScreenPriv->pddsdShadow,

+				     DDLOCK_WAIT,

+				     NULL);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winShadowUpdateDD - Lock failed\n");

+      return;

+    }

+

+  /* Has our memory pointer changed? */

+  if (pScreenInfo->pfb != pScreenPriv->pddsdShadow->lpSurface)

+    {

+      extern const char *g_pszLogFile;

+      ErrorF ("winShadowUpdateDD - Memory location of the shadow "

+	      "surface has changed, trying to update the root window "

+	      "pixmap header to point to the new address.  If you get "

+	      "this message and "PROJECT_NAME" freezes or crashes "

+	      "after this message then send a problem report and your "

+	      "%s file to " BUILDERADDR "\n", g_pszLogFile);

+

+      /* Location of shadow framebuffer has changed */

+      pScreenInfo->pfb = pScreenPriv->pddsdShadow->lpSurface;

+      

+      /* Update the screen pixmap */

+      if (!(*pScreen->ModifyPixmapHeader)(pScreen->devPrivate,

+					  pScreen->width,

+					  pScreen->height,

+					  pScreen->rootDepth,

+					  BitsPerPixel (pScreen->rootDepth),

+					  PixmapBytePad (pScreenInfo->dwStride,

+							 pScreenInfo->dwBPP),

+					  pScreenInfo->pfb))

+	{

+	  ErrorF ("winShadowUpdateDD - Bits changed, could not "

+		  "notify fb.\n");

+	  return;

+	}

+    }

+}

+

+

+/*

+ * Call the wrapped CloseScreen function.

+ * 

+ * Free our resources and private structures.

+ */

+

+static Bool

+winCloseScreenShadowDD (int nIndex, ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  Bool			fReturn;

+  

+  winDebug ("winCloseScreenShadowDD - Freeing screen resources\n");

+

+  /* Flag that the screen is closed */

+  pScreenPriv->fClosed = TRUE;

+  pScreenPriv->fActive = FALSE;

+

+  /* Call the wrapped CloseScreen procedure */

+  WIN_UNWRAP(CloseScreen);

+  fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);

+

+  /* Free the screen DC */

+  ReleaseDC (pScreenPriv->hwndScreen, pScreenPriv->hdcScreen);

+

+  /* Delete the window property */

+  RemoveProp (pScreenPriv->hwndScreen, WIN_SCR_PROP);

+

+  /* Free the shadow surface, if there is one */

+  if (pScreenPriv->pddsShadow)

+    {

+      IDirectDrawSurface2_Unlock (pScreenPriv->pddsShadow, NULL);

+      IDirectDrawSurface2_Release (pScreenPriv->pddsShadow);

+      pScreenPriv->pddsShadow = NULL;

+    }

+

+  /* Detach the clipper from the primary surface and release the clipper. */

+  if (pScreenPriv->pddcPrimary)

+    {

+      /* Detach the clipper */

+      IDirectDrawSurface2_SetClipper (pScreenPriv->pddsPrimary,

+				      NULL);

+

+      /* Release the clipper object */

+      IDirectDrawClipper_Release (pScreenPriv->pddcPrimary);

+      pScreenPriv->pddcPrimary = NULL;

+    }

+

+  /* Release the primary surface, if there is one */

+  if (pScreenPriv->pddsPrimary)

+    {

+      IDirectDrawSurface2_Release (pScreenPriv->pddsPrimary);

+      pScreenPriv->pddsPrimary = NULL;

+    }

+

+  /* Free the DirectDraw2 object, if there is one */

+  if (pScreenPriv->pdd2)

+    {

+      IDirectDraw2_RestoreDisplayMode (pScreenPriv->pdd2);

+      IDirectDraw2_Release (pScreenPriv->pdd2);

+      pScreenPriv->pdd2 = NULL;

+    }

+

+  /* Free the DirectDraw object, if there is one */

+  if (pScreenPriv->pdd)

+    {

+      IDirectDraw_Release (pScreenPriv->pdd);

+      pScreenPriv->pdd = NULL;

+    }

+

+  /* Delete tray icon, if we have one */

+  if (!pScreenInfo->fNoTrayIcon)

+    winDeleteNotifyIcon (pScreenPriv);

+  

+  /* Free the exit confirmation dialog box, if it exists */

+  if (g_hDlgExit != NULL)

+    {

+      DestroyWindow (g_hDlgExit);

+      g_hDlgExit = NULL;

+    }

+

+  /* Kill our window */

+  if (pScreenPriv->hwndScreen)

+    {

+      DestroyWindow (pScreenPriv->hwndScreen);

+      pScreenPriv->hwndScreen = NULL;

+    }

+

+#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)

+  /* Destroy the thread startup mutex */

+  pthread_mutex_destroy (&pScreenPriv->pmServerStarted);

+#endif

+

+  /* Kill our screeninfo's pointer to the screen */

+  pScreenInfo->pScreen = NULL;

+

+  /* Invalidate the ScreenInfo's fb pointer */

+  pScreenInfo->pfb = NULL;

+

+  /* Free the screen privates for this screen */

+  free ((pointer) pScreenPriv);

+

+  return fReturn;

+}

+

+

+/*

+ * Tell mi what sort of visuals we need.

+ * 

+ * Generally we only need one visual, as our screen can only

+ * handle one format at a time, I believe.  You may want

+ * to verify that last sentence.

+ */

+

+static Bool

+winInitVisualsShadowDD (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  DWORD			dwRedBits, dwGreenBits, dwBlueBits;

+

+  /* Count the number of ones in each color mask */

+  dwRedBits = winCountBits (pScreenPriv->dwRedMask);

+  dwGreenBits = winCountBits (pScreenPriv->dwGreenMask);

+  dwBlueBits = winCountBits (pScreenPriv->dwBlueMask);

+  

+  /* Store the maximum number of ones in a color mask as the bitsPerRGB */

+  if (dwRedBits == 0 || dwGreenBits == 0 || dwBlueBits == 0)

+    pScreenPriv->dwBitsPerRGB = 8;

+  else if (dwRedBits > dwGreenBits && dwRedBits > dwBlueBits)

+    pScreenPriv->dwBitsPerRGB = dwRedBits;

+  else if (dwGreenBits > dwRedBits && dwGreenBits > dwBlueBits)

+    pScreenPriv->dwBitsPerRGB = dwGreenBits;

+  else

+    pScreenPriv->dwBitsPerRGB = dwBlueBits;

+  

+  winDebug ("winInitVisualsShadowDD - Masks %08x %08x %08x BPRGB %d d %d "

+	  "bpp %d\n",

+	  (unsigned int) pScreenPriv->dwRedMask,

+	  (unsigned int) pScreenPriv->dwGreenMask,

+	  (unsigned int) pScreenPriv->dwBlueMask,

+	  (int) pScreenPriv->dwBitsPerRGB,

+	  (int) pScreenInfo->dwDepth,

+	  (int) pScreenInfo->dwBPP);

+

+  /* Create a single visual according to the Windows screen depth */

+  switch (pScreenInfo->dwDepth)

+    {

+    case 24:

+    case 16:

+    case 15:

+#if defined(XFree86Server)

+      /* Create the real visual */

+      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,

+				     TrueColorMask,

+				     pScreenPriv->dwBitsPerRGB,

+				     TrueColor,

+				     pScreenPriv->dwRedMask,

+				     pScreenPriv->dwGreenMask,

+				     pScreenPriv->dwBlueMask))

+	{

+	  ErrorF ("winInitVisualsShadowDD - miSetVisualTypesAndMasks "

+		  "failed for TrueColor\n");

+	  return FALSE;

+	}

+

+#ifdef XWIN_EMULATEPSEUDO

+      if (!pScreenInfo->fEmulatePseudo)

+	break;

+

+      /* Setup a pseudocolor visual */

+      if (!miSetVisualTypesAndMasks (8,

+				     PseudoColorMask,

+				     8,

+				     -1,

+				     0,

+				     0,

+				     0))

+	{

+	  ErrorF ("winInitVisualsShadowDD - miSetVisualTypesAndMasks "

+		  "failed for PseudoColor\n");

+	  return FALSE;

+	}

+#endif

+#else /* XFree86Server */

+      /* Create the real visual */

+      if (!fbSetVisualTypesAndMasks (pScreenInfo->dwDepth,

+				     TrueColorMask,

+				     pScreenPriv->dwBitsPerRGB,

+				     pScreenPriv->dwRedMask,

+				     pScreenPriv->dwGreenMask,

+				     pScreenPriv->dwBlueMask))

+	{

+	  ErrorF ("winInitVisualsShadowDD - fbSetVisualTypesAndMasks "

+		  "failed for TrueColor\n");

+	  return FALSE;

+	}

+

+#ifdef XWIN_EMULATEPSEUDO

+      if (!pScreenInfo->fEmulatePseudo)

+	break;

+

+      /* Setup a pseudocolor visual */

+      if (!fbSetVisualTypesAndMasks (8,

+				     PseudoColorMask,

+				     8,

+				     0,

+				     0,

+				     0))

+	{

+	  ErrorF ("winInitVisualsShadowDD - fbSetVisualTypesAndMasks "

+		  "failed for PseudoColor\n");

+	  return FALSE;

+	}

+#endif

+#endif /* XFree86Server */

+      break;

+

+    case 8:

+#if defined(XFree86Server)

+      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,

+				     pScreenInfo->fFullScreen 

+				     ? PseudoColorMask : StaticColorMask,

+				     pScreenPriv->dwBitsPerRGB,

+				     pScreenInfo->fFullScreen 

+				     ? PseudoColor : StaticColor,

+				     pScreenPriv->dwRedMask,

+				     pScreenPriv->dwGreenMask,

+				     pScreenPriv->dwBlueMask))

+	{

+	  ErrorF ("winInitVisualsShadowDD - miSetVisualTypesAndMasks "

+		  "failed\n");

+	  return FALSE;

+	}

+#else /* XFree86Server */

+      if (!fbSetVisualTypesAndMasks (pScreenInfo->dwDepth,

+				     pScreenInfo->fFullScreen 

+				     ? PseudoColorMask : StaticColorMask,

+				     pScreenPriv->dwBitsPerRGB,

+				     pScreenPriv->dwRedMask,

+				     pScreenPriv->dwGreenMask,

+				     pScreenPriv->dwBlueMask))

+	{

+	  ErrorF ("winInitVisualsShadowDD - fbSetVisualTypesAndMasks "

+		  "failed\n");

+	  return FALSE;

+	}

+#endif /* XFree86Server */

+      break;

+

+    default:

+      ErrorF ("winInitVisualsShadowDD - Unknown screen depth\n");

+      return FALSE;

+    }

+

+  winDebug ("winInitVisualsShadowDD - Returning\n");

+

+  return TRUE;

+}

+

+

+/*

+ * Adjust the user proposed video mode

+ */

+

+static Bool

+winAdjustVideoModeShadowDD (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  HDC			hdc = NULL;

+  DWORD			dwBPP;

+

+  /* We're in serious trouble if we can't get a DC */

+  hdc = GetDC (NULL);

+  if (hdc == NULL)

+    {

+      ErrorF ("winAdjustVideoModeShadowDD - GetDC () failed\n");

+      return FALSE;

+    }

+

+  /* Query GDI for current display depth */

+  dwBPP = GetDeviceCaps (hdc, BITSPIXEL);

+

+  /* DirectDraw can only change the depth in fullscreen mode */

+  if (pScreenInfo->dwBPP == WIN_DEFAULT_BPP)

+    {

+      /* No -depth parameter passed, let the user know the depth being used */

+      winDebug ("winAdjustVideoModeShadowDD - Using Windows display "

+	      "depth of %d bits per pixel\n", (int) dwBPP);

+

+      /* Use GDI's depth */

+      pScreenInfo->dwBPP = dwBPP;

+    }

+  else if (pScreenInfo->fFullScreen

+	   && pScreenInfo->dwBPP != dwBPP)

+    {

+      /* FullScreen, and GDI depth differs from -depth parameter */

+      winDebug ("winAdjustVideoModeShadowDD - FullScreen, using command line "

+	      "bpp: %d\n", (int) pScreenInfo->dwBPP);

+    }

+  else if (dwBPP != pScreenInfo->dwBPP)

+    {

+      /* Windowed, and GDI depth differs from -depth parameter */

+      winDebug ("winAdjustVideoModeShadowDD - Windowed, command line bpp: "

+	      "%d, using bpp: %d\n", (int) pScreenInfo->dwBPP, (int) dwBPP);

+

+      /* We'll use GDI's depth */

+      pScreenInfo->dwBPP = dwBPP;

+    }

+  

+  /* See if the shadow bitmap will be larger than the DIB size limit */

+  if (pScreenInfo->dwWidth * pScreenInfo->dwHeight * pScreenInfo->dwBPP

+      >= WIN_DIB_MAXIMUM_SIZE)

+    {

+      ErrorF ("winAdjustVideoModeShadowDD - Requested DirectDraw surface "

+	      "will be larger than %d MB.  The surface may fail to be "

+	      "allocated on Windows 95, 98, or Me, due to a %d MB limit in "

+	      "DIB size.  This limit does not apply to Windows NT/2000, and "

+	      "this message may be ignored on those platforms.\n",

+	      WIN_DIB_MAXIMUM_SIZE_MB, WIN_DIB_MAXIMUM_SIZE_MB);

+    }

+

+  /* Release our DC */

+  ReleaseDC (NULL, hdc);

+  return TRUE;

+}

+

+

+/*

+ * Blt exposed regions to the screen

+ */

+

+static Bool

+winBltExposedRegionsShadowDD (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  RECT			rcSrc, rcDest;

+  POINT			ptOrigin;

+  HDC			hdcUpdate = NULL;

+  PAINTSTRUCT		ps;

+  HRESULT		ddrval = DD_OK;

+  Bool			fReturn = TRUE;

+  Bool			fLocked = TRUE;

+  int			i;

+

+  /* BeginPaint gives us an hdc that clips to the invalidated region */

+  hdcUpdate = BeginPaint (pScreenPriv->hwndScreen, &ps);

+  if (hdcUpdate == NULL)

+    {

+      ErrorF ("winBltExposedRegionsShadowDD - BeginPaint () returned "

+	      "a NULL device context handle.  Aborting blit attempt.\n");

+      return FALSE;

+    }

+  

+  /* Unlock the shadow surface, so we can blit */

+  ddrval = IDirectDrawSurface2_Unlock (pScreenPriv->pddsShadow, NULL);

+  if (FAILED (ddrval))

+    {

+      fReturn = FALSE;

+      goto winBltExposedRegionsShadowDD_Exit;

+    }

+  else

+    {

+      /* Flag that we have unlocked the shadow surface */

+      fLocked = FALSE;

+    }

+

+  /* Get the origin of the window in the screen coords */

+  ptOrigin.x = pScreenInfo->dwXOffset;

+  ptOrigin.y = pScreenInfo->dwYOffset;

+

+  MapWindowPoints (pScreenPriv->hwndScreen,

+		   HWND_DESKTOP,

+		   (LPPOINT)&ptOrigin, 1);

+  rcDest.left = ptOrigin.x;

+  rcDest.right = ptOrigin.x + pScreenInfo->dwWidth;

+  rcDest.top = ptOrigin.y;

+  rcDest.bottom = ptOrigin.y + pScreenInfo->dwHeight;

+

+  /* Source can be enter shadow surface, as Blt should clip */

+  rcSrc.left = 0;

+  rcSrc.top = 0;

+  rcSrc.right = pScreenInfo->dwWidth;

+  rcSrc.bottom = pScreenInfo->dwHeight;

+

+  /* Try to regain the primary surface and blit again if we've lost it */

+  for (i = 0; i <= WIN_REGAIN_SURFACE_RETRIES; ++i)

+    {

+      /* Our Blt should be clipped to the invalidated region */

+      ddrval = IDirectDrawSurface2_Blt (pScreenPriv->pddsPrimary,

+					&rcDest,

+					pScreenPriv->pddsShadow,

+					&rcSrc,

+					DDBLT_WAIT,

+					NULL);

+      if (ddrval == DDERR_SURFACELOST)

+	{

+	  /* Surface was lost */

+	  ErrorF ("winBltExposedRegionsShadowDD - IDirectDrawSurface2_Blt "

+		  "reported that the primary surface was lost, "

+		  "trying to restore, retry: %d\n", i + 1);

+

+	  /* Try to restore the surface, once */

+	  ddrval = IDirectDrawSurface2_Restore (pScreenPriv->pddsPrimary);

+	  ErrorF ("winBltExposedRegionsShadowDD - "

+		  "IDirectDrawSurface2_Restore returned: ");

+	  if (ddrval == DD_OK)

+	    ErrorF ("DD_OK\n");

+	  else if (ddrval == DDERR_WRONGMODE)

+	    ErrorF ("DDERR_WRONGMODE\n");

+	  else if (ddrval == DDERR_INCOMPATIBLEPRIMARY)

+	    ErrorF ("DDERR_INCOMPATIBLEPRIMARY\n");

+	  else if (ddrval == DDERR_UNSUPPORTED)

+	    ErrorF ("DDERR_UNSUPPORTED\n");

+	  else if (ddrval == DDERR_INVALIDPARAMS)

+	    ErrorF ("DDERR_INVALIDPARAMS\n");

+	  else if (ddrval == DDERR_INVALIDOBJECT)

+	    ErrorF ("DDERR_INVALIDOBJECT\n");

+	  else

+	    ErrorF ("unknown error: %08x\n", (unsigned int) ddrval);

+

+	  /* Loop around to try the blit one more time */

+	  continue;

+	}

+      else if (FAILED (ddrval))

+	{

+	  fReturn = FALSE;

+	  ErrorF ("winBltExposedRegionsShadowDD - IDirectDrawSurface2_Blt "

+		  "failed, but surface not lost: %08x %d\n",

+		  (unsigned int) ddrval, (int) ddrval);

+	  goto winBltExposedRegionsShadowDD_Exit;

+	}

+      else

+	{

+	  /* Success, stop looping */

+	  break;

+	}

+    }

+

+  /* Relock the shadow surface */

+  ddrval = IDirectDrawSurface2_Lock (pScreenPriv->pddsShadow,

+				     NULL,

+				     pScreenPriv->pddsdShadow,

+				     DDLOCK_WAIT,

+				     NULL);

+  if (FAILED (ddrval))

+    {

+      fReturn = FALSE;

+      ErrorF ("winBltExposedRegionsShadowDD - IDirectDrawSurface2_Lock "

+	      "failed\n");

+      goto winBltExposedRegionsShadowDD_Exit;

+    }

+  else

+    {

+      /* Indicate that we have relocked the shadow surface */

+      fLocked = TRUE;

+    }

+

+  /* Has our memory pointer changed? */

+  if (pScreenInfo->pfb != pScreenPriv->pddsdShadow->lpSurface)

+    winUpdateFBPointer (pScreen,

+			pScreenPriv->pddsdShadow->lpSurface);

+

+ winBltExposedRegionsShadowDD_Exit:

+  /* EndPaint frees the DC */

+  if (hdcUpdate != NULL)

+    EndPaint (pScreenPriv->hwndScreen, &ps);

+

+  /*

+   * Relock the surface if it is not locked.  We don't care if locking fails,

+   * as it will cause the server to shutdown within a few more operations.

+   */

+  if (!fLocked)

+    {

+      IDirectDrawSurface2_Lock (pScreenPriv->pddsShadow,

+				NULL,

+				pScreenPriv->pddsdShadow,

+				DDLOCK_WAIT,

+				NULL);

+

+      /* Has our memory pointer changed? */

+      if (pScreenInfo->pfb != pScreenPriv->pddsdShadow->lpSurface)

+	winUpdateFBPointer (pScreen,

+			    pScreenPriv->pddsdShadow->lpSurface);

+      

+      fLocked = TRUE;

+    }

+  return fReturn;

+}

+

+

+/*

+ * Do any engine-specific appliation-activation processing

+ */

+

+static Bool

+winActivateAppShadowDD (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+

+  /*

+   * Do we have a surface?

+   * Are we active?

+   * Are we fullscreen?

+   */

+  if (pScreenPriv != NULL

+      && pScreenPriv->pddsPrimary != NULL

+      && pScreenPriv->fActive)

+    {

+      /* Primary surface was lost, restore it */

+      IDirectDrawSurface2_Restore (pScreenPriv->pddsPrimary);

+    }

+

+  return TRUE;

+}

+

+

+/*

+ * Reblit the shadow framebuffer to the screen.

+ */

+

+static Bool

+winRedrawScreenShadowDD (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  HRESULT		ddrval = DD_OK;

+  RECT			rcSrc, rcDest;

+  POINT			ptOrigin;

+

+  /* Get the origin of the window in the screen coords */

+  ptOrigin.x = pScreenInfo->dwXOffset;

+  ptOrigin.y = pScreenInfo->dwYOffset;

+  MapWindowPoints (pScreenPriv->hwndScreen,

+		   HWND_DESKTOP,

+		   (LPPOINT)&ptOrigin, 1);

+  rcDest.left = ptOrigin.x;

+  rcDest.right = ptOrigin.x + pScreenInfo->dwWidth;

+  rcDest.top = ptOrigin.y;

+  rcDest.bottom = ptOrigin.y + pScreenInfo->dwHeight;

+

+  /* Source can be entire shadow surface, as Blt should clip for us */

+  rcSrc.left = 0;

+  rcSrc.top = 0;

+  rcSrc.right = pScreenInfo->dwWidth;

+  rcSrc.bottom = pScreenInfo->dwHeight;

+

+  /* Redraw the whole window, to take account for the new colors */

+  ddrval = IDirectDrawSurface2_Blt (pScreenPriv->pddsPrimary,

+				    &rcDest,

+				    pScreenPriv->pddsShadow,

+				    &rcSrc,

+				    DDBLT_WAIT,

+				    NULL);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winRedrawScreenShadowDD - IDirectDrawSurface_Blt () "

+	      "failed: %08x\n",

+	      (unsigned int) ddrval);

+    }

+

+  return TRUE;

+}

+

+

+/*

+ * Realize the currently installed colormap

+ */

+

+static Bool

+winRealizeInstalledPaletteShadowDD (ScreenPtr pScreen)

+{

+  return TRUE;

+}

+

+

+/*

+ * Install the specified colormap

+ */

+

+static Bool

+winInstallColormapShadowDD (ColormapPtr pColormap)

+{

+  ScreenPtr		pScreen = pColormap->pScreen;

+  winScreenPriv(pScreen);

+  winCmapPriv(pColormap);

+  HRESULT		ddrval = DD_OK;

+

+  /* Install the DirectDraw palette on the primary surface */

+  ddrval = IDirectDrawSurface2_SetPalette (pScreenPriv->pddsPrimary,

+					   pCmapPriv->lpDDPalette);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winInstallColormapShadowDD - Failed installing the "

+	      "DirectDraw palette.\n");

+      return FALSE;

+    }

+

+  /* Save a pointer to the newly installed colormap */

+  pScreenPriv->pcmapInstalled = pColormap;

+

+  return TRUE;

+}

+

+

+/*

+ * Store the specified colors in the specified colormap

+ */

+

+static Bool

+winStoreColorsShadowDD (ColormapPtr pColormap, 

+			int ndef,

+			xColorItem *pdefs)

+{

+  ScreenPtr		pScreen = pColormap->pScreen;

+  winScreenPriv(pScreen);

+  winCmapPriv(pColormap);

+  ColormapPtr		curpmap = pScreenPriv->pcmapInstalled;

+  HRESULT		ddrval = DD_OK;

+  

+  /* Put the X colormap entries into the Windows logical palette */

+  ddrval = IDirectDrawPalette_SetEntries (pCmapPriv->lpDDPalette,

+					  0,

+					  pdefs[0].pixel,

+					  ndef,

+					  pCmapPriv->peColors 

+					  + pdefs[0].pixel);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winStoreColorsShadowDD - SetEntries () failed\n");

+      return FALSE;

+    }

+

+  /* Don't install the DirectDraw palette if the colormap is not installed */

+  if (pColormap != curpmap)

+    {

+      return TRUE;

+    }

+

+  if (!winInstallColormapShadowDD (pColormap))

+    {

+      ErrorF ("winStoreColorsShadowDD - Failed installing colormap\n");

+      return FALSE;

+    }

+

+  return TRUE;

+}

+

+

+/*

+ * Colormap initialization procedure

+ */

+

+static Bool

+winCreateColormapShadowDD (ColormapPtr pColormap)

+{

+  HRESULT		ddrval = DD_OK;

+  ScreenPtr		pScreen = pColormap->pScreen;

+  winScreenPriv(pScreen);

+  winCmapPriv(pColormap);

+  

+  /* Create a DirectDraw palette */

+  ddrval = IDirectDraw2_CreatePalette (pScreenPriv->pdd,

+				       DDPCAPS_8BIT | DDPCAPS_ALLOW256,

+				       pCmapPriv->peColors,

+				       &pCmapPriv->lpDDPalette,

+				       NULL);

+  if (FAILED (ddrval))

+    {

+      ErrorF ("winCreateColormapShadowDD - CreatePalette failed\n");

+      return FALSE;

+    }

+

+  return TRUE;

+}

+

+

+/*

+ * Colormap destruction procedure

+ */

+

+static Bool

+winDestroyColormapShadowDD (ColormapPtr pColormap)

+{

+  winScreenPriv(pColormap->pScreen);

+  winCmapPriv(pColormap);

+  HRESULT		ddrval = DD_OK;

+

+  /*

+   * Is colormap to be destroyed the default?

+   *

+   * Non-default colormaps should have had winUninstallColormap

+   * called on them before we get here.  The default colormap

+   * will not have had winUninstallColormap called on it.  Thus,

+   * we need to handle the default colormap in a special way.

+   */

+  if (pColormap->flags & IsDefault)

+    {

+      winDebug ("winDestroyColormapShadowDD - Destroying default "

+	      "colormap\n");

+      

+      /*

+       * FIXME: Walk the list of all screens, popping the default

+       * palette out of each screen device context.

+       */

+      

+      /* Pop the palette out of the primary surface */

+      ddrval = IDirectDrawSurface2_SetPalette (pScreenPriv->pddsPrimary,

+					       NULL);

+      if (FAILED (ddrval))

+	{

+	  ErrorF ("winDestroyColormapShadowDD - Failed freeing the "

+		  "default colormap DirectDraw palette.\n");

+	  return FALSE;

+	}

+

+      /* Clear our private installed colormap pointer */

+      pScreenPriv->pcmapInstalled = NULL;

+    }

+  

+  /* Release the palette */

+  IDirectDrawPalette_Release (pCmapPriv->lpDDPalette);

+ 

+  /* Invalidate the colormap privates */

+  pCmapPriv->lpDDPalette = NULL;

+

+  return TRUE;

+}

+

+

+/*

+ * Set engine specific functions

+ */

+

+Bool

+winSetEngineFunctionsShadowDD (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  

+  /* Set our pointers */

+  pScreenPriv->pwinAllocateFB = winAllocateFBShadowDD;

+  pScreenPriv->pwinShadowUpdate = winShadowUpdateDD;

+  pScreenPriv->pwinCloseScreen = winCloseScreenShadowDD;

+  pScreenPriv->pwinInitVisuals = winInitVisualsShadowDD;

+  pScreenPriv->pwinAdjustVideoMode = winAdjustVideoModeShadowDD;

+  if (pScreenInfo->fFullScreen)

+    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowFullScreen;

+  else

+    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowWindowed;

+  pScreenPriv->pwinFinishScreenInit = winFinishScreenInitFB;

+  pScreenPriv->pwinBltExposedRegions = winBltExposedRegionsShadowDD;

+  pScreenPriv->pwinActivateApp = winActivateAppShadowDD;

+  pScreenPriv->pwinRedrawScreen = winRedrawScreenShadowDD;

+  pScreenPriv->pwinRealizeInstalledPalette

+    = winRealizeInstalledPaletteShadowDD;

+  pScreenPriv->pwinInstallColormap = winInstallColormapShadowDD;

+  pScreenPriv->pwinStoreColors = winStoreColorsShadowDD;

+  pScreenPriv->pwinCreateColormap = winCreateColormapShadowDD;

+  pScreenPriv->pwinDestroyColormap = winDestroyColormapShadowDD;

+  pScreenPriv->pwinHotKeyAltTab = (winHotKeyAltTabProcPtr) (void (*)(void))NoopDDA;

+  pScreenPriv->pwinCreatePrimarySurface = winCreatePrimarySurfaceShadowDD;

+  pScreenPriv->pwinReleasePrimarySurface = winReleasePrimarySurfaceShadowDD;

+#ifdef XWIN_MULTIWINDOW

+  pScreenPriv->pwinFinishCreateWindowsWindow =

+    (winFinishCreateWindowsWindowProcPtr) (void (*)(void))NoopDDA;

+#endif

+

+  return TRUE;

+}

diff --git a/xorg-server/hw/xwin/winshadddnl.c b/xorg-server/hw/xwin/winshadddnl.c
index af7b989df..95fb0e6fc 100644
--- a/xorg-server/hw/xwin/winshadddnl.c
+++ b/xorg-server/hw/xwin/winshadddnl.c
@@ -583,8 +583,8 @@ winShadowUpdateDDNL (ScreenPtr pScreen,
   HRESULT		ddrval = DD_OK;

   RECT			rcDest, rcSrc;

   POINT			ptOrigin;

-  DWORD			dwBox = REGION_NUM_RECTS (damage);

-  BoxPtr		pBox = REGION_RECTS (damage);

+  DWORD			dwBox = RegionNumRects (damage);

+  BoxPtr		pBox = RegionRects (damage);

   HRGN			hrgnTemp = NULL, hrgnCombined = NULL;

 

   /*

@@ -659,7 +659,7 @@ winShadowUpdateDDNL (ScreenPtr pScreen,
     }

   else

     {

-      BoxPtr		pBoxExtents = REGION_EXTENTS (pScreen, damage);

+      BoxPtr		pBoxExtents = RegionExtents(damage);

 

       /* Compute a GDI region from the damaged region */

       hrgnCombined = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);

diff --git a/xorg-server/hw/xwin/winshadgdi.c b/xorg-server/hw/xwin/winshadgdi.c
index fbc15abb3..09135c702 100644
--- a/xorg-server/hw/xwin/winshadgdi.c
+++ b/xorg-server/hw/xwin/winshadgdi.c
@@ -1,1302 +1,1302 @@
-/*
- *Copyright (C) 2001-2004 Harold L Hunt II All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL HAROLD L HUNT II BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of Harold L Hunt II
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from Harold L Hunt II.
- *
- * Authors:	Harold L Hunt II
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-
-
-/*
- * External symbols
- */
-
-#ifdef XWIN_MULTIWINDOW
-extern DWORD			g_dwCurrentThreadID;
-#endif
-extern HWND			g_hDlgExit;
-
-
-/*
- * Local function prototypes
- */
-
-#ifdef XWIN_MULTIWINDOW
-static wBOOL CALLBACK
-winRedrawAllProcShadowGDI (HWND hwnd, LPARAM lParam);
-
-static wBOOL CALLBACK
-winRedrawDamagedWindowShadowGDI (HWND hwnd, LPARAM lParam);
-#endif
-
-static Bool
-winAllocateFBShadowGDI (ScreenPtr pScreen);
-
-static void
-winShadowUpdateGDI (ScreenPtr pScreen, 
-		    shadowBufPtr pBuf);
-
-static Bool
-winCloseScreenShadowGDI (int nIndex, ScreenPtr pScreen);
-
-static Bool
-winInitVisualsShadowGDI (ScreenPtr pScreen);
-
-static Bool
-winAdjustVideoModeShadowGDI (ScreenPtr pScreen);
-
-static Bool
-winBltExposedRegionsShadowGDI (ScreenPtr pScreen);
-
-static Bool
-winActivateAppShadowGDI (ScreenPtr pScreen);
-
-static Bool
-winRedrawScreenShadowGDI (ScreenPtr pScreen);
-
-static Bool
-winRealizeInstalledPaletteShadowGDI (ScreenPtr pScreen);
-
-static Bool
-winInstallColormapShadowGDI (ColormapPtr pColormap);
-
-static Bool
-winStoreColorsShadowGDI (ColormapPtr pmap, 
-			 int ndef,
-			 xColorItem *pdefs);
-
-static Bool
-winCreateColormapShadowGDI (ColormapPtr pColormap);
-
-static Bool
-winDestroyColormapShadowGDI (ColormapPtr pColormap);
-
-
-/*
- * Internal function to get the DIB format that is compatible with the screen
- */
-
-static
-Bool
-winQueryScreenDIBFormat (ScreenPtr pScreen, BITMAPINFOHEADER *pbmih)
-{
-  winScreenPriv(pScreen);
-  HBITMAP		hbmp;
-#ifdef WINDBG
-  LPDWORD		pdw = NULL;
-#endif
-  
-  /* Create a memory bitmap compatible with the screen */
-  hbmp = CreateCompatibleBitmap (pScreenPriv->hdcScreen, 1, 1);
-  if (hbmp == NULL)
-    {
-      ErrorF ("winQueryScreenDIBFormat - CreateCompatibleBitmap failed\n");
-      return FALSE;
-    }
-  
-  /* Initialize our bitmap info header */
-  ZeroMemory (pbmih, sizeof (BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD));
-  pbmih->biSize = sizeof (BITMAPINFOHEADER);
-
-  /* Get the biBitCount */
-  if (!GetDIBits (pScreenPriv->hdcScreen,
-		  hbmp,
-		  0, 1,
-		  NULL,
-		  (BITMAPINFO*) pbmih,
-		  DIB_RGB_COLORS))
-    {
-      ErrorF ("winQueryScreenDIBFormat - First call to GetDIBits failed\n");
-      DeleteObject (hbmp);
-      return FALSE;
-    }
-
-#ifdef WINDBG
-  /* Get a pointer to bitfields */
-  pdw = (DWORD*) ((CARD8*)pbmih + sizeof (BITMAPINFOHEADER));
-
-  winDebug ("winQueryScreenDIBFormat - First call masks: %08x %08x %08x\n",
-	  pdw[0], pdw[1], pdw[2]);
-#endif
-
-  /* Get optimal color table, or the optimal bitfields */
-  if (!GetDIBits (pScreenPriv->hdcScreen,
-		  hbmp,
-		  0, 1,
-		  NULL,
-		  (BITMAPINFO*)pbmih,
-		  DIB_RGB_COLORS))
-    {
-      ErrorF ("winQueryScreenDIBFormat - Second call to GetDIBits "
-	      "failed\n");
-      DeleteObject (hbmp);
-      return FALSE;
-    }
-
-  /* Free memory */
-  DeleteObject (hbmp);
-  
-  return TRUE;
-}
-
-
-/*
- * Internal function to determine the GDI bits per rgb and bit masks
- */
-
-static
-Bool
-winQueryRGBBitsAndMasks (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  BITMAPINFOHEADER	*pbmih = NULL;
-  Bool			fReturn = TRUE;
-  LPDWORD		pdw = NULL;
-  DWORD			dwRedBits, dwGreenBits, dwBlueBits;
-
-  /* Color masks for 8 bpp are standardized */
-  if (GetDeviceCaps (pScreenPriv->hdcScreen, RASTERCAPS) & RC_PALETTE)
-    {
-      /* 
-       * RGB BPP for 8 bit palletes is always 8
-       * and the color masks are always 0.
-       */
-      pScreenPriv->dwBitsPerRGB = 8;
-      pScreenPriv->dwRedMask = 0x0L;
-      pScreenPriv->dwGreenMask = 0x0L;
-      pScreenPriv->dwBlueMask = 0x0L;
-      return TRUE;
-    }
-
-  /* Color masks for 24 bpp are standardized */
-  if (GetDeviceCaps (pScreenPriv->hdcScreen, PLANES)
-      * GetDeviceCaps (pScreenPriv->hdcScreen, BITSPIXEL) == 24)
-    {
-      winDebug ("winQueryRGBBitsAndMasks - GetDeviceCaps (BITSPIXEL) "
-	      "returned 24 for the screen.  Using default 24bpp masks.\n");
-
-      /* 8 bits per primary color */
-      pScreenPriv->dwBitsPerRGB = 8;
-
-      /* Set screen privates masks */
-      pScreenPriv->dwRedMask = WIN_24BPP_MASK_RED;
-      pScreenPriv->dwGreenMask = WIN_24BPP_MASK_GREEN;
-      pScreenPriv->dwBlueMask = WIN_24BPP_MASK_BLUE;
-      
-      return TRUE;
-    }
-
-  /* Allocate a bitmap header and color table */
-  pbmih = (BITMAPINFOHEADER*) malloc (sizeof (BITMAPINFOHEADER)
-				      + 256  * sizeof (RGBQUAD));
-  if (pbmih == NULL)
-    {
-      ErrorF ("winQueryRGBBitsAndMasks - malloc failed\n");
-      return FALSE;
-    }
-
-  /* Get screen description */
-  if (winQueryScreenDIBFormat (pScreen, pbmih))
-    {
-      /* Get a pointer to bitfields */
-      pdw = (DWORD*) ((CARD8*)pbmih + sizeof (BITMAPINFOHEADER));
-      
-#ifdef WINDBG
-      winDebug ("%s - Masks: %08x %08x %08x\n", __FUNCTION__,
-	      pdw[0], pdw[1], pdw[2]);
-      winDebug ("%s - Bitmap: %dx%d %d bpp %d planes\n", __FUNCTION__,
-              pbmih->biWidth, pbmih->biHeight, pbmih->biBitCount, pbmih->biPlanes);
-      winDebug ("%s - Compression: %d %s\n", __FUNCTION__,
-              pbmih->biCompression,
-              (pbmih->biCompression == BI_RGB?"(BI_RGB)":
-               (pbmih->biCompression == BI_RLE8?"(BI_RLE8)":
-                (pbmih->biCompression == BI_RLE4?"(BI_RLE4)":
-                 (pbmih->biCompression == BI_BITFIELDS?"(BI_BITFIELDS)":""
-                 )))));
-#endif
-
-      /* Handle BI_RGB case, which is returned by Wine */
-      if (pbmih->biCompression == BI_RGB)
-        {
-	  dwRedBits = 5;
-	  dwGreenBits = 5;
-	  dwBlueBits = 5;
-	  
-	  pScreenPriv->dwBitsPerRGB = 5;
-	  
-	  /* Set screen privates masks */
-	  pScreenPriv->dwRedMask = 0x7c00;
-	  pScreenPriv->dwGreenMask = 0x03e0;
-	  pScreenPriv->dwBlueMask = 0x001f;
-        }
-      else 
-        {
-          /* Count the number of bits in each mask */
-          dwRedBits = winCountBits (pdw[0]);
-          dwGreenBits = winCountBits (pdw[1]);
-          dwBlueBits = winCountBits (pdw[2]);
-
-	  /* Find maximum bits per red, green, blue */
-	  if (dwRedBits > dwGreenBits && dwRedBits > dwBlueBits)
-	    pScreenPriv->dwBitsPerRGB = dwRedBits;
-	  else if (dwGreenBits > dwRedBits && dwGreenBits > dwBlueBits)
-	    pScreenPriv->dwBitsPerRGB = dwGreenBits;
-	  else
-	    pScreenPriv->dwBitsPerRGB = dwBlueBits;
-
-	  /* Set screen privates masks */
-	  pScreenPriv->dwRedMask = pdw[0];
-	  pScreenPriv->dwGreenMask = pdw[1];
-	  pScreenPriv->dwBlueMask = pdw[2];
-	}
-    }
-  else
-    {
-      ErrorF ("winQueryRGBBitsAndMasks - winQueryScreenDIBFormat failed\n");
-      free (pbmih);
-      fReturn = FALSE;
-    }
-
-  /* Free memory */
-  free (pbmih);
-
-  return fReturn;
-}
-
-
-#ifdef XWIN_MULTIWINDOW
-/*
- * Redraw all ---?
- */
-
-static wBOOL CALLBACK
-winRedrawAllProcShadowGDI (HWND hwnd, LPARAM lParam)
-{
-  if (hwnd == (HWND)lParam)
-    return TRUE;  
-  InvalidateRect (hwnd, NULL, FALSE);
-  UpdateWindow (hwnd);
-  return TRUE;
-}
-
-static wBOOL CALLBACK
-winRedrawDamagedWindowShadowGDI (HWND hwnd, LPARAM lParam)
-{
-  BoxPtr pDamage = (BoxPtr)lParam;
-  RECT rcClient, rcDamage, rcRedraw;
-  POINT topLeft, bottomRight;
-  
-  if (IsIconic (hwnd))
-    return TRUE; /* Don't care minimized windows */
-  
-  /* Convert the damaged area from Screen coords to Client coords */
-  topLeft.x = pDamage->x1; topLeft.y = pDamage->y1;
-  bottomRight.x = pDamage->x2; bottomRight.y = pDamage->y2;
-  topLeft.x += GetSystemMetrics (SM_XVIRTUALSCREEN);
-  bottomRight.x += GetSystemMetrics (SM_XVIRTUALSCREEN);
-  topLeft.y += GetSystemMetrics (SM_YVIRTUALSCREEN);
-  bottomRight.y += GetSystemMetrics (SM_YVIRTUALSCREEN);
-  ScreenToClient (hwnd, &topLeft);
-  ScreenToClient (hwnd, &bottomRight);
-  SetRect (&rcDamage, topLeft.x, topLeft.y, bottomRight.x, bottomRight.y);
-
-  GetClientRect (hwnd, &rcClient);
-
-  if (IntersectRect (&rcRedraw, &rcClient, &rcDamage))
-    {
-      InvalidateRect (hwnd, &rcRedraw, FALSE);
-      UpdateWindow (hwnd);
-    }
-  return TRUE;
-}
-#endif
-
-
-/*
- * Allocate a DIB for the shadow framebuffer GDI server
- */
-
-static Bool
-winAllocateFBShadowGDI (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  BITMAPINFOHEADER	*pbmih = NULL;
-  DIBSECTION		dibsection;
-  Bool			fReturn = TRUE;
-
-  /* Get device contexts for the screen and shadow bitmap */
-  pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);
-  pScreenPriv->hdcShadow = CreateCompatibleDC (pScreenPriv->hdcScreen);
-
-  /* Allocate bitmap info header */
-  pbmih = (BITMAPINFOHEADER*) malloc (sizeof (BITMAPINFOHEADER)
-				      + 256 * sizeof (RGBQUAD));
-  if (pbmih == NULL)
-    {
-      ErrorF ("winAllocateFBShadowGDI - malloc () failed\n");
-      return FALSE;
-    }
-
-  /* Query the screen format */
-  fReturn = winQueryScreenDIBFormat (pScreen, pbmih);
-
-  /* Describe shadow bitmap to be created */
-  pbmih->biWidth = pScreenInfo->dwWidth;
-  pbmih->biHeight = -pScreenInfo->dwHeight;
-  
-  winDebug ("winAllocateFBShadowGDI - Creating DIB with width: %d height: %d "
-	  "depth: %d\n",
-	  (int) pbmih->biWidth, (int) -pbmih->biHeight, pbmih->biBitCount);
-
-  /* Create a DI shadow bitmap with a bit pointer */
-  pScreenPriv->hbmpShadow = CreateDIBSection (pScreenPriv->hdcScreen,
-					      (BITMAPINFO *) pbmih,
-					      DIB_RGB_COLORS,
-					      (VOID**) &pScreenInfo->pfb,
-					      NULL,
-					      0);
-  if (pScreenPriv->hbmpShadow == NULL || pScreenInfo->pfb == NULL)
-    {
-      winW32Error ("winAllocateFBShadowGDI - CreateDIBSection failed:");
-      return FALSE;
-    }
-  else
-    {
-      winDebug ("winAllocateFBShadowGDI - Shadow buffer allocated\n");
-    }
-
-  /* Get information about the bitmap that was allocated */
-  GetObject (pScreenPriv->hbmpShadow,
-	     sizeof (dibsection),
-	     &dibsection);
-
-  /* Print information about bitmap allocated */
-  winDebug ("winAllocateFBShadowGDI - Dibsection width: %d height: %d "
-	  "depth: %d size image: %d\n",
-	  (int) dibsection.dsBmih.biWidth, (int) dibsection.dsBmih.biHeight,
-	  dibsection.dsBmih.biBitCount,
-	  (int) dibsection.dsBmih.biSizeImage);
-
-  /* Select the shadow bitmap into the shadow DC */
-  SelectObject (pScreenPriv->hdcShadow,
-		pScreenPriv->hbmpShadow);
-
-  winDebug ("winAllocateFBShadowGDI - Attempting a shadow blit\n");
-
-  /* Do a test blit from the shadow to the screen, I think */
-  fReturn = BitBlt (pScreenPriv->hdcScreen,
-		    0, 0,
-		    pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-		    pScreenPriv->hdcShadow,
-		    0, 0,
-		    SRCCOPY);
-  if (fReturn)
-    {
-      winDebug ("winAllocateFBShadowGDI - Shadow blit success\n");
-    }
-  else
-    {
-      winW32Error ("winAllocateFBShadowGDI - Shadow blit failure\n");
-      /* ago: ignore this error. The blit fails with wine, but does not 
-       * cause any problems later. */
-
-      fReturn = TRUE;
-    }
-
-  /* Look for height weirdness */
-  if (dibsection.dsBmih.biHeight < 0)
-    {
-      dibsection.dsBmih.biHeight = -dibsection.dsBmih.biHeight;
-    }
-
-  /* Set screeninfo stride */
-  pScreenInfo->dwStride = ((dibsection.dsBmih.biSizeImage
-			    / dibsection.dsBmih.biHeight)
-			   * 8) / pScreenInfo->dwBPP;
-
-  winDebug ("winAllocateFBShadowGDI - Created shadow stride: %d\n",
-	  (int) pScreenInfo->dwStride);
-
-  /* See if the shadow bitmap will be larger than the DIB size limit */
-  if (pScreenInfo->dwWidth * pScreenInfo->dwHeight * pScreenInfo->dwBPP
-      >= WIN_DIB_MAXIMUM_SIZE)
-    {
-      ErrorF ("winAllocateFBShadowGDI - Requested DIB (bitmap) "
-	      "will be larger than %d MB.  The surface may fail to be "
-	      "allocated on Windows 95, 98, or Me, due to a %d MB limit in "
-	      "DIB size.  This limit does not apply to Windows NT/2000, and "
-	      "this message may be ignored on those platforms.\n",
-	      WIN_DIB_MAXIMUM_SIZE_MB, WIN_DIB_MAXIMUM_SIZE_MB);
-    }
-
-  /* Determine our color masks */
-  if (!winQueryRGBBitsAndMasks (pScreen))
-    {
-      ErrorF ("winAllocateFBShadowGDI - winQueryRGBBitsAndMasks failed\n");
-      return FALSE;
-    }
-
-#ifdef XWIN_MULTIWINDOW
-  /* Redraw all windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows (g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);
-#endif
-
-  return fReturn;
-}
-
-
-/*
- * Blit the damaged regions of the shadow fb to the screen
- */
-
-static void
-winShadowUpdateGDI (ScreenPtr pScreen, 
-		    shadowBufPtr pBuf)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  RegionPtr		damage = shadowDamage(pBuf);
-  DWORD			dwBox = REGION_NUM_RECTS (damage);
-  BoxPtr		pBox = REGION_RECTS (damage);
-  int			x, y, w, h;
-  HRGN			hrgnTemp = NULL, hrgnCombined = NULL;
-#ifdef XWIN_UPDATESTATS
-  static DWORD		s_dwNonUnitRegions = 0;
-  static DWORD		s_dwTotalUpdates = 0;
-  static DWORD		s_dwTotalBoxes = 0;
-#endif
-  BoxPtr		pBoxExtents = REGION_EXTENTS (pScreen, damage);
-
-  /*
-   * Return immediately if the app is not active
-   * and we are fullscreen, or if we have a bad display depth
-   */
-  if ((!pScreenPriv->fActive && pScreenInfo->fFullScreen)
-      || pScreenPriv->fBadDepth) return;
-
-#ifdef XWIN_UPDATESTATS
-  ++s_dwTotalUpdates;
-  s_dwTotalBoxes += dwBox;
-
-  if (dwBox != 1)
-    {
-      ++s_dwNonUnitRegions;
-      winDebug ("winShadowUpdatGDI - dwBox: %d\n", dwBox);
-    }
-  
-  if ((s_dwTotalUpdates % 100) == 0)
-  {
-    winDebug ("winShadowUpdateGDI - %d%% non-unity regions, avg boxes: %d "
-	    "nu: %d tu: %d\n",
-	    (s_dwNonUnitRegions * 100) / s_dwTotalUpdates,
-	    s_dwTotalBoxes / s_dwTotalUpdates,
-	    s_dwNonUnitRegions, s_dwTotalUpdates);
-  }
-#endif /* XWIN_UPDATESTATS */
-
-  /*
-   * Handle small regions with multiple blits,
-   * handle large regions by creating a clipping region and 
-   * doing a single blit constrained to that clipping region.
-   */
-  if (!pScreenInfo->fMultiWindow &&
-      (pScreenInfo->dwClipUpdatesNBoxes == 0 ||
-      dwBox < pScreenInfo->dwClipUpdatesNBoxes))
-    {
-      /* Loop through all boxes in the damaged region */
-      while (dwBox--)
-	{
-	  /*
-	   * Calculate x offset, y offset, width, and height for
-	   * current damage box
-	   */
-	  x = pBox->x1;
-	  y = pBox->y1;
-	  w = pBox->x2 - pBox->x1;
-	  h = pBox->y2 - pBox->y1;
-	  
-	  BitBlt (pScreenPriv->hdcScreen,
-		  x, y,
-		  w, h,
-		  pScreenPriv->hdcShadow,
-		  x, y,
-		  SRCCOPY);
-	  
-	  /* Get a pointer to the next box */
-	  ++pBox;
-	}
-    }
-  else if (!pScreenInfo->fMultiWindow)
-    {
-      /* Compute a GDI region from the damaged region */
-      hrgnCombined = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);
-      dwBox--;
-      pBox++;
-      while (dwBox--)
-	{
-	  hrgnTemp = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);
-	  CombineRgn (hrgnCombined, hrgnCombined, hrgnTemp, RGN_OR);
-	  DeleteObject (hrgnTemp);
-	  pBox++;
-	}
-      
-      /* Install the GDI region as a clipping region */
-      SelectClipRgn (pScreenPriv->hdcScreen, hrgnCombined);
-      DeleteObject (hrgnCombined);
-      hrgnCombined = NULL;
-      
-      /*
-       * Blit the shadow buffer to the screen,
-       * constrained to the clipping region.
-       */
-      BitBlt (pScreenPriv->hdcScreen,
-	      pBoxExtents->x1, pBoxExtents->y1,
-	      pBoxExtents->x2 - pBoxExtents->x1,
-	      pBoxExtents->y2 - pBoxExtents->y1,
-	      pScreenPriv->hdcShadow,
-	      pBoxExtents->x1, pBoxExtents->y1,
-	      SRCCOPY);
-
-      /* Reset the clip region */
-      SelectClipRgn (pScreenPriv->hdcScreen, NULL);
-    }
-
-#ifdef XWIN_MULTIWINDOW
-  /* Redraw all multiwindow windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows (g_dwCurrentThreadID,
-		       winRedrawDamagedWindowShadowGDI,
-		       (LPARAM)pBoxExtents);
-#endif
-}
-
-
-/* See Porting Layer Definition - p. 33 */
-/*
- * We wrap whatever CloseScreen procedure was specified by fb;
- * a pointer to said procedure is stored in our privates.
- */
-
-static Bool
-winCloseScreenShadowGDI (int nIndex, ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  Bool			fReturn;
-
-  winDebug ("winCloseScreenShadowGDI - Freeing screen resources\n");
-
-  /* Flag that the screen is closed */
-  pScreenPriv->fClosed = TRUE;
-  pScreenPriv->fActive = FALSE;
-
-  /* Call the wrapped CloseScreen procedure */
-  WIN_UNWRAP(CloseScreen);
-  fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);
-
-  /* Delete the window property */
-  RemoveProp (pScreenPriv->hwndScreen, WIN_SCR_PROP);
-
-  /* Free the shadow DC; which allows the bitmap to be freed */
-  DeleteDC (pScreenPriv->hdcShadow);
-  
-  /* Free the shadow bitmap */
-  DeleteObject (pScreenPriv->hbmpShadow);
-
-  /* Free the screen DC */
-  ReleaseDC (pScreenPriv->hwndScreen, pScreenPriv->hdcScreen);
-
-  /* Delete tray icon, if we have one */
-  if (!pScreenInfo->fNoTrayIcon)
-    winDeleteNotifyIcon (pScreenPriv);
-
-  /* Free the exit confirmation dialog box, if it exists */
-  if (g_hDlgExit != NULL)
-    {
-      DestroyWindow (g_hDlgExit);
-      g_hDlgExit = NULL;
-    }
-
-  /* Kill our window */
-  if (pScreenPriv->hwndScreen)
-    {
-      DestroyWindow (pScreenPriv->hwndScreen);
-      pScreenPriv->hwndScreen = NULL;
-    }
-
-#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
-  /* Destroy the thread startup mutex */
-  pthread_mutex_destroy (&pScreenPriv->pmServerStarted);
-#endif
-
-  /* Invalidate our screeninfo's pointer to the screen */
-  pScreenInfo->pScreen = NULL;
-
-  /* Invalidate the ScreenInfo's fb pointer */
-  pScreenInfo->pfb = NULL;
-
-  /* Free the screen privates for this screen */
-  free ((pointer) pScreenPriv);
-
-  return fReturn;
-}
-
-
-/*
- * Tell mi what sort of visuals we need.
- * 
- * Generally we only need one visual, as our screen can only
- * handle one format at a time, I believe.  You may want
- * to verify that last sentence.
- */
-
-static Bool
-winInitVisualsShadowGDI (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-
-  /* Display debugging information */
-  winDebug ("winInitVisualsShadowGDI - Masks %08x %08x %08x BPRGB %d d %d "
-	  "bpp %d\n",
-	  (unsigned int) pScreenPriv->dwRedMask,
-	  (unsigned int) pScreenPriv->dwGreenMask,
-	  (unsigned int) pScreenPriv->dwBlueMask,
-	  (int) pScreenPriv->dwBitsPerRGB,
-	  (int) pScreenInfo->dwDepth,
-	  (int) pScreenInfo->dwBPP);
-
-  /* Create a single visual according to the Windows screen depth */
-  switch (pScreenInfo->dwDepth)
-    {
-    case 24:
-    case 16:
-    case 15:
-#if defined(XFree86Server)
-      /* Setup the real visual */
-      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     TrueColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     -1,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "
-		  "failed\n");
-	  return FALSE;
-	}
-
-#ifdef XWIN_EMULATEPSEUDO
-      if (!pScreenInfo->fEmulatePseudo)
-	break;
-
-      /* Setup a pseudocolor visual */
-      if (!miSetVisualTypesAndMasks (8,
-				     PseudoColorMask,
-				     8,
-				     -1,
-				     0,
-				     0,
-				     0))
-	{
-	  ErrorF ("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "
-		  "failed for PseudoColor\n");
-	  return FALSE;
-	}
-#endif
-#else /* XFree86Server */
-      /* Setup the real visual */
-      if (!fbSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     TrueColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowGDI - fbSetVisualTypesAndMasks "
-		  "failed for TrueColor\n");
-	  return FALSE;
-	}
-
-#ifdef XWIN_EMULATEPSEUDO
-      if (!pScreenInfo->fEmulatePseudo)
-	break;
-
-      /* Setup a pseudocolor visual */
-      if (!fbSetVisualTypesAndMasks (8,
-				     PseudoColorMask,
-				     8,
-				     0,
-				     0,
-				     0))
-	{
-	  ErrorF ("winInitVisualsShadowGDI - fbSetVisualTypesAndMasks "
-		  "failed for PseudoColor\n");
-	  return FALSE;
-	}
-#endif
-#endif /* XFree86Server */
-      break;
-
-    case 8:
-#if defined(XFree86Server)
-      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     PseudoColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     PseudoColor,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "
-		  "failed\n");
-	  return FALSE;
-	}
-#else /* XFree86Server */
-      if (!fbSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     PseudoColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowGDI - fbSetVisualTypesAndMasks "
-		  "failed\n");
-	  return FALSE;
-	}
-#endif
-      break;
-
-    default:
-      ErrorF ("winInitVisualsShadowGDI - Unknown screen depth\n");
-      return FALSE;
-    }
-
-  winDebug ("winInitVisualsShadowGDI - Returning\n");
-
-  return TRUE;
-}
-
-
-/*
- * Adjust the proposed video mode
- */
-
-static Bool
-winAdjustVideoModeShadowGDI (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  HDC			hdc;
-  DWORD			dwBPP;
-  
-  hdc = GetDC (NULL);
-
-  /* We're in serious trouble if we can't get a DC */
-  if (hdc == NULL)
-    {
-      ErrorF ("winAdjustVideoModeShadowGDI - GetDC () failed\n");
-      return FALSE;
-    }
-
-  /* Query GDI for current display depth */
-  dwBPP = GetDeviceCaps (hdc, BITSPIXEL);
-
-  /* GDI cannot change the screen depth */
-  if (pScreenInfo->dwBPP == WIN_DEFAULT_BPP)
-    {
-      /* No -depth parameter passed, let the user know the depth being used */
-      winDebug ("winAdjustVideoModeShadowGDI - Using Windows display "
-	      "depth of %d bits per pixel\n", (int) dwBPP);
-
-      /* Use GDI's depth */
-      pScreenInfo->dwBPP = dwBPP;
-    }
-  else if (dwBPP != pScreenInfo->dwBPP)
-    {
-      /* Warn user if GDI depth is different than -depth parameter */
-      winDebug ("winAdjustVideoModeShadowGDI - Command line bpp: %d, "\
-	      "using bpp: %d\n", (int) pScreenInfo->dwBPP, (int) dwBPP);
-
-      /* We'll use GDI's depth */
-      pScreenInfo->dwBPP = dwBPP;
-    }
-  
-  /* Release our DC */
-  ReleaseDC (NULL, hdc);
-  hdc = NULL;
-
-  return TRUE;
-}
-
-
-/*
- * Blt exposed regions to the screen
- */
-
-static Bool
-winBltExposedRegionsShadowGDI (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  winPrivCmapPtr	pCmapPriv = NULL;
-  HDC			hdcUpdate;
-  PAINTSTRUCT		ps;
-
-  /* BeginPaint gives us an hdc that clips to the invalidated region */
-  hdcUpdate = BeginPaint (pScreenPriv->hwndScreen, &ps);
-
-  /* Realize the palette, if we have one */
-  if (pScreenPriv->pcmapInstalled != NULL)
-    {
-      pCmapPriv = winGetCmapPriv (pScreenPriv->pcmapInstalled);
-      
-      SelectPalette (hdcUpdate, pCmapPriv->hPalette, FALSE);
-      RealizePalette (hdcUpdate);
-    }
-
-  /* Our BitBlt will be clipped to the invalidated region */
-  BitBlt (hdcUpdate,
-	  0, 0,
-	  pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-	  pScreenPriv->hdcShadow,
-	  0, 0,
-	  SRCCOPY);
-
-  /* EndPaint frees the DC */
-  EndPaint (pScreenPriv->hwndScreen, &ps);
-
-#ifdef XWIN_MULTIWINDOW
-  /* Redraw all windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 
-            (LPARAM)pScreenPriv->hwndScreen);
-#endif
-
-  return TRUE;
-}
-
-
-/*
- * Do any engine-specific appliation-activation processing
- */
-
-static Bool
-winActivateAppShadowGDI (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-
-  /*
-   * 2004/04/12 - Harold - We perform the restoring or minimizing
-   * manually for ShadowGDI in fullscreen modes so that this engine
-   * will perform just like ShadowDD and ShadowDDNL in fullscreen mode;
-   * if we do not do this then our fullscreen window will appear in the
-   * z-order when it is deactivated and it can be uncovered by resizing
-   * or minimizing another window that is on top of it, which is not how
-   * the DirectDraw engines work.  Therefore we keep this code here to
-   * make sure that all engines work the same in fullscreen mode.
-   */
-
-  /*
-   * Are we active?
-   * Are we fullscreen?
-   */
-  if (pScreenPriv->fActive
-      && pScreenInfo->fFullScreen)
-    {
-      /*
-       * Activating, attempt to bring our window 
-       * to the top of the display
-       */
-      ShowWindow (pScreenPriv->hwndScreen, SW_RESTORE);
-    }
-  else if (!pScreenPriv->fActive
-	   && pScreenInfo->fFullScreen)
-    {
-      /*
-       * Deactivating, stuff our window onto the
-       * task bar.
-       */
-      ShowWindow (pScreenPriv->hwndScreen, SW_MINIMIZE);
-    }
-
-  return TRUE;
-}
-
-
-/*
- * Reblit the shadow framebuffer to the screen.
- */
-
-static Bool
-winRedrawScreenShadowGDI (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-
-  /* Redraw the whole window, to take account for the new colors */
-  BitBlt (pScreenPriv->hdcScreen,
-	  0, 0,
-	  pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-	  pScreenPriv->hdcShadow,
-	  0, 0,
-	  SRCCOPY);
-
-#ifdef XWIN_MULTIWINDOW
-  /* Redraw all windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);
-#endif
-
-  return TRUE;
-}
-
-
-
-/*
- * Realize the currently installed colormap
- */
-
-static Bool
-winRealizeInstalledPaletteShadowGDI (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winPrivCmapPtr	pCmapPriv = NULL;
-
-  winDebug ("winRealizeInstalledPaletteShadowGDI\n");
-
-  /* Don't do anything if there is not a colormap */
-  if (pScreenPriv->pcmapInstalled == NULL)
-    {
-      winDebug ("winRealizeInstalledPaletteShadowGDI - No colormap "
-	      "installed\n");
-      return TRUE;
-    }
-
-  pCmapPriv = winGetCmapPriv (pScreenPriv->pcmapInstalled);
-  
-  /* Realize our palette for the screen */
-  if (RealizePalette (pScreenPriv->hdcScreen) == GDI_ERROR)
-    {
-      ErrorF ("winRealizeInstalledPaletteShadowGDI - RealizePalette () "
-	      "failed\n");
-      return FALSE;
-    }
-  
-  /* Set the DIB color table */
-  if (SetDIBColorTable (pScreenPriv->hdcShadow,
-			0,
-			WIN_NUM_PALETTE_ENTRIES,
-			pCmapPriv->rgbColors) == 0)
-    {
-      ErrorF ("winRealizeInstalledPaletteShadowGDI - SetDIBColorTable () "
-	      "failed\n");
-      return FALSE;
-    }
-  
-  return TRUE;
-}
-
-
-/*
- * Install the specified colormap
- */
-
-static Bool
-winInstallColormapShadowGDI (ColormapPtr pColormap)
-{
-  ScreenPtr		pScreen = pColormap->pScreen;
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  winCmapPriv(pColormap);
-
-  /*
-   * Tell Windows to install the new colormap
-   */
-  if (SelectPalette (pScreenPriv->hdcScreen,
-		     pCmapPriv->hPalette,
-		     FALSE) == NULL)
-    {
-      ErrorF ("winInstallColormapShadowGDI - SelectPalette () failed\n");
-      return FALSE;
-    }
-      
-  /* Realize the palette */
-  if (GDI_ERROR == RealizePalette (pScreenPriv->hdcScreen))
-    {
-      ErrorF ("winInstallColormapShadowGDI - RealizePalette () failed\n");
-      return FALSE;
-    }
-
-  /* Set the DIB color table */
-  if (SetDIBColorTable (pScreenPriv->hdcShadow,
-			0,
-			WIN_NUM_PALETTE_ENTRIES,
-			pCmapPriv->rgbColors) == 0)
-    {
-      ErrorF ("winInstallColormapShadowGDI - SetDIBColorTable () failed\n");
-      return FALSE;
-    }
-
-  /* Redraw the whole window, to take account for the new colors */
-  BitBlt (pScreenPriv->hdcScreen,
-	  0, 0,
-	  pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-	  pScreenPriv->hdcShadow,
-	  0, 0,
-	  SRCCOPY);
-
-  /* Save a pointer to the newly installed colormap */
-  pScreenPriv->pcmapInstalled = pColormap;
-
-#ifdef XWIN_MULTIWINDOW
-  /* Redraw all windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows (g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);
-#endif
-
-  return TRUE;
-}
-
-
-/*
- * Store the specified colors in the specified colormap
- */
-
-static Bool
-winStoreColorsShadowGDI (ColormapPtr pColormap,
-			 int ndef,
-			 xColorItem *pdefs)
-{
-  ScreenPtr		pScreen = pColormap->pScreen;
-  winScreenPriv(pScreen);
-  winCmapPriv(pColormap);
-  ColormapPtr curpmap = pScreenPriv->pcmapInstalled;
-  
-  /* Put the X colormap entries into the Windows logical palette */
-  if (SetPaletteEntries (pCmapPriv->hPalette,
-			 pdefs[0].pixel,
-			 ndef,
-			 pCmapPriv->peColors + pdefs[0].pixel) == 0)
-    {
-      ErrorF ("winStoreColorsShadowGDI - SetPaletteEntries () failed\n");
-      return FALSE;
-    }
-
-  /* Don't install the Windows palette if the colormap is not installed */
-  if (pColormap != curpmap)
-    {
-      return TRUE;
-    }
-
-  /* Try to install the newly modified colormap */
-  if (!winInstallColormapShadowGDI (pColormap))
-    {
-      ErrorF ("winInstallColormapShadowGDI - winInstallColormapShadowGDI "
-	      "failed\n");
-      return FALSE;
-    }
-
-#if 0
-  /* Tell Windows that the palette has changed */
-  RealizePalette (pScreenPriv->hdcScreen);
-  
-  /* Set the DIB color table */
-  if (SetDIBColorTable (pScreenPriv->hdcShadow,
-			pdefs[0].pixel,
-			ndef,
-			pCmapPriv->rgbColors + pdefs[0].pixel) == 0)
-    {
-      ErrorF ("winInstallColormapShadowGDI - SetDIBColorTable () failed\n");
-      return FALSE;
-    }
-
-  /* Save a pointer to the newly installed colormap */
-  pScreenPriv->pcmapInstalled = pColormap;
-#endif
-
-  return TRUE;
-}
-
-
-/*
- * Colormap initialization procedure
- */
-
-static Bool
-winCreateColormapShadowGDI (ColormapPtr pColormap)
-{
-  LPLOGPALETTE		lpPaletteNew = NULL;
-  DWORD			dwEntriesMax;
-  VisualPtr		pVisual;
-  HPALETTE		hpalNew = NULL;
-  winCmapPriv(pColormap);
-
-  /* Get a pointer to the visual that the colormap belongs to */
-  pVisual = pColormap->pVisual;
-
-  /* Get the maximum number of palette entries for this visual */
-  dwEntriesMax = pVisual->ColormapEntries;
-
-  /* Allocate a Windows logical color palette with max entries */
-  lpPaletteNew = malloc (sizeof (LOGPALETTE)
-			 + (dwEntriesMax - 1) * sizeof (PALETTEENTRY));
-  if (lpPaletteNew == NULL)
-    {
-      ErrorF ("winCreateColormapShadowGDI - Couldn't allocate palette "
-	      "with %d entries\n",
-	      (int) dwEntriesMax);
-      return FALSE;
-    }
-
-  /* Zero out the colormap */
-  ZeroMemory (lpPaletteNew, sizeof (LOGPALETTE)
-	      + (dwEntriesMax - 1) * sizeof (PALETTEENTRY));
-  
-  /* Set the logical palette structure */
-  lpPaletteNew->palVersion = 0x0300;
-  lpPaletteNew->palNumEntries = dwEntriesMax;
-
-  /* Tell Windows to create the palette */
-  hpalNew = CreatePalette (lpPaletteNew);
-  if (hpalNew == NULL)
-    {
-      ErrorF ("winCreateColormapShadowGDI - CreatePalette () failed\n");
-      free (lpPaletteNew);
-      return FALSE;
-    }
-
-  /* Save the Windows logical palette handle in the X colormaps' privates */
-  pCmapPriv->hPalette = hpalNew;
-
-  /* Free the palette initialization memory */
-  free (lpPaletteNew);
-
-  return TRUE;
-}
-
-
-/*
- * Colormap destruction procedure
- */
-
-static Bool
-winDestroyColormapShadowGDI (ColormapPtr pColormap)
-{
-  winScreenPriv(pColormap->pScreen);
-  winCmapPriv(pColormap);
-
-  /*
-   * Is colormap to be destroyed the default?
-   *
-   * Non-default colormaps should have had winUninstallColormap
-   * called on them before we get here.  The default colormap
-   * will not have had winUninstallColormap called on it.  Thus,
-   * we need to handle the default colormap in a special way.
-   */
-  if (pColormap->flags & IsDefault)
-    {
-      winDebug ("winDestroyColormapShadowGDI - Destroying default "
-	      "colormap\n");
-      
-      /*
-       * FIXME: Walk the list of all screens, popping the default
-       * palette out of each screen device context.
-       */
-      
-      /* Pop the palette out of the device context */
-      SelectPalette (pScreenPriv->hdcScreen,
-		     GetStockObject (DEFAULT_PALETTE),
-		     FALSE);
-
-      /* Clear our private installed colormap pointer */
-      pScreenPriv->pcmapInstalled = NULL;
-    }
-  
-  /* Try to delete the logical palette */
-  if (DeleteObject (pCmapPriv->hPalette) == 0)
-    {
-      ErrorF ("winDestroyColormap - DeleteObject () failed\n");
-      return FALSE;
-    }
-  
-  /* Invalidate the colormap privates */
-  pCmapPriv->hPalette = NULL;
-
-  return TRUE;
-}
-
-
-/*
- * Set engine specific funtions
- */
-
-Bool
-winSetEngineFunctionsShadowGDI (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  
-  /* Set our pointers */
-  pScreenPriv->pwinAllocateFB = winAllocateFBShadowGDI;
-  pScreenPriv->pwinShadowUpdate = winShadowUpdateGDI;
-  pScreenPriv->pwinCloseScreen = winCloseScreenShadowGDI;
-  pScreenPriv->pwinInitVisuals = winInitVisualsShadowGDI;
-  pScreenPriv->pwinAdjustVideoMode = winAdjustVideoModeShadowGDI;
-  if (pScreenInfo->fFullScreen)
-    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowFullScreen;
-  else
-    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowWindowed;
-  pScreenPriv->pwinFinishScreenInit = winFinishScreenInitFB;
-  pScreenPriv->pwinBltExposedRegions = winBltExposedRegionsShadowGDI;
-  pScreenPriv->pwinActivateApp = winActivateAppShadowGDI;
-  pScreenPriv->pwinRedrawScreen = winRedrawScreenShadowGDI;
-  pScreenPriv->pwinRealizeInstalledPalette = 
-    winRealizeInstalledPaletteShadowGDI;
-  pScreenPriv->pwinInstallColormap = winInstallColormapShadowGDI;
-  pScreenPriv->pwinStoreColors = winStoreColorsShadowGDI;
-  pScreenPriv->pwinCreateColormap = winCreateColormapShadowGDI;
-  pScreenPriv->pwinDestroyColormap = winDestroyColormapShadowGDI;
-  pScreenPriv->pwinHotKeyAltTab = (winHotKeyAltTabProcPtr) (void (*)(void))NoopDDA;
-  pScreenPriv->pwinCreatePrimarySurface
-    = (winCreatePrimarySurfaceProcPtr) (void (*)(void))NoopDDA;
-  pScreenPriv->pwinReleasePrimarySurface
-    = (winReleasePrimarySurfaceProcPtr) (void (*)(void))NoopDDA;
-#ifdef XWIN_MULTIWINDOW
-  pScreenPriv->pwinFinishCreateWindowsWindow =
-    (winFinishCreateWindowsWindowProcPtr) (void (*)(void))NoopDDA;
-#endif
-
-  return TRUE;
-}
+/*

+ *Copyright (C) 2001-2004 Harold L Hunt II All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL HAROLD L HUNT II BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of Harold L Hunt II

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from Harold L Hunt II.

+ *

+ * Authors:	Harold L Hunt II

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+

+

+/*

+ * External symbols

+ */

+

+#ifdef XWIN_MULTIWINDOW

+extern DWORD			g_dwCurrentThreadID;

+#endif

+extern HWND			g_hDlgExit;

+

+

+/*

+ * Local function prototypes

+ */

+

+#ifdef XWIN_MULTIWINDOW

+static wBOOL CALLBACK

+winRedrawAllProcShadowGDI (HWND hwnd, LPARAM lParam);

+

+static wBOOL CALLBACK

+winRedrawDamagedWindowShadowGDI (HWND hwnd, LPARAM lParam);

+#endif

+

+static Bool

+winAllocateFBShadowGDI (ScreenPtr pScreen);

+

+static void

+winShadowUpdateGDI (ScreenPtr pScreen, 

+		    shadowBufPtr pBuf);

+

+static Bool

+winCloseScreenShadowGDI (int nIndex, ScreenPtr pScreen);

+

+static Bool

+winInitVisualsShadowGDI (ScreenPtr pScreen);

+

+static Bool

+winAdjustVideoModeShadowGDI (ScreenPtr pScreen);

+

+static Bool

+winBltExposedRegionsShadowGDI (ScreenPtr pScreen);

+

+static Bool

+winActivateAppShadowGDI (ScreenPtr pScreen);

+

+static Bool

+winRedrawScreenShadowGDI (ScreenPtr pScreen);

+

+static Bool

+winRealizeInstalledPaletteShadowGDI (ScreenPtr pScreen);

+

+static Bool

+winInstallColormapShadowGDI (ColormapPtr pColormap);

+

+static Bool

+winStoreColorsShadowGDI (ColormapPtr pmap, 

+			 int ndef,

+			 xColorItem *pdefs);

+

+static Bool

+winCreateColormapShadowGDI (ColormapPtr pColormap);

+

+static Bool

+winDestroyColormapShadowGDI (ColormapPtr pColormap);

+

+

+/*

+ * Internal function to get the DIB format that is compatible with the screen

+ */

+

+static

+Bool

+winQueryScreenDIBFormat (ScreenPtr pScreen, BITMAPINFOHEADER *pbmih)

+{

+  winScreenPriv(pScreen);

+  HBITMAP		hbmp;

+#ifdef WINDBG

+  LPDWORD		pdw = NULL;

+#endif

+  

+  /* Create a memory bitmap compatible with the screen */

+  hbmp = CreateCompatibleBitmap (pScreenPriv->hdcScreen, 1, 1);

+  if (hbmp == NULL)

+    {

+      ErrorF ("winQueryScreenDIBFormat - CreateCompatibleBitmap failed\n");

+      return FALSE;

+    }

+  

+  /* Initialize our bitmap info header */

+  ZeroMemory (pbmih, sizeof (BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD));

+  pbmih->biSize = sizeof (BITMAPINFOHEADER);

+

+  /* Get the biBitCount */

+  if (!GetDIBits (pScreenPriv->hdcScreen,

+		  hbmp,

+		  0, 1,

+		  NULL,

+		  (BITMAPINFO*) pbmih,

+		  DIB_RGB_COLORS))

+    {

+      ErrorF ("winQueryScreenDIBFormat - First call to GetDIBits failed\n");

+      DeleteObject (hbmp);

+      return FALSE;

+    }

+

+#ifdef WINDBG

+  /* Get a pointer to bitfields */

+  pdw = (DWORD*) ((CARD8*)pbmih + sizeof (BITMAPINFOHEADER));

+

+  winDebug ("winQueryScreenDIBFormat - First call masks: %08x %08x %08x\n",

+	  pdw[0], pdw[1], pdw[2]);

+#endif

+

+  /* Get optimal color table, or the optimal bitfields */

+  if (!GetDIBits (pScreenPriv->hdcScreen,

+		  hbmp,

+		  0, 1,

+		  NULL,

+		  (BITMAPINFO*)pbmih,

+		  DIB_RGB_COLORS))

+    {

+      ErrorF ("winQueryScreenDIBFormat - Second call to GetDIBits "

+	      "failed\n");

+      DeleteObject (hbmp);

+      return FALSE;

+    }

+

+  /* Free memory */

+  DeleteObject (hbmp);

+  

+  return TRUE;

+}

+

+

+/*

+ * Internal function to determine the GDI bits per rgb and bit masks

+ */

+

+static

+Bool

+winQueryRGBBitsAndMasks (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  BITMAPINFOHEADER	*pbmih = NULL;

+  Bool			fReturn = TRUE;

+  LPDWORD		pdw = NULL;

+  DWORD			dwRedBits, dwGreenBits, dwBlueBits;

+

+  /* Color masks for 8 bpp are standardized */

+  if (GetDeviceCaps (pScreenPriv->hdcScreen, RASTERCAPS) & RC_PALETTE)

+    {

+      /* 

+       * RGB BPP for 8 bit palletes is always 8

+       * and the color masks are always 0.

+       */

+      pScreenPriv->dwBitsPerRGB = 8;

+      pScreenPriv->dwRedMask = 0x0L;

+      pScreenPriv->dwGreenMask = 0x0L;

+      pScreenPriv->dwBlueMask = 0x0L;

+      return TRUE;

+    }

+

+  /* Color masks for 24 bpp are standardized */

+  if (GetDeviceCaps (pScreenPriv->hdcScreen, PLANES)

+      * GetDeviceCaps (pScreenPriv->hdcScreen, BITSPIXEL) == 24)

+    {

+      winDebug ("winQueryRGBBitsAndMasks - GetDeviceCaps (BITSPIXEL) "

+	      "returned 24 for the screen.  Using default 24bpp masks.\n");

+

+      /* 8 bits per primary color */

+      pScreenPriv->dwBitsPerRGB = 8;

+

+      /* Set screen privates masks */

+      pScreenPriv->dwRedMask = WIN_24BPP_MASK_RED;

+      pScreenPriv->dwGreenMask = WIN_24BPP_MASK_GREEN;

+      pScreenPriv->dwBlueMask = WIN_24BPP_MASK_BLUE;

+      

+      return TRUE;

+    }

+

+  /* Allocate a bitmap header and color table */

+  pbmih = (BITMAPINFOHEADER*) malloc (sizeof (BITMAPINFOHEADER)

+				      + 256  * sizeof (RGBQUAD));

+  if (pbmih == NULL)

+    {

+      ErrorF ("winQueryRGBBitsAndMasks - malloc failed\n");

+      return FALSE;

+    }

+

+  /* Get screen description */

+  if (winQueryScreenDIBFormat (pScreen, pbmih))

+    {

+      /* Get a pointer to bitfields */

+      pdw = (DWORD*) ((CARD8*)pbmih + sizeof (BITMAPINFOHEADER));

+      

+#ifdef WINDBG

+      winDebug ("%s - Masks: %08x %08x %08x\n", __FUNCTION__,

+	      pdw[0], pdw[1], pdw[2]);

+      winDebug ("%s - Bitmap: %dx%d %d bpp %d planes\n", __FUNCTION__,

+              pbmih->biWidth, pbmih->biHeight, pbmih->biBitCount, pbmih->biPlanes);

+      winDebug ("%s - Compression: %d %s\n", __FUNCTION__,

+              pbmih->biCompression,

+              (pbmih->biCompression == BI_RGB?"(BI_RGB)":

+               (pbmih->biCompression == BI_RLE8?"(BI_RLE8)":

+                (pbmih->biCompression == BI_RLE4?"(BI_RLE4)":

+                 (pbmih->biCompression == BI_BITFIELDS?"(BI_BITFIELDS)":""

+                 )))));

+#endif

+

+      /* Handle BI_RGB case, which is returned by Wine */

+      if (pbmih->biCompression == BI_RGB)

+        {

+	  dwRedBits = 5;

+	  dwGreenBits = 5;

+	  dwBlueBits = 5;

+	  

+	  pScreenPriv->dwBitsPerRGB = 5;

+	  

+	  /* Set screen privates masks */

+	  pScreenPriv->dwRedMask = 0x7c00;

+	  pScreenPriv->dwGreenMask = 0x03e0;

+	  pScreenPriv->dwBlueMask = 0x001f;

+        }

+      else 

+        {

+          /* Count the number of bits in each mask */

+          dwRedBits = winCountBits (pdw[0]);

+          dwGreenBits = winCountBits (pdw[1]);

+          dwBlueBits = winCountBits (pdw[2]);

+

+	  /* Find maximum bits per red, green, blue */

+	  if (dwRedBits > dwGreenBits && dwRedBits > dwBlueBits)

+	    pScreenPriv->dwBitsPerRGB = dwRedBits;

+	  else if (dwGreenBits > dwRedBits && dwGreenBits > dwBlueBits)

+	    pScreenPriv->dwBitsPerRGB = dwGreenBits;

+	  else

+	    pScreenPriv->dwBitsPerRGB = dwBlueBits;

+

+	  /* Set screen privates masks */

+	  pScreenPriv->dwRedMask = pdw[0];

+	  pScreenPriv->dwGreenMask = pdw[1];

+	  pScreenPriv->dwBlueMask = pdw[2];

+	}

+    }

+  else

+    {

+      ErrorF ("winQueryRGBBitsAndMasks - winQueryScreenDIBFormat failed\n");

+      free (pbmih);

+      fReturn = FALSE;

+    }

+

+  /* Free memory */

+  free (pbmih);

+

+  return fReturn;

+}

+

+

+#ifdef XWIN_MULTIWINDOW

+/*

+ * Redraw all ---?

+ */

+

+static wBOOL CALLBACK

+winRedrawAllProcShadowGDI (HWND hwnd, LPARAM lParam)

+{

+  if (hwnd == (HWND)lParam)

+    return TRUE;  

+  InvalidateRect (hwnd, NULL, FALSE);

+  UpdateWindow (hwnd);

+  return TRUE;

+}

+

+static wBOOL CALLBACK

+winRedrawDamagedWindowShadowGDI (HWND hwnd, LPARAM lParam)

+{

+  BoxPtr pDamage = (BoxPtr)lParam;

+  RECT rcClient, rcDamage, rcRedraw;

+  POINT topLeft, bottomRight;

+  

+  if (IsIconic (hwnd))

+    return TRUE; /* Don't care minimized windows */

+  

+  /* Convert the damaged area from Screen coords to Client coords */

+  topLeft.x = pDamage->x1; topLeft.y = pDamage->y1;

+  bottomRight.x = pDamage->x2; bottomRight.y = pDamage->y2;

+  topLeft.x += GetSystemMetrics (SM_XVIRTUALSCREEN);

+  bottomRight.x += GetSystemMetrics (SM_XVIRTUALSCREEN);

+  topLeft.y += GetSystemMetrics (SM_YVIRTUALSCREEN);

+  bottomRight.y += GetSystemMetrics (SM_YVIRTUALSCREEN);

+  ScreenToClient (hwnd, &topLeft);

+  ScreenToClient (hwnd, &bottomRight);

+  SetRect (&rcDamage, topLeft.x, topLeft.y, bottomRight.x, bottomRight.y);

+

+  GetClientRect (hwnd, &rcClient);

+

+  if (IntersectRect (&rcRedraw, &rcClient, &rcDamage))

+    {

+      InvalidateRect (hwnd, &rcRedraw, FALSE);

+      UpdateWindow (hwnd);

+    }

+  return TRUE;

+}

+#endif

+

+

+/*

+ * Allocate a DIB for the shadow framebuffer GDI server

+ */

+

+static Bool

+winAllocateFBShadowGDI (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  BITMAPINFOHEADER	*pbmih = NULL;

+  DIBSECTION		dibsection;

+  Bool			fReturn = TRUE;

+

+  /* Get device contexts for the screen and shadow bitmap */

+  pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);

+  pScreenPriv->hdcShadow = CreateCompatibleDC (pScreenPriv->hdcScreen);

+

+  /* Allocate bitmap info header */

+  pbmih = (BITMAPINFOHEADER*) malloc (sizeof (BITMAPINFOHEADER)

+				      + 256 * sizeof (RGBQUAD));

+  if (pbmih == NULL)

+    {

+      ErrorF ("winAllocateFBShadowGDI - malloc () failed\n");

+      return FALSE;

+    }

+

+  /* Query the screen format */

+  fReturn = winQueryScreenDIBFormat (pScreen, pbmih);

+

+  /* Describe shadow bitmap to be created */

+  pbmih->biWidth = pScreenInfo->dwWidth;

+  pbmih->biHeight = -pScreenInfo->dwHeight;

+  

+  winDebug ("winAllocateFBShadowGDI - Creating DIB with width: %d height: %d "

+	  "depth: %d\n",

+	  (int) pbmih->biWidth, (int) -pbmih->biHeight, pbmih->biBitCount);

+

+  /* Create a DI shadow bitmap with a bit pointer */

+  pScreenPriv->hbmpShadow = CreateDIBSection (pScreenPriv->hdcScreen,

+					      (BITMAPINFO *) pbmih,

+					      DIB_RGB_COLORS,

+					      (VOID**) &pScreenInfo->pfb,

+					      NULL,

+					      0);

+  if (pScreenPriv->hbmpShadow == NULL || pScreenInfo->pfb == NULL)

+    {

+      winW32Error ("winAllocateFBShadowGDI - CreateDIBSection failed:");

+      return FALSE;

+    }

+  else

+    {

+      winDebug ("winAllocateFBShadowGDI - Shadow buffer allocated\n");

+    }

+

+  /* Get information about the bitmap that was allocated */

+  GetObject (pScreenPriv->hbmpShadow,

+	     sizeof (dibsection),

+	     &dibsection);

+

+  /* Print information about bitmap allocated */

+  winDebug ("winAllocateFBShadowGDI - Dibsection width: %d height: %d "

+	  "depth: %d size image: %d\n",

+	  (int) dibsection.dsBmih.biWidth, (int) dibsection.dsBmih.biHeight,

+	  dibsection.dsBmih.biBitCount,

+	  (int) dibsection.dsBmih.biSizeImage);

+

+  /* Select the shadow bitmap into the shadow DC */

+  SelectObject (pScreenPriv->hdcShadow,

+		pScreenPriv->hbmpShadow);

+

+  winDebug ("winAllocateFBShadowGDI - Attempting a shadow blit\n");

+

+  /* Do a test blit from the shadow to the screen, I think */

+  fReturn = BitBlt (pScreenPriv->hdcScreen,

+		    0, 0,

+		    pScreenInfo->dwWidth, pScreenInfo->dwHeight,

+		    pScreenPriv->hdcShadow,

+		    0, 0,

+		    SRCCOPY);

+  if (fReturn)

+    {

+      winDebug ("winAllocateFBShadowGDI - Shadow blit success\n");

+    }

+  else

+    {

+      winW32Error ("winAllocateFBShadowGDI - Shadow blit failure\n");

+      /* ago: ignore this error. The blit fails with wine, but does not 

+       * cause any problems later. */

+

+      fReturn = TRUE;

+    }

+

+  /* Look for height weirdness */

+  if (dibsection.dsBmih.biHeight < 0)

+    {

+      dibsection.dsBmih.biHeight = -dibsection.dsBmih.biHeight;

+    }

+

+  /* Set screeninfo stride */

+  pScreenInfo->dwStride = ((dibsection.dsBmih.biSizeImage

+			    / dibsection.dsBmih.biHeight)

+			   * 8) / pScreenInfo->dwBPP;

+

+  winDebug ("winAllocateFBShadowGDI - Created shadow stride: %d\n",

+	  (int) pScreenInfo->dwStride);

+

+  /* See if the shadow bitmap will be larger than the DIB size limit */

+  if (pScreenInfo->dwWidth * pScreenInfo->dwHeight * pScreenInfo->dwBPP

+      >= WIN_DIB_MAXIMUM_SIZE)

+    {

+      ErrorF ("winAllocateFBShadowGDI - Requested DIB (bitmap) "

+	      "will be larger than %d MB.  The surface may fail to be "

+	      "allocated on Windows 95, 98, or Me, due to a %d MB limit in "

+	      "DIB size.  This limit does not apply to Windows NT/2000, and "

+	      "this message may be ignored on those platforms.\n",

+	      WIN_DIB_MAXIMUM_SIZE_MB, WIN_DIB_MAXIMUM_SIZE_MB);

+    }

+

+  /* Determine our color masks */

+  if (!winQueryRGBBitsAndMasks (pScreen))

+    {

+      ErrorF ("winAllocateFBShadowGDI - winQueryRGBBitsAndMasks failed\n");

+      return FALSE;

+    }

+

+#ifdef XWIN_MULTIWINDOW

+  /* Redraw all windows */

+  if (pScreenInfo->fMultiWindow)

+    EnumThreadWindows (g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);

+#endif

+

+  return fReturn;

+}

+

+

+/*

+ * Blit the damaged regions of the shadow fb to the screen

+ */

+

+static void

+winShadowUpdateGDI (ScreenPtr pScreen, 

+		    shadowBufPtr pBuf)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  RegionPtr		damage = shadowDamage(pBuf);

+  DWORD			dwBox = RegionNumRects (damage);

+  BoxPtr		pBox = RegionRects (damage);

+  int			x, y, w, h;

+  HRGN			hrgnTemp = NULL, hrgnCombined = NULL;

+#ifdef XWIN_UPDATESTATS

+  static DWORD		s_dwNonUnitRegions = 0;

+  static DWORD		s_dwTotalUpdates = 0;

+  static DWORD		s_dwTotalBoxes = 0;

+#endif

+  BoxPtr		pBoxExtents = RegionExtents(damage);

+

+  /*

+   * Return immediately if the app is not active

+   * and we are fullscreen, or if we have a bad display depth

+   */

+  if ((!pScreenPriv->fActive && pScreenInfo->fFullScreen)

+      || pScreenPriv->fBadDepth) return;

+

+#ifdef XWIN_UPDATESTATS

+  ++s_dwTotalUpdates;

+  s_dwTotalBoxes += dwBox;

+

+  if (dwBox != 1)

+    {

+      ++s_dwNonUnitRegions;

+      winDebug ("winShadowUpdatGDI - dwBox: %d\n", dwBox);

+    }

+  

+  if ((s_dwTotalUpdates % 100) == 0)

+  {

+    winDebug ("winShadowUpdateGDI - %d%% non-unity regions, avg boxes: %d "

+	    "nu: %d tu: %d\n",

+	    (s_dwNonUnitRegions * 100) / s_dwTotalUpdates,

+	    s_dwTotalBoxes / s_dwTotalUpdates,

+	    s_dwNonUnitRegions, s_dwTotalUpdates);

+  }

+#endif /* XWIN_UPDATESTATS */

+

+  /*

+   * Handle small regions with multiple blits,

+   * handle large regions by creating a clipping region and 

+   * doing a single blit constrained to that clipping region.

+   */

+  if (!pScreenInfo->fMultiWindow &&

+      (pScreenInfo->dwClipUpdatesNBoxes == 0 ||

+      dwBox < pScreenInfo->dwClipUpdatesNBoxes))

+    {

+      /* Loop through all boxes in the damaged region */

+      while (dwBox--)

+	{

+	  /*

+	   * Calculate x offset, y offset, width, and height for

+	   * current damage box

+	   */

+	  x = pBox->x1;

+	  y = pBox->y1;

+	  w = pBox->x2 - pBox->x1;

+	  h = pBox->y2 - pBox->y1;

+	  

+	  BitBlt (pScreenPriv->hdcScreen,

+		  x, y,

+		  w, h,

+		  pScreenPriv->hdcShadow,

+		  x, y,

+		  SRCCOPY);

+	  

+	  /* Get a pointer to the next box */

+	  ++pBox;

+	}

+    }

+  else if (!pScreenInfo->fMultiWindow)

+    {

+      /* Compute a GDI region from the damaged region */

+      hrgnCombined = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);

+      dwBox--;

+      pBox++;

+      while (dwBox--)

+	{

+	  hrgnTemp = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);

+	  CombineRgn (hrgnCombined, hrgnCombined, hrgnTemp, RGN_OR);

+	  DeleteObject (hrgnTemp);

+	  pBox++;

+	}

+      

+      /* Install the GDI region as a clipping region */

+      SelectClipRgn (pScreenPriv->hdcScreen, hrgnCombined);

+      DeleteObject (hrgnCombined);

+      hrgnCombined = NULL;

+      

+      /*

+       * Blit the shadow buffer to the screen,

+       * constrained to the clipping region.

+       */

+      BitBlt (pScreenPriv->hdcScreen,

+	      pBoxExtents->x1, pBoxExtents->y1,

+	      pBoxExtents->x2 - pBoxExtents->x1,

+	      pBoxExtents->y2 - pBoxExtents->y1,

+	      pScreenPriv->hdcShadow,

+	      pBoxExtents->x1, pBoxExtents->y1,

+	      SRCCOPY);

+

+      /* Reset the clip region */

+      SelectClipRgn (pScreenPriv->hdcScreen, NULL);

+    }

+

+#ifdef XWIN_MULTIWINDOW

+  /* Redraw all multiwindow windows */

+  if (pScreenInfo->fMultiWindow)

+    EnumThreadWindows (g_dwCurrentThreadID,

+		       winRedrawDamagedWindowShadowGDI,

+		       (LPARAM)pBoxExtents);

+#endif

+}

+

+

+/* See Porting Layer Definition - p. 33 */

+/*

+ * We wrap whatever CloseScreen procedure was specified by fb;

+ * a pointer to said procedure is stored in our privates.

+ */

+

+static Bool

+winCloseScreenShadowGDI (int nIndex, ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  Bool			fReturn;

+

+  winDebug ("winCloseScreenShadowGDI - Freeing screen resources\n");

+

+  /* Flag that the screen is closed */

+  pScreenPriv->fClosed = TRUE;

+  pScreenPriv->fActive = FALSE;

+

+  /* Call the wrapped CloseScreen procedure */

+  WIN_UNWRAP(CloseScreen);

+  fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);

+

+  /* Delete the window property */

+  RemoveProp (pScreenPriv->hwndScreen, WIN_SCR_PROP);

+

+  /* Free the shadow DC; which allows the bitmap to be freed */

+  DeleteDC (pScreenPriv->hdcShadow);

+  

+  /* Free the shadow bitmap */

+  DeleteObject (pScreenPriv->hbmpShadow);

+

+  /* Free the screen DC */

+  ReleaseDC (pScreenPriv->hwndScreen, pScreenPriv->hdcScreen);

+

+  /* Delete tray icon, if we have one */

+  if (!pScreenInfo->fNoTrayIcon)

+    winDeleteNotifyIcon (pScreenPriv);

+

+  /* Free the exit confirmation dialog box, if it exists */

+  if (g_hDlgExit != NULL)

+    {

+      DestroyWindow (g_hDlgExit);

+      g_hDlgExit = NULL;

+    }

+

+  /* Kill our window */

+  if (pScreenPriv->hwndScreen)

+    {

+      DestroyWindow (pScreenPriv->hwndScreen);

+      pScreenPriv->hwndScreen = NULL;

+    }

+

+#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)

+  /* Destroy the thread startup mutex */

+  pthread_mutex_destroy (&pScreenPriv->pmServerStarted);

+#endif

+

+  /* Invalidate our screeninfo's pointer to the screen */

+  pScreenInfo->pScreen = NULL;

+

+  /* Invalidate the ScreenInfo's fb pointer */

+  pScreenInfo->pfb = NULL;

+

+  /* Free the screen privates for this screen */

+  free ((pointer) pScreenPriv);

+

+  return fReturn;

+}

+

+

+/*

+ * Tell mi what sort of visuals we need.

+ * 

+ * Generally we only need one visual, as our screen can only

+ * handle one format at a time, I believe.  You may want

+ * to verify that last sentence.

+ */

+

+static Bool

+winInitVisualsShadowGDI (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+

+  /* Display debugging information */

+  winDebug ("winInitVisualsShadowGDI - Masks %08x %08x %08x BPRGB %d d %d "

+	  "bpp %d\n",

+	  (unsigned int) pScreenPriv->dwRedMask,

+	  (unsigned int) pScreenPriv->dwGreenMask,

+	  (unsigned int) pScreenPriv->dwBlueMask,

+	  (int) pScreenPriv->dwBitsPerRGB,

+	  (int) pScreenInfo->dwDepth,

+	  (int) pScreenInfo->dwBPP);

+

+  /* Create a single visual according to the Windows screen depth */

+  switch (pScreenInfo->dwDepth)

+    {

+    case 24:

+    case 16:

+    case 15:

+#if defined(XFree86Server)

+      /* Setup the real visual */

+      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,

+				     TrueColorMask,

+				     pScreenPriv->dwBitsPerRGB,

+				     -1,

+				     pScreenPriv->dwRedMask,

+				     pScreenPriv->dwGreenMask,

+				     pScreenPriv->dwBlueMask))

+	{

+	  ErrorF ("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "

+		  "failed\n");

+	  return FALSE;

+	}

+

+#ifdef XWIN_EMULATEPSEUDO

+      if (!pScreenInfo->fEmulatePseudo)

+	break;

+

+      /* Setup a pseudocolor visual */

+      if (!miSetVisualTypesAndMasks (8,

+				     PseudoColorMask,

+				     8,

+				     -1,

+				     0,

+				     0,

+				     0))

+	{

+	  ErrorF ("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "

+		  "failed for PseudoColor\n");

+	  return FALSE;

+	}

+#endif

+#else /* XFree86Server */

+      /* Setup the real visual */

+      if (!fbSetVisualTypesAndMasks (pScreenInfo->dwDepth,

+				     TrueColorMask,

+				     pScreenPriv->dwBitsPerRGB,

+				     pScreenPriv->dwRedMask,

+				     pScreenPriv->dwGreenMask,

+				     pScreenPriv->dwBlueMask))

+	{

+	  ErrorF ("winInitVisualsShadowGDI - fbSetVisualTypesAndMasks "

+		  "failed for TrueColor\n");

+	  return FALSE;

+	}

+

+#ifdef XWIN_EMULATEPSEUDO

+      if (!pScreenInfo->fEmulatePseudo)

+	break;

+

+      /* Setup a pseudocolor visual */

+      if (!fbSetVisualTypesAndMasks (8,

+				     PseudoColorMask,

+				     8,

+				     0,

+				     0,

+				     0))

+	{

+	  ErrorF ("winInitVisualsShadowGDI - fbSetVisualTypesAndMasks "

+		  "failed for PseudoColor\n");

+	  return FALSE;

+	}

+#endif

+#endif /* XFree86Server */

+      break;

+

+    case 8:

+#if defined(XFree86Server)

+      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,

+				     PseudoColorMask,

+				     pScreenPriv->dwBitsPerRGB,

+				     PseudoColor,

+				     pScreenPriv->dwRedMask,

+				     pScreenPriv->dwGreenMask,

+				     pScreenPriv->dwBlueMask))

+	{

+	  ErrorF ("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "

+		  "failed\n");

+	  return FALSE;

+	}

+#else /* XFree86Server */

+      if (!fbSetVisualTypesAndMasks (pScreenInfo->dwDepth,

+				     PseudoColorMask,

+				     pScreenPriv->dwBitsPerRGB,

+				     pScreenPriv->dwRedMask,

+				     pScreenPriv->dwGreenMask,

+				     pScreenPriv->dwBlueMask))

+	{

+	  ErrorF ("winInitVisualsShadowGDI - fbSetVisualTypesAndMasks "

+		  "failed\n");

+	  return FALSE;

+	}

+#endif

+      break;

+

+    default:

+      ErrorF ("winInitVisualsShadowGDI - Unknown screen depth\n");

+      return FALSE;

+    }

+

+  winDebug ("winInitVisualsShadowGDI - Returning\n");

+

+  return TRUE;

+}

+

+

+/*

+ * Adjust the proposed video mode

+ */

+

+static Bool

+winAdjustVideoModeShadowGDI (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  HDC			hdc;

+  DWORD			dwBPP;

+  

+  hdc = GetDC (NULL);

+

+  /* We're in serious trouble if we can't get a DC */

+  if (hdc == NULL)

+    {

+      ErrorF ("winAdjustVideoModeShadowGDI - GetDC () failed\n");

+      return FALSE;

+    }

+

+  /* Query GDI for current display depth */

+  dwBPP = GetDeviceCaps (hdc, BITSPIXEL);

+

+  /* GDI cannot change the screen depth */

+  if (pScreenInfo->dwBPP == WIN_DEFAULT_BPP)

+    {

+      /* No -depth parameter passed, let the user know the depth being used */

+      winDebug ("winAdjustVideoModeShadowGDI - Using Windows display "

+	      "depth of %d bits per pixel\n", (int) dwBPP);

+

+      /* Use GDI's depth */

+      pScreenInfo->dwBPP = dwBPP;

+    }

+  else if (dwBPP != pScreenInfo->dwBPP)

+    {

+      /* Warn user if GDI depth is different than -depth parameter */

+      winDebug ("winAdjustVideoModeShadowGDI - Command line bpp: %d, "\

+	      "using bpp: %d\n", (int) pScreenInfo->dwBPP, (int) dwBPP);

+

+      /* We'll use GDI's depth */

+      pScreenInfo->dwBPP = dwBPP;

+    }

+  

+  /* Release our DC */

+  ReleaseDC (NULL, hdc);

+  hdc = NULL;

+

+  return TRUE;

+}

+

+

+/*

+ * Blt exposed regions to the screen

+ */

+

+static Bool

+winBltExposedRegionsShadowGDI (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  winPrivCmapPtr	pCmapPriv = NULL;

+  HDC			hdcUpdate;

+  PAINTSTRUCT		ps;

+

+  /* BeginPaint gives us an hdc that clips to the invalidated region */

+  hdcUpdate = BeginPaint (pScreenPriv->hwndScreen, &ps);

+

+  /* Realize the palette, if we have one */

+  if (pScreenPriv->pcmapInstalled != NULL)

+    {

+      pCmapPriv = winGetCmapPriv (pScreenPriv->pcmapInstalled);

+      

+      SelectPalette (hdcUpdate, pCmapPriv->hPalette, FALSE);

+      RealizePalette (hdcUpdate);

+    }

+

+  /* Our BitBlt will be clipped to the invalidated region */

+  BitBlt (hdcUpdate,

+	  0, 0,

+	  pScreenInfo->dwWidth, pScreenInfo->dwHeight,

+	  pScreenPriv->hdcShadow,

+	  0, 0,

+	  SRCCOPY);

+

+  /* EndPaint frees the DC */

+  EndPaint (pScreenPriv->hwndScreen, &ps);

+

+#ifdef XWIN_MULTIWINDOW

+  /* Redraw all windows */

+  if (pScreenInfo->fMultiWindow)

+    EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 

+            (LPARAM)pScreenPriv->hwndScreen);

+#endif

+

+  return TRUE;

+}

+

+

+/*

+ * Do any engine-specific appliation-activation processing

+ */

+

+static Bool

+winActivateAppShadowGDI (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+

+  /*

+   * 2004/04/12 - Harold - We perform the restoring or minimizing

+   * manually for ShadowGDI in fullscreen modes so that this engine

+   * will perform just like ShadowDD and ShadowDDNL in fullscreen mode;

+   * if we do not do this then our fullscreen window will appear in the

+   * z-order when it is deactivated and it can be uncovered by resizing

+   * or minimizing another window that is on top of it, which is not how

+   * the DirectDraw engines work.  Therefore we keep this code here to

+   * make sure that all engines work the same in fullscreen mode.

+   */

+

+  /*

+   * Are we active?

+   * Are we fullscreen?

+   */

+  if (pScreenPriv->fActive

+      && pScreenInfo->fFullScreen)

+    {

+      /*

+       * Activating, attempt to bring our window 

+       * to the top of the display

+       */

+      ShowWindow (pScreenPriv->hwndScreen, SW_RESTORE);

+    }

+  else if (!pScreenPriv->fActive

+	   && pScreenInfo->fFullScreen)

+    {

+      /*

+       * Deactivating, stuff our window onto the

+       * task bar.

+       */

+      ShowWindow (pScreenPriv->hwndScreen, SW_MINIMIZE);

+    }

+

+  return TRUE;

+}

+

+

+/*

+ * Reblit the shadow framebuffer to the screen.

+ */

+

+static Bool

+winRedrawScreenShadowGDI (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+

+  /* Redraw the whole window, to take account for the new colors */

+  BitBlt (pScreenPriv->hdcScreen,

+	  0, 0,

+	  pScreenInfo->dwWidth, pScreenInfo->dwHeight,

+	  pScreenPriv->hdcShadow,

+	  0, 0,

+	  SRCCOPY);

+

+#ifdef XWIN_MULTIWINDOW

+  /* Redraw all windows */

+  if (pScreenInfo->fMultiWindow)

+    EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);

+#endif

+

+  return TRUE;

+}

+

+

+

+/*

+ * Realize the currently installed colormap

+ */

+

+static Bool

+winRealizeInstalledPaletteShadowGDI (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winPrivCmapPtr	pCmapPriv = NULL;

+

+  winDebug ("winRealizeInstalledPaletteShadowGDI\n");

+

+  /* Don't do anything if there is not a colormap */

+  if (pScreenPriv->pcmapInstalled == NULL)

+    {

+      winDebug ("winRealizeInstalledPaletteShadowGDI - No colormap "

+	      "installed\n");

+      return TRUE;

+    }

+

+  pCmapPriv = winGetCmapPriv (pScreenPriv->pcmapInstalled);

+  

+  /* Realize our palette for the screen */

+  if (RealizePalette (pScreenPriv->hdcScreen) == GDI_ERROR)

+    {

+      ErrorF ("winRealizeInstalledPaletteShadowGDI - RealizePalette () "

+	      "failed\n");

+      return FALSE;

+    }

+  

+  /* Set the DIB color table */

+  if (SetDIBColorTable (pScreenPriv->hdcShadow,

+			0,

+			WIN_NUM_PALETTE_ENTRIES,

+			pCmapPriv->rgbColors) == 0)

+    {

+      ErrorF ("winRealizeInstalledPaletteShadowGDI - SetDIBColorTable () "

+	      "failed\n");

+      return FALSE;

+    }

+  

+  return TRUE;

+}

+

+

+/*

+ * Install the specified colormap

+ */

+

+static Bool

+winInstallColormapShadowGDI (ColormapPtr pColormap)

+{

+  ScreenPtr		pScreen = pColormap->pScreen;

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  winCmapPriv(pColormap);

+

+  /*

+   * Tell Windows to install the new colormap

+   */

+  if (SelectPalette (pScreenPriv->hdcScreen,

+		     pCmapPriv->hPalette,

+		     FALSE) == NULL)

+    {

+      ErrorF ("winInstallColormapShadowGDI - SelectPalette () failed\n");

+      return FALSE;

+    }

+      

+  /* Realize the palette */

+  if (GDI_ERROR == RealizePalette (pScreenPriv->hdcScreen))

+    {

+      ErrorF ("winInstallColormapShadowGDI - RealizePalette () failed\n");

+      return FALSE;

+    }

+

+  /* Set the DIB color table */

+  if (SetDIBColorTable (pScreenPriv->hdcShadow,

+			0,

+			WIN_NUM_PALETTE_ENTRIES,

+			pCmapPriv->rgbColors) == 0)

+    {

+      ErrorF ("winInstallColormapShadowGDI - SetDIBColorTable () failed\n");

+      return FALSE;

+    }

+

+  /* Redraw the whole window, to take account for the new colors */

+  BitBlt (pScreenPriv->hdcScreen,

+	  0, 0,

+	  pScreenInfo->dwWidth, pScreenInfo->dwHeight,

+	  pScreenPriv->hdcShadow,

+	  0, 0,

+	  SRCCOPY);

+

+  /* Save a pointer to the newly installed colormap */

+  pScreenPriv->pcmapInstalled = pColormap;

+

+#ifdef XWIN_MULTIWINDOW

+  /* Redraw all windows */

+  if (pScreenInfo->fMultiWindow)

+    EnumThreadWindows (g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);

+#endif

+

+  return TRUE;

+}

+

+

+/*

+ * Store the specified colors in the specified colormap

+ */

+

+static Bool

+winStoreColorsShadowGDI (ColormapPtr pColormap,

+			 int ndef,

+			 xColorItem *pdefs)

+{

+  ScreenPtr		pScreen = pColormap->pScreen;

+  winScreenPriv(pScreen);

+  winCmapPriv(pColormap);

+  ColormapPtr curpmap = pScreenPriv->pcmapInstalled;

+  

+  /* Put the X colormap entries into the Windows logical palette */

+  if (SetPaletteEntries (pCmapPriv->hPalette,

+			 pdefs[0].pixel,

+			 ndef,

+			 pCmapPriv->peColors + pdefs[0].pixel) == 0)

+    {

+      ErrorF ("winStoreColorsShadowGDI - SetPaletteEntries () failed\n");

+      return FALSE;

+    }

+

+  /* Don't install the Windows palette if the colormap is not installed */

+  if (pColormap != curpmap)

+    {

+      return TRUE;

+    }

+

+  /* Try to install the newly modified colormap */

+  if (!winInstallColormapShadowGDI (pColormap))

+    {

+      ErrorF ("winInstallColormapShadowGDI - winInstallColormapShadowGDI "

+	      "failed\n");

+      return FALSE;

+    }

+

+#if 0

+  /* Tell Windows that the palette has changed */

+  RealizePalette (pScreenPriv->hdcScreen);

+  

+  /* Set the DIB color table */

+  if (SetDIBColorTable (pScreenPriv->hdcShadow,

+			pdefs[0].pixel,

+			ndef,

+			pCmapPriv->rgbColors + pdefs[0].pixel) == 0)

+    {

+      ErrorF ("winInstallColormapShadowGDI - SetDIBColorTable () failed\n");

+      return FALSE;

+    }

+

+  /* Save a pointer to the newly installed colormap */

+  pScreenPriv->pcmapInstalled = pColormap;

+#endif

+

+  return TRUE;

+}

+

+

+/*

+ * Colormap initialization procedure

+ */

+

+static Bool

+winCreateColormapShadowGDI (ColormapPtr pColormap)

+{

+  LPLOGPALETTE		lpPaletteNew = NULL;

+  DWORD			dwEntriesMax;

+  VisualPtr		pVisual;

+  HPALETTE		hpalNew = NULL;

+  winCmapPriv(pColormap);

+

+  /* Get a pointer to the visual that the colormap belongs to */

+  pVisual = pColormap->pVisual;

+

+  /* Get the maximum number of palette entries for this visual */

+  dwEntriesMax = pVisual->ColormapEntries;

+

+  /* Allocate a Windows logical color palette with max entries */

+  lpPaletteNew = malloc (sizeof (LOGPALETTE)

+			 + (dwEntriesMax - 1) * sizeof (PALETTEENTRY));

+  if (lpPaletteNew == NULL)

+    {

+      ErrorF ("winCreateColormapShadowGDI - Couldn't allocate palette "

+	      "with %d entries\n",

+	      (int) dwEntriesMax);

+      return FALSE;

+    }

+

+  /* Zero out the colormap */

+  ZeroMemory (lpPaletteNew, sizeof (LOGPALETTE)

+	      + (dwEntriesMax - 1) * sizeof (PALETTEENTRY));

+  

+  /* Set the logical palette structure */

+  lpPaletteNew->palVersion = 0x0300;

+  lpPaletteNew->palNumEntries = dwEntriesMax;

+

+  /* Tell Windows to create the palette */

+  hpalNew = CreatePalette (lpPaletteNew);

+  if (hpalNew == NULL)

+    {

+      ErrorF ("winCreateColormapShadowGDI - CreatePalette () failed\n");

+      free (lpPaletteNew);

+      return FALSE;

+    }

+

+  /* Save the Windows logical palette handle in the X colormaps' privates */

+  pCmapPriv->hPalette = hpalNew;

+

+  /* Free the palette initialization memory */

+  free (lpPaletteNew);

+

+  return TRUE;

+}

+

+

+/*

+ * Colormap destruction procedure

+ */

+

+static Bool

+winDestroyColormapShadowGDI (ColormapPtr pColormap)

+{

+  winScreenPriv(pColormap->pScreen);

+  winCmapPriv(pColormap);

+

+  /*

+   * Is colormap to be destroyed the default?

+   *

+   * Non-default colormaps should have had winUninstallColormap

+   * called on them before we get here.  The default colormap

+   * will not have had winUninstallColormap called on it.  Thus,

+   * we need to handle the default colormap in a special way.

+   */

+  if (pColormap->flags & IsDefault)

+    {

+      winDebug ("winDestroyColormapShadowGDI - Destroying default "

+	      "colormap\n");

+      

+      /*

+       * FIXME: Walk the list of all screens, popping the default

+       * palette out of each screen device context.

+       */

+      

+      /* Pop the palette out of the device context */

+      SelectPalette (pScreenPriv->hdcScreen,

+		     GetStockObject (DEFAULT_PALETTE),

+		     FALSE);

+

+      /* Clear our private installed colormap pointer */

+      pScreenPriv->pcmapInstalled = NULL;

+    }

+  

+  /* Try to delete the logical palette */

+  if (DeleteObject (pCmapPriv->hPalette) == 0)

+    {

+      ErrorF ("winDestroyColormap - DeleteObject () failed\n");

+      return FALSE;

+    }

+  

+  /* Invalidate the colormap privates */

+  pCmapPriv->hPalette = NULL;

+

+  return TRUE;

+}

+

+

+/*

+ * Set engine specific funtions

+ */

+

+Bool

+winSetEngineFunctionsShadowGDI (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;

+  

+  /* Set our pointers */

+  pScreenPriv->pwinAllocateFB = winAllocateFBShadowGDI;

+  pScreenPriv->pwinShadowUpdate = winShadowUpdateGDI;

+  pScreenPriv->pwinCloseScreen = winCloseScreenShadowGDI;

+  pScreenPriv->pwinInitVisuals = winInitVisualsShadowGDI;

+  pScreenPriv->pwinAdjustVideoMode = winAdjustVideoModeShadowGDI;

+  if (pScreenInfo->fFullScreen)

+    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowFullScreen;

+  else

+    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowWindowed;

+  pScreenPriv->pwinFinishScreenInit = winFinishScreenInitFB;

+  pScreenPriv->pwinBltExposedRegions = winBltExposedRegionsShadowGDI;

+  pScreenPriv->pwinActivateApp = winActivateAppShadowGDI;

+  pScreenPriv->pwinRedrawScreen = winRedrawScreenShadowGDI;

+  pScreenPriv->pwinRealizeInstalledPalette = 

+    winRealizeInstalledPaletteShadowGDI;

+  pScreenPriv->pwinInstallColormap = winInstallColormapShadowGDI;

+  pScreenPriv->pwinStoreColors = winStoreColorsShadowGDI;

+  pScreenPriv->pwinCreateColormap = winCreateColormapShadowGDI;

+  pScreenPriv->pwinDestroyColormap = winDestroyColormapShadowGDI;

+  pScreenPriv->pwinHotKeyAltTab = (winHotKeyAltTabProcPtr) (void (*)(void))NoopDDA;

+  pScreenPriv->pwinCreatePrimarySurface

+    = (winCreatePrimarySurfaceProcPtr) (void (*)(void))NoopDDA;

+  pScreenPriv->pwinReleasePrimarySurface

+    = (winReleasePrimarySurfaceProcPtr) (void (*)(void))NoopDDA;

+#ifdef XWIN_MULTIWINDOW

+  pScreenPriv->pwinFinishCreateWindowsWindow =

+    (winFinishCreateWindowsWindowProcPtr) (void (*)(void))NoopDDA;

+#endif

+

+  return TRUE;

+}

diff --git a/xorg-server/hw/xwin/winvideo.c b/xorg-server/hw/xwin/winvideo.c
index 42f46f405..998a3face 100644
--- a/xorg-server/hw/xwin/winvideo.c
+++ b/xorg-server/hw/xwin/winvideo.c
@@ -185,7 +185,7 @@ winSetupImageVideo (ScreenPtr pScreen)
 

 #if 0

     /* gotta uninit this someplace */

-    REGION_NULL(pScreen, &pPriv->clip);

+    RegionNull(&pPriv->clip);

 #endif

 

 #if 0

diff --git a/xorg-server/hw/xwin/winwin32rootless.c b/xorg-server/hw/xwin/winwin32rootless.c
index f76363e43..85a932f75 100644
--- a/xorg-server/hw/xwin/winwin32rootless.c
+++ b/xorg-server/hw/xwin/winwin32rootless.c
@@ -1,982 +1,982 @@
-/*
- *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of the XFree86 Project
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from the XFree86 Project.
- *
- * Authors:	Kensuke Matsuzaki
- *		Earle F. Philhower, III
- *		Harold L Hunt II
- */
-/*
- * Look at hw/darwin/quartz/xpr/xprFrame.c and hw/darwin/quartz/cr/crFrame.c
- */
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-#include <winuser.h>
-#define _WINDOWSWM_SERVER_
-#include <X11/extensions/windowswmstr.h>
-#include "dixevents.h"
-#include "winmultiwindowclass.h"
-#include "winprefs.h"
-#include <X11/Xatom.h>
-
-
-/*
- * Constant defines
- */
-
-#ifndef ULW_COLORKEY
-#define ULW_COLORKEY	0x00000001
-#endif
-#ifndef ULW_ALPHA
-#define ULW_ALPHA	0x00000002
-#endif
-#ifndef ULW_OPAQUE
-#define ULW_OPAQUE	0x00000004
-#endif
-#define AC_SRC_ALPHA	0x01
-
-/*
- * Local function
- */
-
-DEFINE_ATOM_HELPER(AtmWindowsWmNativeHwnd, WINDOWSWM_NATIVE_HWND)
-static void
-winMWExtWMSetNativeProperty (RootlessWindowPtr pFrame);
-
-/*
- * Global variables
- */
-
-Bool			g_fNoConfigureWindow = FALSE;
-
-/*
- * Internal function to get the DIB format that is compatible with the screen
- * Fixme: Share code with winshadgdi.c
- */
-
-static
-Bool
-winMWExtWMQueryDIBFormat (win32RootlessWindowPtr pRLWinPriv, BITMAPINFOHEADER *pbmih)
-{
-  HBITMAP		hbmp;
-#if CYGMULTIWINDOW_DEBUG
-  LPDWORD		pdw = NULL;
-#endif
-  
-  /* Create a memory bitmap compatible with the screen */
-  hbmp = CreateCompatibleBitmap (pRLWinPriv->hdcScreen, 1, 1);
-  if (hbmp == NULL)
-    {
-      ErrorF ("winMWExtWMQueryDIBFormat - CreateCompatibleBitmap failed\n");
-      return FALSE;
-    }
-  
-  /* Initialize our bitmap info header */
-  ZeroMemory (pbmih, sizeof (BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD));
-  pbmih->biSize = sizeof (BITMAPINFOHEADER);
-
-  /* Get the biBitCount */
-  if (!GetDIBits (pRLWinPriv->hdcScreen,
-		  hbmp,
-		  0, 1,
-		  NULL,
-		  (BITMAPINFO*) pbmih,
-		  DIB_RGB_COLORS))
-    {
-      ErrorF ("winMWExtWMQueryDIBFormat - First call to GetDIBits failed\n");
-      DeleteObject (hbmp);
-      return FALSE;
-    }
-
-#if CYGMULTIWINDOW_DEBUG
-  /* Get a pointer to bitfields */
-  pdw = (DWORD*) ((CARD8*)pbmih + sizeof (BITMAPINFOHEADER));
-
-  winDebug ("winMWExtWMQueryDIBFormat - First call masks: %08x %08x %08x\n",
-	  (unsigned int)pdw[0], (unsigned int)pdw[1], (unsigned int)pdw[2]);
-#endif
-
-  /* Get optimal color table, or the optimal bitfields */
-  if (!GetDIBits (pRLWinPriv->hdcScreen,
-		  hbmp,
-		  0, 1,
-		  NULL,
-		  (BITMAPINFO*)pbmih,
-		  DIB_RGB_COLORS))
-    {
-      ErrorF ("winMWExtWMQueryDIBFormat - Second call to GetDIBits "
-	      "failed\n");
-      DeleteObject (hbmp);
-      return FALSE;
-    }
-
-  /* Free memory */
-  DeleteObject (hbmp);
-  
-  return TRUE;
-}
-
-static HRGN
-winMWExtWMCreateRgnFromRegion (RegionPtr pShape)
-{
-  int		nRects;
-  BoxPtr	pRects, pEnd;
-  HRGN		hRgn, hRgnRect;
-
-  if (pShape == NULL) return NULL;
-
-  nRects = REGION_NUM_RECTS(pShape);
-  pRects = REGION_RECTS(pShape);
-  
-  hRgn = CreateRectRgn (0, 0, 0, 0);
-  if (hRgn == NULL)
-    {
-      ErrorF ("winReshape - Initial CreateRectRgn (%d, %d, %d, %d) "
-	      "failed: %d\n",
-	      0, 0, 0, 0, (int) GetLastError ());
-    }
-
-  /* Loop through all rectangles in the X region */
-  for (pEnd = pRects + nRects; pRects < pEnd; pRects++)
-    {
-      /* Create a Windows region for the X rectangle */
-      hRgnRect = CreateRectRgn (pRects->x1,
-				pRects->y1,
-				pRects->x2,
-				pRects->y2);
-      if (hRgnRect == NULL)
-	{
-	  ErrorF ("winReshape - Loop CreateRectRgn (%d, %d, %d, %d) "
-		  "failed: %d\n",
-		  pRects->x1,
-		  pRects->y1,
-		  pRects->x2,
-		  pRects->y2,
-		  (int) GetLastError ());
-	}
-      
-      /* Merge the Windows region with the accumulated region */
-      if (CombineRgn (hRgn, hRgn, hRgnRect, RGN_OR) == ERROR)
-	{
-	  ErrorF ("winReshape - CombineRgn () failed: %d\n",
-		  (int) GetLastError ());
-	}
-      
-      /* Delete the temporary Windows region */
-      DeleteObject (hRgnRect);
-    }
-  
-  return hRgn;
-}
-
-static void
-InitWin32RootlessEngine (win32RootlessWindowPtr pRLWinPriv)
-{
-  pRLWinPriv->hdcScreen = GetDC (pRLWinPriv->hWnd);
-  pRLWinPriv->hdcShadow = CreateCompatibleDC (pRLWinPriv->hdcScreen);
-  pRLWinPriv->hbmpShadow = NULL;
-
-  /* Allocate bitmap info header */
-  pRLWinPriv->pbmihShadow = (BITMAPINFOHEADER*) malloc (sizeof (BITMAPINFOHEADER)
-							+ 256 * sizeof (RGBQUAD));
-  if (pRLWinPriv->pbmihShadow == NULL)
-    {
-      ErrorF ("InitWin32RootlessEngine - malloc () failed\n");
-      return;
-    }
-  
-  /* Query the screen format */
-  winMWExtWMQueryDIBFormat (pRLWinPriv,
-				  pRLWinPriv->pbmihShadow);
-}
-
-Bool
-winMWExtWMCreateFrame (RootlessWindowPtr pFrame, ScreenPtr pScreen,
-			     int newX, int newY, RegionPtr pShape)
-{
-#define CLASS_NAME_LENGTH 512
-  Bool				fResult = TRUE;
-  win32RootlessWindowPtr	pRLWinPriv;
-  WNDCLASSEX			wc;
-  char				pszClass[CLASS_NAME_LENGTH], pszWindowID[12];
-  HICON				hIcon;
-  HICON				hIconSmall;
-  char				*res_name, *res_class, *res_role;
-  static int			s_iWindowID = 0;
- 
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMCreateFrame %d %d - %d %d\n",
-	  newX, newY, pFrame->width, pFrame->height);
-#endif
-
-  pRLWinPriv = (win32RootlessWindowPtr) malloc (sizeof (win32RootlessWindowRec));
-  pRLWinPriv->pFrame = pFrame;
-  pRLWinPriv->pfb = NULL;
-  pRLWinPriv->hbmpShadow = NULL;
-  pRLWinPriv->hdcShadow = NULL;
-  pRLWinPriv->hdcScreen = NULL;
-  pRLWinPriv->pbmihShadow = NULL;
-  pRLWinPriv->fResized = TRUE;
-  pRLWinPriv->fClose = FALSE;
-  pRLWinPriv->fRestackingNow = FALSE;
-  pRLWinPriv->fDestroyed = FALSE;
-  pRLWinPriv->fMovingOrSizing = FALSE;
-  
-  // Store the implementation private frame ID
-  pFrame->wid = (RootlessFrameID) pRLWinPriv;
-
-  winSelectIcons(pFrame->win, &hIcon, &hIconSmall); 
-  
-  /* Set standard class name prefix so we can identify window easily */
-  strncpy (pszClass, WINDOW_CLASS_X, sizeof(pszClass));
-
-  if (winMultiWindowGetClassHint (pFrame->win, &res_name, &res_class))
-    {
-      strncat (pszClass, "-", 1);
-      strncat (pszClass, res_name, CLASS_NAME_LENGTH - strlen (pszClass));
-      strncat (pszClass, "-", 1);
-      strncat (pszClass, res_class, CLASS_NAME_LENGTH - strlen (pszClass));
-      
-      /* Check if a window class is provided by the WM_WINDOW_ROLE property,
-       * if not use the WM_CLASS information.
-       * For further information see:
-       * http://tronche.com/gui/x/icccm/sec-5.html
-       */
-      if (winMultiWindowGetWindowRole (pFrame->win, &res_role) )
-	{
-	  strcat (pszClass, "-");
-	  strcat (pszClass, res_role);
-	  free (res_role);
-	}
-
-      free (res_name);
-      free (res_class);
-    }
-
-  /* Add incrementing window ID to make unique class name */
-  snprintf (pszWindowID, sizeof(pszWindowID), "-%x", s_iWindowID++);
-  pszWindowID[sizeof(pszWindowID)-1] = 0;
-  strcat (pszClass, pszWindowID);
-
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winCreateWindowsWindow - Creating class: %s\n", pszClass);
-#endif
-
-  /* Setup our window class */
-  wc.cbSize = sizeof(wc);
-  wc.style = CS_HREDRAW | CS_VREDRAW;
-  wc.lpfnWndProc = winMWExtWMWindowProc;
-  wc.cbClsExtra = 0;
-  wc.cbWndExtra = 0;
-  wc.hInstance = g_hInstance;
-  wc.hIcon = hIcon;
-  wc.hIconSm = hIconSmall;
-  wc.hCursor = 0;
-  wc.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);
-  wc.lpszMenuName = NULL;
-  wc.lpszClassName = pszClass;
-  RegisterClassEx (&wc);
-
-  /* Create the window */
-  g_fNoConfigureWindow = TRUE;
-  pRLWinPriv->hWnd = CreateWindowExA (WS_EX_TOOLWINDOW,		/* Extended styles */
-				      pszClass,			/* Class name */
-				      WINDOW_TITLE_X,		/* Window name */
-				      WS_POPUP | WS_CLIPCHILDREN,
-				      newX,			/* Horizontal position */
-				      newY,			/* Vertical position */
-				      pFrame->width,		/* Right edge */ 
-				      pFrame->height,		/* Bottom edge */
-				      (HWND) NULL,		/* No parent or owner window */
-				      (HMENU) NULL,		/* No menu */
-				      GetModuleHandle (NULL),	/* Instance handle */
-				      pRLWinPriv);		/* ScreenPrivates */
-  if (pRLWinPriv->hWnd == NULL)
-    {
-      ErrorF ("winMWExtWMCreateFrame - CreateWindowExA () failed: %d\n",
-	      (int) GetLastError ());
-      fResult = FALSE;
-    }
-
-  winDebug ("winMWExtWMCreateFrame - ShowWindow\n");
-
-  //ShowWindow (pRLWinPriv->hWnd, SW_SHOWNOACTIVATE);
-  g_fNoConfigureWindow = FALSE;
-  
-  if (pShape != NULL)
-    {
-      winMWExtWMReshapeFrame (pFrame->wid, pShape);
-    }
-
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMCreateFrame - (%08x) %08x\n",
-	  (int) pFrame->wid, (int) pRLWinPriv->hWnd);
-#if 0
-  {
-   WindowPtr		pWin2 = NULL;
-   win32RootlessWindowPtr pRLWinPriv2 = NULL;
-
-   /* Check if the Windows window property for our X window pointer is valid */
-   if ((pWin2 = (WindowPtr)GetProp (pRLWinPriv->hWnd, WIN_WINDOW_PROP)) != NULL)
-     {
-       pRLWinPriv2 = (win32RootlessWindowPtr) RootlessFrameForWindow (pWin2, FALSE);
-     }
-   winDebug ("winMWExtWMCreateFrame2 (%08x) %08x\n",
-	   pRLWinPriv2, pRLWinPriv2->hWnd);
-   if (pRLWinPriv != pRLWinPriv2 || pRLWinPriv->hWnd != pRLWinPriv2->hWnd)
-     {
-       winDebug ("Error param missmatch\n");
-     }
- }
-#endif
-#endif
-
-  winMWExtWMSetNativeProperty (pFrame);
-
-  return fResult;
-}
-
-void
-winMWExtWMDestroyFrame (RootlessFrameID wid)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-  HICON			hiconClass;
-  HICON			hiconSmClass;
-  HMODULE		hInstance;
-  int			iReturn;
-  char			pszClass[CLASS_NAME_LENGTH];
-
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMDestroyFrame (%08x) %08x\n",
-	  (int) pRLWinPriv, (int) pRLWinPriv->hWnd);
-#if 0
- {
-   WindowPtr		pWin2 = NULL;
-   win32RootlessWindowPtr pRLWinPriv2 = NULL;
-
-   /* Check if the Windows window property for our X window pointer is valid */
-   if ((pWin2 = (WindowPtr)GetProp (pRLWinPriv->hWnd, WIN_WINDOW_PROP)) != NULL)
-     {
-       pRLWinPriv2 = (win32RootlessWindowPtr) RootlessFrameForWindow (pWin2, FALSE);
-     }
-   winDebug ("winMWExtWMDestroyFrame2 (%08x) %08x\n",
-	   pRLWinPriv2, pRLWinPriv2->hWnd);
-   if (pRLWinPriv != pRLWinPriv2 || pRLWinPriv->hWnd != pRLWinPriv2->hWnd)
-     {
-       winDebug ("Error param missmatch\n");
-       *(int*)0 = 1;//raise exseption
-     }
- }
-#endif
-#endif
-
-  /* Store the info we need to destroy after this window is gone */
-  hInstance = (HINSTANCE) GetClassLongPtr (pRLWinPriv->hWnd, GCLP_HMODULE);
-  hiconClass = (HICON) GetClassLongPtr (pRLWinPriv->hWnd, GCLP_HICON);
-  hiconSmClass = (HICON) GetClassLongPtr (pRLWinPriv->hWnd, GCLP_HICONSM);
-  iReturn = GetClassName (pRLWinPriv->hWnd, pszClass, CLASS_NAME_LENGTH);
-
-  pRLWinPriv->fClose = TRUE;
-  pRLWinPriv->fDestroyed = TRUE;
-
-  /* Destroy the Windows window */
-  DestroyWindow (pRLWinPriv->hWnd);
-
-  /* Only if we were able to get the name */
-  if (iReturn)
-    { 
-#if CYGMULTIWINDOW_DEBUG
-      winDebug ("winMWExtWMDestroyFrame - Unregistering %s: ", pszClass);
-#endif
-      iReturn = UnregisterClass (pszClass, hInstance);
-      
-#if CYGMULTIWINDOW_DEBUG
-      winDebug ("winMWExtWMDestroyFramew - %d Deleting Icon: ", iReturn);
-#endif
-      
-      winDestroyIcon(hiconClass);
-      winDestroyIcon(hiconSmClass);
-    }
-
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMDestroyFrame - done\n");
-#endif
-}
-
-void
-winMWExtWMMoveFrame (RootlessFrameID wid, ScreenPtr pScreen, int iNewX, int iNewY)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-  RECT rcNew;
-  DWORD dwExStyle;
-  DWORD dwStyle;
-  int iX, iY, iWidth, iHeight;
-
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMMoveFrame (%08x) (%d %d)\n", (int) pRLWinPriv, iNewX, iNewY);
-#endif
-
-  /* Get the Windows window style and extended style */
-  dwExStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE);
-  dwStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE);
-
-  /* Get the X and Y location of the X window */
-  iX = iNewX + GetSystemMetrics (SM_XVIRTUALSCREEN);
-  iY = iNewY + GetSystemMetrics (SM_YVIRTUALSCREEN);
-
-  /* Get the height and width of the X window */
-  iWidth = pRLWinPriv->pFrame->width;
-  iHeight = pRLWinPriv->pFrame->height;
-
-  /* Store the origin, height, and width in a rectangle structure */
-  SetRect (&rcNew, iX, iY, iX + iWidth, iY + iHeight);
-
-#ifdef CYGMULTIWINDOW_DEBUG
-          winDebug("\tWindow {%d, %d, %d, %d}, {%d, %d}\n", 
-              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,
-              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);
-#endif
-  /*
-   * Calculate the required size of the Windows window rectangle,
-   * given the size of the Windows window client area.
-   */
-  AdjustWindowRectEx (&rcNew, dwStyle, FALSE, dwExStyle);
-
-#ifdef CYGMULTIWINDOW_DEBUG
-          winDebug("\tAdjusted {%d, %d, %d, %d}, {%d, %d}\n", 
-              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,
-              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);
-#endif
-  g_fNoConfigureWindow = TRUE;
-  SetWindowPos (pRLWinPriv->hWnd, NULL, rcNew.left, rcNew.top, 0, 0,
-		SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
-  g_fNoConfigureWindow = FALSE;
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMMoveFrame (%08x) done\n", (int) pRLWinPriv);
-#endif
-}
-
-void
-winMWExtWMResizeFrame (RootlessFrameID wid, ScreenPtr pScreen,
-			     int iNewX, int iNewY,
-			     unsigned int uiNewWidth, unsigned int uiNewHeight,
-			     unsigned int uiGravity)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-  RECT rcNew;
-  RECT rcOld;
-  DWORD dwExStyle;
-  DWORD dwStyle;
-  int iX, iY;
-
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMResizeFrame (%08x) (%d %d)-(%d %d)\n",
-	  (int) pRLWinPriv, iNewX, iNewY, uiNewWidth, uiNewHeight);
-#endif
-
-  pRLWinPriv->fResized = TRUE;
-
-  /* Get the Windows window style and extended style */
-  dwExStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE);
-  dwStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE);
-
-  /* Get the X and Y location of the X window */
-  iX = iNewX + GetSystemMetrics (SM_XVIRTUALSCREEN);
-  iY = iNewY + GetSystemMetrics (SM_YVIRTUALSCREEN);
-
-  /* Store the origin, height, and width in a rectangle structure */
-  SetRect (&rcNew, iX, iY, iX + uiNewWidth, iY + uiNewHeight);
-
-  /*
-   * Calculate the required size of the Windows window rectangle,
-   * given the size of the Windows window client area.
-   */
-  AdjustWindowRectEx (&rcNew, dwStyle, FALSE, dwExStyle);
-
-  /* Get a rectangle describing the old Windows window */
-  GetWindowRect (pRLWinPriv->hWnd, &rcOld);
-
-  /* Check if the old rectangle and new rectangle are the same */
-  if (!EqualRect (&rcNew, &rcOld))
-    {
-
-      g_fNoConfigureWindow = TRUE;
-      MoveWindow (pRLWinPriv->hWnd,
-		  rcNew.left, rcNew.top,
-		  rcNew.right - rcNew.left, rcNew.bottom - rcNew.top,
-		  TRUE);
-      g_fNoConfigureWindow = FALSE;
-    }
-}
-
-void
-winMWExtWMRestackFrame (RootlessFrameID wid, RootlessFrameID nextWid)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-  win32RootlessWindowPtr pRLNextWinPriv = (win32RootlessWindowPtr) nextWid;
-  winScreenPriv(pRLWinPriv->pFrame->win->drawable.pScreen);
-  winScreenInfo *pScreenInfo = NULL;
-  DWORD dwCurrentProcessID = GetCurrentProcessId ();
-  DWORD dwWindowProcessID = 0;
-  HWND hWnd;
-  Bool fFirst = TRUE;
-  Bool fNeedRestack = TRUE;
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMRestackFrame (%08x)\n", (int) pRLWinPriv);
-#endif
-
-  if (pScreenPriv->fRestacking) return;
-
-  if (pScreenPriv) pScreenInfo = pScreenPriv->pScreenInfo;
-
-  pRLWinPriv->fRestackingNow = TRUE;
-
-  /* Show window */
-  if(!IsWindowVisible (pRLWinPriv->hWnd))
-    ShowWindow (pRLWinPriv->hWnd, SW_SHOWNOACTIVATE);
-
-  if (pRLNextWinPriv == NULL)
-    {
-#if CYGMULTIWINDOW_DEBUG
-      winDebug ("Win %08x is top\n", pRLWinPriv);
-#endif
-      pScreenPriv->widTop = wid;
-      SetWindowPos (pRLWinPriv->hWnd, HWND_TOP,
-		    0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
-    }
-  else if (winIsInternalWMRunning(pScreenInfo))
-    {
-      /* using mulwinidow wm */
-#if CYGMULTIWINDOW_DEBUG
-      winDebug ("Win %08x is not top\n", pRLWinPriv);
-#endif
-      for (hWnd = GetNextWindow (pRLWinPriv->hWnd, GW_HWNDPREV);
-	   fNeedRestack && hWnd != NULL;
-	   hWnd = GetNextWindow (hWnd, GW_HWNDPREV))
-	{
-	  GetWindowThreadProcessId (hWnd, &dwWindowProcessID);
-
-	  if ((dwWindowProcessID == dwCurrentProcessID)
-	      && GetProp (hWnd, WIN_WINDOW_PROP))
-	    {
-	      if (hWnd == pRLNextWinPriv->hWnd)
-		{
-		  /* Enable interleave X window and Windows window */
-		  if (!fFirst)
-		    {
-#if CYGMULTIWINDOW_DEBUG
-		      winDebug ("raise: Insert after Win %08x\n", pRLNextWinPriv);
-#endif
-		      SetWindowPos (pRLWinPriv->hWnd, pRLNextWinPriv->hWnd,
-				    0, 0, 0, 0,
-				    SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
-		    }
-		  else
-		    {
-#if CYGMULTIWINDOW_DEBUG
-		      winDebug ("No change\n");
-#endif
-		    }
-		  fNeedRestack = FALSE;
-		  break;
-		}
-	      if (fFirst) fFirst = FALSE;
-	    }
-	}
-
-      for (hWnd = GetNextWindow (pRLWinPriv->hWnd, GW_HWNDNEXT);
-	   fNeedRestack && hWnd != NULL;
-	   hWnd = GetNextWindow (hWnd, GW_HWNDNEXT))
-	{
-	  GetWindowThreadProcessId (hWnd, &dwWindowProcessID);
-
-	  if ((dwWindowProcessID == dwCurrentProcessID)
-	      && GetProp (hWnd, WIN_WINDOW_PROP))
-	    {
-	      if (hWnd == pRLNextWinPriv->hWnd)
-		{
-#if CYGMULTIWINDOW_DEBUG
-		  winDebug ("lower: Insert after Win %08x\n", pRLNextWinPriv);
-#endif
-		  SetWindowPos (pRLWinPriv->hWnd, pRLNextWinPriv->hWnd,
-				0, 0, 0, 0,
-				SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
-		  fNeedRestack = FALSE;
-		  break;
-		}
-	    }
-	}
-    }
-  else
-    {
-      /* using general wm like twm, wmaker etc.
-	 Interleave X window and Windows window will cause problem. */
-      SetWindowPos (pRLWinPriv->hWnd, pRLNextWinPriv->hWnd,
-		    0, 0, 0, 0,
-		    SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
-#if 0
-#endif
-    }
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMRestackFrame - done (%08x)\n", (int) pRLWinPriv);
-#endif
-
-  pRLWinPriv->fRestackingNow = FALSE;
-}
-
-void
-winMWExtWMReshapeFrame (RootlessFrameID wid, RegionPtr pShape)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-  HRGN hRgn, hRgnWindow, hRgnClient;
-  RECT rcWindow, rcClient;
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMReshapeFrame (%08x)\n", (int) pRLWinPriv);
-#endif
-
-  hRgn = winMWExtWMCreateRgnFromRegion (pShape);
-  
-  /* Create region for non-client area */
-  GetWindowRect (pRLWinPriv->hWnd, &rcWindow);
-  GetClientRect (pRLWinPriv->hWnd, &rcClient);
-  MapWindowPoints (pRLWinPriv->hWnd, HWND_DESKTOP, (LPPOINT)&rcClient, 2);
-  OffsetRgn (hRgn, rcClient.left - rcWindow.left, rcClient.top - rcWindow.top);
-  OffsetRect (&rcClient, -rcWindow.left, -rcWindow.top);
-  OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
-  hRgnWindow = CreateRectRgnIndirect (&rcWindow);
-  hRgnClient = CreateRectRgnIndirect (&rcClient);
-  CombineRgn (hRgnWindow, hRgnWindow, hRgnClient, RGN_DIFF);
-  CombineRgn (hRgn, hRgnWindow, hRgn, RGN_OR);
-
-
-  SetWindowRgn (pRLWinPriv->hWnd, hRgn, TRUE);
-
-  DeleteObject (hRgnWindow);
-  DeleteObject (hRgnClient);
-}
-
-void
-winMWExtWMUnmapFrame (RootlessFrameID wid)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMUnmapFrame (%08x)\n", (int) pRLWinPriv);
-#endif
-
-  g_fNoConfigureWindow = TRUE;
-  //ShowWindow (pRLWinPriv->hWnd, SW_MINIMIZE);
-  ShowWindow (pRLWinPriv->hWnd, SW_HIDE);
-  g_fNoConfigureWindow = FALSE;
-}
-
-/*
- * Fixme: Code sharing with winshadgdi.c and other engine support
- */
-void
-winMWExtWMStartDrawing (RootlessFrameID wid, char **pixelData, int *bytesPerRow)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-  winPrivScreenPtr	pScreenPriv = NULL;
-  winScreenInfo		*pScreenInfo = NULL;
-  ScreenPtr		pScreen = NULL;
-  DIBSECTION		dibsection;
-  Bool			fReturn = TRUE;
-  HDC			hdcNew;
-  HBITMAP		hbmpNew;
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMStartDrawing (%08x) %08x\n", (int) pRLWinPriv, pRLWinPriv->fDestroyed);
-#endif
-
-  if (!pRLWinPriv->fDestroyed)
-    {
-      pScreen = pRLWinPriv->pFrame->win->drawable.pScreen;
-      if (pScreen) pScreenPriv = winGetScreenPriv(pScreen);
-      if (pScreenPriv) pScreenInfo = pScreenPriv->pScreenInfo;
-      
-#if CYGMULTIWINDOW_DEBUG
-      winDebug ("\tpScreenPriv %08X\n", (int) pScreenPriv);
-      winDebug ("\tpScreenInfo %08X\n", (int) pScreenInfo);
-      winDebug ("\t(%d, %d)\n", (int)pRLWinPriv->pFrame->width,
-		(int) pRLWinPriv->pFrame->height);
-#endif
-      if (pRLWinPriv->hdcScreen == NULL)
-	{
-	  InitWin32RootlessEngine (pRLWinPriv);
-	}
-      
-      if (pRLWinPriv->fResized)
-	{
-          /* width * bpp must be multiple of 4 to match 32bit alignment */
-	  int stridesize;
-	  int misalignment;
-         
-	  pRLWinPriv->pbmihShadow->biWidth = pRLWinPriv->pFrame->width;
-	  pRLWinPriv->pbmihShadow->biHeight = -pRLWinPriv->pFrame->height;
- 
-	  stridesize = pRLWinPriv->pFrame->width * (pScreenInfo->dwBPP >> 3);
-	  misalignment = stridesize & 3; 
-	  if (misalignment != 0)
-	  {
-	    stridesize += 4 - misalignment;
-	    pRLWinPriv->pbmihShadow->biWidth = stridesize / (pScreenInfo->dwBPP >> 3);
-	    winDebug("\tresizing to %d (was %d)\n", 
-		    pRLWinPriv->pbmihShadow->biWidth, pRLWinPriv->pFrame->width);
-	  }
-	  
-	  hdcNew = CreateCompatibleDC (pRLWinPriv->hdcScreen);
-	  /* Create a DI shadow bitmap with a bit pointer */
-	  hbmpNew = CreateDIBSection (pRLWinPriv->hdcScreen,
-				      (BITMAPINFO *) pRLWinPriv->pbmihShadow,
-				      DIB_RGB_COLORS,
-				      (VOID**) &pRLWinPriv->pfb,
-				      NULL,
-				      0);
-	  if (hbmpNew == NULL || pRLWinPriv->pfb == NULL)
-	    {
-	      ErrorF ("winMWExtWMStartDrawing - CreateDIBSection failed\n");
-	      //return FALSE;
-	    }
-	  else
-	    {
-#if CYGMULTIWINDOW_DEBUG
-	      winDebug ("winMWExtWMStartDrawing - Shadow buffer allocated\n");
-#endif
-	    }
-	  
-	  /* Get information about the bitmap that was allocated */
-	  GetObject (hbmpNew, sizeof (dibsection), &dibsection);
-	  
-#if CYGMULTIWINDOW_DEBUG
-	  /* Print information about bitmap allocated */
-	  winDebug ("winMWExtWMStartDrawing - Dibsection width: %d height: %d "
-		    "depth: %d size image: %d\n",
-		    (unsigned int)dibsection.dsBmih.biWidth,
-		    (unsigned int)dibsection.dsBmih.biHeight,
-		    (unsigned int)dibsection.dsBmih.biBitCount,
-		    (unsigned int)dibsection.dsBmih.biSizeImage);
-#endif
-	  
-	  /* Select the shadow bitmap into the shadow DC */
-	  SelectObject (hdcNew, hbmpNew);
-	  
-#if CYGMULTIWINDOW_DEBUG
-	  winDebug ("winMWExtWMStartDrawing - Attempting a shadow blit\n");
-#endif
-	  
-	  /* Blit from the old shadow to the new shadow */
-	  fReturn = BitBlt (hdcNew,
-			    0, 0,
-			    pRLWinPriv->pFrame->width, pRLWinPriv->pFrame->height,
-			    pRLWinPriv->hdcShadow,
-			    0, 0,
-			    SRCCOPY);
-	  if (fReturn)
-	    {
-	      winDebug ("winMWExtWMStartDrawing - Shadow blit success\n");
-	    }
-	  else
-	    {
-	      ErrorF ("winMWExtWMStartDrawing - Shadow blit failure\n");
-	    }
-	  
-	  /* Look for height weirdness */
-	  if (dibsection.dsBmih.biHeight < 0)
-	    {
-	      /* FIXME: Figure out why biHeight is sometimes negative */
-	      ErrorF ("winMWExtWMStartDrawing - WEIRDNESS - "
-                  "biHeight still negative: %d\n", 
-                  (int) dibsection.dsBmih.biHeight);
-	      ErrorF ("winMWExtWMStartDrawing - WEIRDNESS - "
-                  "Flipping biHeight sign\n");
-	      dibsection.dsBmih.biHeight = -dibsection.dsBmih.biHeight;
-	    }
-	  
-	  pRLWinPriv->dwWidthBytes = dibsection.dsBm.bmWidthBytes;
-	  
-	  winDebug ("winMWExtWMStartDrawing - bytesPerRow: %d\n",
-		    (unsigned int)dibsection.dsBm.bmWidthBytes);
-	  
-	  /* Free the old shadow bitmap */
-	  DeleteObject (pRLWinPriv->hdcShadow);
-	  DeleteObject (pRLWinPriv->hbmpShadow);
-	  
-	  pRLWinPriv->hdcShadow = hdcNew;
-	  pRLWinPriv->hbmpShadow = hbmpNew;
-	  
-	  pRLWinPriv->fResized = FALSE;
-	  winDebug ("winMWExtWMStartDrawing - 0x%08x %d\n",
-		(unsigned int)pRLWinPriv->pfb, 
-		(unsigned int)dibsection.dsBm.bmWidthBytes);
-	}
-    }
-  else
-    {
-      ErrorF ("winMWExtWMStartDrawing - Already window was destroyed \n"); 
-    }
-  winDebug ("winMWExtWMStartDrawing - done (0x%08x) 0x%08x %d\n",
-	    (int) pRLWinPriv,
-	    (unsigned int)pRLWinPriv->pfb, (unsigned int)pRLWinPriv->dwWidthBytes);
-  *pixelData = pRLWinPriv->pfb;
-  *bytesPerRow = pRLWinPriv->dwWidthBytes;
-}
-
-void
-winMWExtWMStopDrawing (RootlessFrameID wid, Bool fFlush)
-{
-}
-
-void
-winMWExtWMUpdateRegion (RootlessFrameID wid, RegionPtr pDamage)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-  if (!g_fNoConfigureWindow) UpdateWindow (pRLWinPriv->hWnd);
-}
-
-void
-winMWExtWMDamageRects (RootlessFrameID wid, int nCount, const BoxRec *pRects,
-			     int shift_x, int shift_y)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-  const BoxRec *pEnd;
-  winDebug ("winMWExtWMDamageRects (%08x, %d, %08x, %d, %d)\n",
-	    pRLWinPriv, nCount, pRects, shift_x, shift_y);
-
-  for (pEnd = pRects + nCount; pRects < pEnd; pRects++) {
-        RECT rcDmg;
-        rcDmg.left = pRects->x1 + shift_x;
-        rcDmg.top = pRects->y1 + shift_y;
-        rcDmg.right = pRects->x2 + shift_x;
-        rcDmg.bottom = pRects->y2 + shift_y;
-
-	InvalidateRect (pRLWinPriv->hWnd, &rcDmg, FALSE);
-    }
-}
-
-void
-winMWExtWMRootlessSwitchWindow (RootlessWindowPtr pFrame, WindowPtr oldWin)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) pFrame->wid;
-  winDebug ("winMWExtWMRootlessSwitchWindow (%08x) %08x\n",
-	    (int) pRLWinPriv, (int) pRLWinPriv->hWnd);
-  pRLWinPriv->pFrame = pFrame;
-  pRLWinPriv->fResized = TRUE;
-
-  /* Set the window extended style flags */
-  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE, WS_EX_TOOLWINDOW);
-
-  /* Set the window standard style flags */
-  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE,
-		    WS_POPUP | WS_CLIPCHILDREN);
-
-  DeleteProperty (serverClient, oldWin, AtmWindowsWmNativeHwnd ());
-  winMWExtWMSetNativeProperty (pFrame);
-}
-
-void
-winMWExtWMCopyBytes (unsigned int width, unsigned int height,
-			   const void *src, unsigned int srcRowBytes,
-			   void *dst, unsigned int dstRowBytes)
-{
-  winDebug ("winMWExtWMCopyBytes - Not implemented\n");
-}
-
-void
-winMWExtWMFillBytes (unsigned int width, unsigned int height, unsigned int value,
-			   void *dst, unsigned int dstRowBytes)
-{
-  winDebug ("winMWExtWMFillBytes - Not implemented\n");
-}
-
-int
-winMWExtWMCompositePixels (unsigned int width, unsigned int height, unsigned int function,
-				 void *src[2], unsigned int srcRowBytes[2],
-				 void *mask, unsigned int maskRowBytes,
-				 void *dst[2], unsigned int dstRowBytes[2])
-{
-  winDebug ("winMWExtWMCompositePixels - Not implemented\n");
-  return 0;
-}
-
-
-void
-winMWExtWMCopyWindow (RootlessFrameID wid, int nDstRects, const BoxRec *pDstRects,
-			    int nDx, int nDy)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;
-  const BoxRec *pEnd;
-  RECT rcDmg;
-  winDebug ("winMWExtWMCopyWindow (%08x, %d, %08x, %d, %d)\n",
-	  (int) pRLWinPriv, nDstRects, (int) pDstRects, nDx, nDy);
-
-  for (pEnd = pDstRects + nDstRects; pDstRects < pEnd; pDstRects++)
-    {
-      winDebug ("BitBlt (%d, %d, %d, %d) (%d, %d)\n",
-	      pDstRects->x1, pDstRects->y1,
-	      pDstRects->x2 - pDstRects->x1,
-	      pDstRects->y2 - pDstRects->y1,
-	      pDstRects->x1 + nDx,
-	      pDstRects->y1 + nDy);
-
-      if (!BitBlt (pRLWinPriv->hdcShadow,
-		   pDstRects->x1, pDstRects->y1,
-		   pDstRects->x2 - pDstRects->x1,
-		   pDstRects->y2 - pDstRects->y1,
-		   pRLWinPriv->hdcShadow,
-		   pDstRects->x1 + nDx,  pDstRects->y1 + nDy,
-		   SRCCOPY))
-	{
-	  ErrorF ("winMWExtWMCopyWindow - BitBlt failed.\n");
-	}
-      
-      rcDmg.left = pDstRects->x1;
-      rcDmg.top = pDstRects->y1;
-      rcDmg.right = pDstRects->x2;
-      rcDmg.bottom = pDstRects->y2;
-      
-      InvalidateRect (pRLWinPriv->hWnd, &rcDmg, FALSE);
-    }
-  winDebug ("winMWExtWMCopyWindow - done\n");
-}
-
-
-/*
- * winMWExtWMSetNativeProperty
- */
-
-static void
-winMWExtWMSetNativeProperty (RootlessWindowPtr pFrame)
-{
-  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) pFrame->wid;
-  long lData;
-
-  /* FIXME: move this to WindowsWM extension */
-
-  lData = (long) pRLWinPriv->hWnd;
-  dixChangeWindowProperty(serverClient, pFrame->win, AtmWindowsWmNativeHwnd(),
-			  XA_INTEGER, 32, PropModeReplace, 1, &lData, TRUE);
-}
+/*

+ *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of the XFree86 Project

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from the XFree86 Project.

+ *

+ * Authors:	Kensuke Matsuzaki

+ *		Earle F. Philhower, III

+ *		Harold L Hunt II

+ */

+/*

+ * Look at hw/darwin/quartz/xpr/xprFrame.c and hw/darwin/quartz/cr/crFrame.c

+ */

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+#include <winuser.h>

+#define _WINDOWSWM_SERVER_

+#include <X11/extensions/windowswmstr.h>

+#include "dixevents.h"

+#include "winmultiwindowclass.h"

+#include "winprefs.h"

+#include <X11/Xatom.h>

+

+

+/*

+ * Constant defines

+ */

+

+#ifndef ULW_COLORKEY

+#define ULW_COLORKEY	0x00000001

+#endif

+#ifndef ULW_ALPHA

+#define ULW_ALPHA	0x00000002

+#endif

+#ifndef ULW_OPAQUE

+#define ULW_OPAQUE	0x00000004

+#endif

+#define AC_SRC_ALPHA	0x01

+

+/*

+ * Local function

+ */

+

+DEFINE_ATOM_HELPER(AtmWindowsWmNativeHwnd, WINDOWSWM_NATIVE_HWND)

+static void

+winMWExtWMSetNativeProperty (RootlessWindowPtr pFrame);

+

+/*

+ * Global variables

+ */

+

+Bool			g_fNoConfigureWindow = FALSE;

+

+/*

+ * Internal function to get the DIB format that is compatible with the screen

+ * Fixme: Share code with winshadgdi.c

+ */

+

+static

+Bool

+winMWExtWMQueryDIBFormat (win32RootlessWindowPtr pRLWinPriv, BITMAPINFOHEADER *pbmih)

+{

+  HBITMAP		hbmp;

+#if CYGMULTIWINDOW_DEBUG

+  LPDWORD		pdw = NULL;

+#endif

+  

+  /* Create a memory bitmap compatible with the screen */

+  hbmp = CreateCompatibleBitmap (pRLWinPriv->hdcScreen, 1, 1);

+  if (hbmp == NULL)

+    {

+      ErrorF ("winMWExtWMQueryDIBFormat - CreateCompatibleBitmap failed\n");

+      return FALSE;

+    }

+  

+  /* Initialize our bitmap info header */

+  ZeroMemory (pbmih, sizeof (BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD));

+  pbmih->biSize = sizeof (BITMAPINFOHEADER);

+

+  /* Get the biBitCount */

+  if (!GetDIBits (pRLWinPriv->hdcScreen,

+		  hbmp,

+		  0, 1,

+		  NULL,

+		  (BITMAPINFO*) pbmih,

+		  DIB_RGB_COLORS))

+    {

+      ErrorF ("winMWExtWMQueryDIBFormat - First call to GetDIBits failed\n");

+      DeleteObject (hbmp);

+      return FALSE;

+    }

+

+#if CYGMULTIWINDOW_DEBUG

+  /* Get a pointer to bitfields */

+  pdw = (DWORD*) ((CARD8*)pbmih + sizeof (BITMAPINFOHEADER));

+

+  winDebug ("winMWExtWMQueryDIBFormat - First call masks: %08x %08x %08x\n",

+	  (unsigned int)pdw[0], (unsigned int)pdw[1], (unsigned int)pdw[2]);

+#endif

+

+  /* Get optimal color table, or the optimal bitfields */

+  if (!GetDIBits (pRLWinPriv->hdcScreen,

+		  hbmp,

+		  0, 1,

+		  NULL,

+		  (BITMAPINFO*)pbmih,

+		  DIB_RGB_COLORS))

+    {

+      ErrorF ("winMWExtWMQueryDIBFormat - Second call to GetDIBits "

+	      "failed\n");

+      DeleteObject (hbmp);

+      return FALSE;

+    }

+

+  /* Free memory */

+  DeleteObject (hbmp);

+  

+  return TRUE;

+}

+

+static HRGN

+winMWExtWMCreateRgnFromRegion (RegionPtr pShape)

+{

+  int		nRects;

+  BoxPtr	pRects, pEnd;

+  HRGN		hRgn, hRgnRect;

+

+  if (pShape == NULL) return NULL;

+

+  nRects = RegionNumRects(pShape);

+  pRects = RegionRects(pShape);

+  

+  hRgn = CreateRectRgn (0, 0, 0, 0);

+  if (hRgn == NULL)

+    {

+      ErrorF ("winReshape - Initial CreateRectRgn (%d, %d, %d, %d) "

+	      "failed: %d\n",

+	      0, 0, 0, 0, (int) GetLastError ());

+    }

+

+  /* Loop through all rectangles in the X region */

+  for (pEnd = pRects + nRects; pRects < pEnd; pRects++)

+    {

+      /* Create a Windows region for the X rectangle */

+      hRgnRect = CreateRectRgn (pRects->x1,

+				pRects->y1,

+				pRects->x2,

+				pRects->y2);

+      if (hRgnRect == NULL)

+	{

+	  ErrorF ("winReshape - Loop CreateRectRgn (%d, %d, %d, %d) "

+		  "failed: %d\n",

+		  pRects->x1,

+		  pRects->y1,

+		  pRects->x2,

+		  pRects->y2,

+		  (int) GetLastError ());

+	}

+      

+      /* Merge the Windows region with the accumulated region */

+      if (CombineRgn (hRgn, hRgn, hRgnRect, RGN_OR) == ERROR)

+	{

+	  ErrorF ("winReshape - CombineRgn () failed: %d\n",

+		  (int) GetLastError ());

+	}

+      

+      /* Delete the temporary Windows region */

+      DeleteObject (hRgnRect);

+    }

+  

+  return hRgn;

+}

+

+static void

+InitWin32RootlessEngine (win32RootlessWindowPtr pRLWinPriv)

+{

+  pRLWinPriv->hdcScreen = GetDC (pRLWinPriv->hWnd);

+  pRLWinPriv->hdcShadow = CreateCompatibleDC (pRLWinPriv->hdcScreen);

+  pRLWinPriv->hbmpShadow = NULL;

+

+  /* Allocate bitmap info header */

+  pRLWinPriv->pbmihShadow = (BITMAPINFOHEADER*) malloc (sizeof (BITMAPINFOHEADER)

+							+ 256 * sizeof (RGBQUAD));

+  if (pRLWinPriv->pbmihShadow == NULL)

+    {

+      ErrorF ("InitWin32RootlessEngine - malloc () failed\n");

+      return;

+    }

+  

+  /* Query the screen format */

+  winMWExtWMQueryDIBFormat (pRLWinPriv,

+				  pRLWinPriv->pbmihShadow);

+}

+

+Bool

+winMWExtWMCreateFrame (RootlessWindowPtr pFrame, ScreenPtr pScreen,

+			     int newX, int newY, RegionPtr pShape)

+{

+#define CLASS_NAME_LENGTH 512

+  Bool				fResult = TRUE;

+  win32RootlessWindowPtr	pRLWinPriv;

+  WNDCLASSEX			wc;

+  char				pszClass[CLASS_NAME_LENGTH], pszWindowID[12];

+  HICON				hIcon;

+  HICON				hIconSmall;

+  char				*res_name, *res_class, *res_role;

+  static int			s_iWindowID = 0;

+ 

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMCreateFrame %d %d - %d %d\n",

+	  newX, newY, pFrame->width, pFrame->height);

+#endif

+

+  pRLWinPriv = (win32RootlessWindowPtr) malloc (sizeof (win32RootlessWindowRec));

+  pRLWinPriv->pFrame = pFrame;

+  pRLWinPriv->pfb = NULL;

+  pRLWinPriv->hbmpShadow = NULL;

+  pRLWinPriv->hdcShadow = NULL;

+  pRLWinPriv->hdcScreen = NULL;

+  pRLWinPriv->pbmihShadow = NULL;

+  pRLWinPriv->fResized = TRUE;

+  pRLWinPriv->fClose = FALSE;

+  pRLWinPriv->fRestackingNow = FALSE;

+  pRLWinPriv->fDestroyed = FALSE;

+  pRLWinPriv->fMovingOrSizing = FALSE;

+  

+  // Store the implementation private frame ID

+  pFrame->wid = (RootlessFrameID) pRLWinPriv;

+

+  winSelectIcons(pFrame->win, &hIcon, &hIconSmall); 

+  

+  /* Set standard class name prefix so we can identify window easily */

+  strncpy (pszClass, WINDOW_CLASS_X, sizeof(pszClass));

+

+  if (winMultiWindowGetClassHint (pFrame->win, &res_name, &res_class))

+    {

+      strncat (pszClass, "-", 1);

+      strncat (pszClass, res_name, CLASS_NAME_LENGTH - strlen (pszClass));

+      strncat (pszClass, "-", 1);

+      strncat (pszClass, res_class, CLASS_NAME_LENGTH - strlen (pszClass));

+      

+      /* Check if a window class is provided by the WM_WINDOW_ROLE property,

+       * if not use the WM_CLASS information.

+       * For further information see:

+       * http://tronche.com/gui/x/icccm/sec-5.html

+       */

+      if (winMultiWindowGetWindowRole (pFrame->win, &res_role) )

+	{

+	  strcat (pszClass, "-");

+	  strcat (pszClass, res_role);

+	  free (res_role);

+	}

+

+      free (res_name);

+      free (res_class);

+    }

+

+  /* Add incrementing window ID to make unique class name */

+  snprintf (pszWindowID, sizeof(pszWindowID), "-%x", s_iWindowID++);

+  pszWindowID[sizeof(pszWindowID)-1] = 0;

+  strcat (pszClass, pszWindowID);

+

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winCreateWindowsWindow - Creating class: %s\n", pszClass);

+#endif

+

+  /* Setup our window class */

+  wc.cbSize = sizeof(wc);

+  wc.style = CS_HREDRAW | CS_VREDRAW;

+  wc.lpfnWndProc = winMWExtWMWindowProc;

+  wc.cbClsExtra = 0;

+  wc.cbWndExtra = 0;

+  wc.hInstance = g_hInstance;

+  wc.hIcon = hIcon;

+  wc.hIconSm = hIconSmall;

+  wc.hCursor = 0;

+  wc.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);

+  wc.lpszMenuName = NULL;

+  wc.lpszClassName = pszClass;

+  RegisterClassEx (&wc);

+

+  /* Create the window */

+  g_fNoConfigureWindow = TRUE;

+  pRLWinPriv->hWnd = CreateWindowExA (WS_EX_TOOLWINDOW,		/* Extended styles */

+				      pszClass,			/* Class name */

+				      WINDOW_TITLE_X,		/* Window name */

+				      WS_POPUP | WS_CLIPCHILDREN,

+				      newX,			/* Horizontal position */

+				      newY,			/* Vertical position */

+				      pFrame->width,		/* Right edge */ 

+				      pFrame->height,		/* Bottom edge */

+				      (HWND) NULL,		/* No parent or owner window */

+				      (HMENU) NULL,		/* No menu */

+				      GetModuleHandle (NULL),	/* Instance handle */

+				      pRLWinPriv);		/* ScreenPrivates */

+  if (pRLWinPriv->hWnd == NULL)

+    {

+      ErrorF ("winMWExtWMCreateFrame - CreateWindowExA () failed: %d\n",

+	      (int) GetLastError ());

+      fResult = FALSE;

+    }

+

+  winDebug ("winMWExtWMCreateFrame - ShowWindow\n");

+

+  //ShowWindow (pRLWinPriv->hWnd, SW_SHOWNOACTIVATE);

+  g_fNoConfigureWindow = FALSE;

+  

+  if (pShape != NULL)

+    {

+      winMWExtWMReshapeFrame (pFrame->wid, pShape);

+    }

+

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMCreateFrame - (%08x) %08x\n",

+	  (int) pFrame->wid, (int) pRLWinPriv->hWnd);

+#if 0

+  {

+   WindowPtr		pWin2 = NULL;

+   win32RootlessWindowPtr pRLWinPriv2 = NULL;

+

+   /* Check if the Windows window property for our X window pointer is valid */

+   if ((pWin2 = (WindowPtr)GetProp (pRLWinPriv->hWnd, WIN_WINDOW_PROP)) != NULL)

+     {

+       pRLWinPriv2 = (win32RootlessWindowPtr) RootlessFrameForWindow (pWin2, FALSE);

+     }

+   winDebug ("winMWExtWMCreateFrame2 (%08x) %08x\n",

+	   pRLWinPriv2, pRLWinPriv2->hWnd);

+   if (pRLWinPriv != pRLWinPriv2 || pRLWinPriv->hWnd != pRLWinPriv2->hWnd)

+     {

+       winDebug ("Error param missmatch\n");

+     }

+ }

+#endif

+#endif

+

+  winMWExtWMSetNativeProperty (pFrame);

+

+  return fResult;

+}

+

+void

+winMWExtWMDestroyFrame (RootlessFrameID wid)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+  HICON			hiconClass;

+  HICON			hiconSmClass;

+  HMODULE		hInstance;

+  int			iReturn;

+  char			pszClass[CLASS_NAME_LENGTH];

+

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMDestroyFrame (%08x) %08x\n",

+	  (int) pRLWinPriv, (int) pRLWinPriv->hWnd);

+#if 0

+ {

+   WindowPtr		pWin2 = NULL;

+   win32RootlessWindowPtr pRLWinPriv2 = NULL;

+

+   /* Check if the Windows window property for our X window pointer is valid */

+   if ((pWin2 = (WindowPtr)GetProp (pRLWinPriv->hWnd, WIN_WINDOW_PROP)) != NULL)

+     {

+       pRLWinPriv2 = (win32RootlessWindowPtr) RootlessFrameForWindow (pWin2, FALSE);

+     }

+   winDebug ("winMWExtWMDestroyFrame2 (%08x) %08x\n",

+	   pRLWinPriv2, pRLWinPriv2->hWnd);

+   if (pRLWinPriv != pRLWinPriv2 || pRLWinPriv->hWnd != pRLWinPriv2->hWnd)

+     {

+       winDebug ("Error param missmatch\n");

+       *(int*)0 = 1;//raise exseption

+     }

+ }

+#endif

+#endif

+

+  /* Store the info we need to destroy after this window is gone */

+  hInstance = (HINSTANCE) GetClassLongPtr (pRLWinPriv->hWnd, GCLP_HMODULE);

+  hiconClass = (HICON) GetClassLongPtr (pRLWinPriv->hWnd, GCLP_HICON);

+  hiconSmClass = (HICON) GetClassLongPtr (pRLWinPriv->hWnd, GCLP_HICONSM);

+  iReturn = GetClassName (pRLWinPriv->hWnd, pszClass, CLASS_NAME_LENGTH);

+

+  pRLWinPriv->fClose = TRUE;

+  pRLWinPriv->fDestroyed = TRUE;

+

+  /* Destroy the Windows window */

+  DestroyWindow (pRLWinPriv->hWnd);

+

+  /* Only if we were able to get the name */

+  if (iReturn)

+    { 

+#if CYGMULTIWINDOW_DEBUG

+      winDebug ("winMWExtWMDestroyFrame - Unregistering %s: ", pszClass);

+#endif

+      iReturn = UnregisterClass (pszClass, hInstance);

+      

+#if CYGMULTIWINDOW_DEBUG

+      winDebug ("winMWExtWMDestroyFramew - %d Deleting Icon: ", iReturn);

+#endif

+      

+      winDestroyIcon(hiconClass);

+      winDestroyIcon(hiconSmClass);

+    }

+

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMDestroyFrame - done\n");

+#endif

+}

+

+void

+winMWExtWMMoveFrame (RootlessFrameID wid, ScreenPtr pScreen, int iNewX, int iNewY)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+  RECT rcNew;

+  DWORD dwExStyle;

+  DWORD dwStyle;

+  int iX, iY, iWidth, iHeight;

+

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMMoveFrame (%08x) (%d %d)\n", (int) pRLWinPriv, iNewX, iNewY);

+#endif

+

+  /* Get the Windows window style and extended style */

+  dwExStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE);

+  dwStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE);

+

+  /* Get the X and Y location of the X window */

+  iX = iNewX + GetSystemMetrics (SM_XVIRTUALSCREEN);

+  iY = iNewY + GetSystemMetrics (SM_YVIRTUALSCREEN);

+

+  /* Get the height and width of the X window */

+  iWidth = pRLWinPriv->pFrame->width;

+  iHeight = pRLWinPriv->pFrame->height;

+

+  /* Store the origin, height, and width in a rectangle structure */

+  SetRect (&rcNew, iX, iY, iX + iWidth, iY + iHeight);

+

+#ifdef CYGMULTIWINDOW_DEBUG

+          winDebug("\tWindow {%d, %d, %d, %d}, {%d, %d}\n", 

+              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,

+              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);

+#endif

+  /*

+   * Calculate the required size of the Windows window rectangle,

+   * given the size of the Windows window client area.

+   */

+  AdjustWindowRectEx (&rcNew, dwStyle, FALSE, dwExStyle);

+

+#ifdef CYGMULTIWINDOW_DEBUG

+          winDebug("\tAdjusted {%d, %d, %d, %d}, {%d, %d}\n", 

+              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,

+              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);

+#endif

+  g_fNoConfigureWindow = TRUE;

+  SetWindowPos (pRLWinPriv->hWnd, NULL, rcNew.left, rcNew.top, 0, 0,

+		SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);

+  g_fNoConfigureWindow = FALSE;

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMMoveFrame (%08x) done\n", (int) pRLWinPriv);

+#endif

+}

+

+void

+winMWExtWMResizeFrame (RootlessFrameID wid, ScreenPtr pScreen,

+			     int iNewX, int iNewY,

+			     unsigned int uiNewWidth, unsigned int uiNewHeight,

+			     unsigned int uiGravity)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+  RECT rcNew;

+  RECT rcOld;

+  DWORD dwExStyle;

+  DWORD dwStyle;

+  int iX, iY;

+

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMResizeFrame (%08x) (%d %d)-(%d %d)\n",

+	  (int) pRLWinPriv, iNewX, iNewY, uiNewWidth, uiNewHeight);

+#endif

+

+  pRLWinPriv->fResized = TRUE;

+

+  /* Get the Windows window style and extended style */

+  dwExStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE);

+  dwStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE);

+

+  /* Get the X and Y location of the X window */

+  iX = iNewX + GetSystemMetrics (SM_XVIRTUALSCREEN);

+  iY = iNewY + GetSystemMetrics (SM_YVIRTUALSCREEN);

+

+  /* Store the origin, height, and width in a rectangle structure */

+  SetRect (&rcNew, iX, iY, iX + uiNewWidth, iY + uiNewHeight);

+

+  /*

+   * Calculate the required size of the Windows window rectangle,

+   * given the size of the Windows window client area.

+   */

+  AdjustWindowRectEx (&rcNew, dwStyle, FALSE, dwExStyle);

+

+  /* Get a rectangle describing the old Windows window */

+  GetWindowRect (pRLWinPriv->hWnd, &rcOld);

+

+  /* Check if the old rectangle and new rectangle are the same */

+  if (!EqualRect (&rcNew, &rcOld))

+    {

+

+      g_fNoConfigureWindow = TRUE;

+      MoveWindow (pRLWinPriv->hWnd,

+		  rcNew.left, rcNew.top,

+		  rcNew.right - rcNew.left, rcNew.bottom - rcNew.top,

+		  TRUE);

+      g_fNoConfigureWindow = FALSE;

+    }

+}

+

+void

+winMWExtWMRestackFrame (RootlessFrameID wid, RootlessFrameID nextWid)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+  win32RootlessWindowPtr pRLNextWinPriv = (win32RootlessWindowPtr) nextWid;

+  winScreenPriv(pRLWinPriv->pFrame->win->drawable.pScreen);

+  winScreenInfo *pScreenInfo = NULL;

+  DWORD dwCurrentProcessID = GetCurrentProcessId ();

+  DWORD dwWindowProcessID = 0;

+  HWND hWnd;

+  Bool fFirst = TRUE;

+  Bool fNeedRestack = TRUE;

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMRestackFrame (%08x)\n", (int) pRLWinPriv);

+#endif

+

+  if (pScreenPriv->fRestacking) return;

+

+  if (pScreenPriv) pScreenInfo = pScreenPriv->pScreenInfo;

+

+  pRLWinPriv->fRestackingNow = TRUE;

+

+  /* Show window */

+  if(!IsWindowVisible (pRLWinPriv->hWnd))

+    ShowWindow (pRLWinPriv->hWnd, SW_SHOWNOACTIVATE);

+

+  if (pRLNextWinPriv == NULL)

+    {

+#if CYGMULTIWINDOW_DEBUG

+      winDebug ("Win %08x is top\n", pRLWinPriv);

+#endif

+      pScreenPriv->widTop = wid;

+      SetWindowPos (pRLWinPriv->hWnd, HWND_TOP,

+		    0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);

+    }

+  else if (winIsInternalWMRunning(pScreenInfo))

+    {

+      /* using mulwinidow wm */

+#if CYGMULTIWINDOW_DEBUG

+      winDebug ("Win %08x is not top\n", pRLWinPriv);

+#endif

+      for (hWnd = GetNextWindow (pRLWinPriv->hWnd, GW_HWNDPREV);

+	   fNeedRestack && hWnd != NULL;

+	   hWnd = GetNextWindow (hWnd, GW_HWNDPREV))

+	{

+	  GetWindowThreadProcessId (hWnd, &dwWindowProcessID);

+

+	  if ((dwWindowProcessID == dwCurrentProcessID)

+	      && GetProp (hWnd, WIN_WINDOW_PROP))

+	    {

+	      if (hWnd == pRLNextWinPriv->hWnd)

+		{

+		  /* Enable interleave X window and Windows window */

+		  if (!fFirst)

+		    {

+#if CYGMULTIWINDOW_DEBUG

+		      winDebug ("raise: Insert after Win %08x\n", pRLNextWinPriv);

+#endif

+		      SetWindowPos (pRLWinPriv->hWnd, pRLNextWinPriv->hWnd,

+				    0, 0, 0, 0,

+				    SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);

+		    }

+		  else

+		    {

+#if CYGMULTIWINDOW_DEBUG

+		      winDebug ("No change\n");

+#endif

+		    }

+		  fNeedRestack = FALSE;

+		  break;

+		}

+	      if (fFirst) fFirst = FALSE;

+	    }

+	}

+

+      for (hWnd = GetNextWindow (pRLWinPriv->hWnd, GW_HWNDNEXT);

+	   fNeedRestack && hWnd != NULL;

+	   hWnd = GetNextWindow (hWnd, GW_HWNDNEXT))

+	{

+	  GetWindowThreadProcessId (hWnd, &dwWindowProcessID);

+

+	  if ((dwWindowProcessID == dwCurrentProcessID)

+	      && GetProp (hWnd, WIN_WINDOW_PROP))

+	    {

+	      if (hWnd == pRLNextWinPriv->hWnd)

+		{

+#if CYGMULTIWINDOW_DEBUG

+		  winDebug ("lower: Insert after Win %08x\n", pRLNextWinPriv);

+#endif

+		  SetWindowPos (pRLWinPriv->hWnd, pRLNextWinPriv->hWnd,

+				0, 0, 0, 0,

+				SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);

+		  fNeedRestack = FALSE;

+		  break;

+		}

+	    }

+	}

+    }

+  else

+    {

+      /* using general wm like twm, wmaker etc.

+	 Interleave X window and Windows window will cause problem. */

+      SetWindowPos (pRLWinPriv->hWnd, pRLNextWinPriv->hWnd,

+		    0, 0, 0, 0,

+		    SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);

+#if 0

+#endif

+    }

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMRestackFrame - done (%08x)\n", (int) pRLWinPriv);

+#endif

+

+  pRLWinPriv->fRestackingNow = FALSE;

+}

+

+void

+winMWExtWMReshapeFrame (RootlessFrameID wid, RegionPtr pShape)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+  HRGN hRgn, hRgnWindow, hRgnClient;

+  RECT rcWindow, rcClient;

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMReshapeFrame (%08x)\n", (int) pRLWinPriv);

+#endif

+

+  hRgn = winMWExtWMCreateRgnFromRegion (pShape);

+  

+  /* Create region for non-client area */

+  GetWindowRect (pRLWinPriv->hWnd, &rcWindow);

+  GetClientRect (pRLWinPriv->hWnd, &rcClient);

+  MapWindowPoints (pRLWinPriv->hWnd, HWND_DESKTOP, (LPPOINT)&rcClient, 2);

+  OffsetRgn (hRgn, rcClient.left - rcWindow.left, rcClient.top - rcWindow.top);

+  OffsetRect (&rcClient, -rcWindow.left, -rcWindow.top);

+  OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);

+  hRgnWindow = CreateRectRgnIndirect (&rcWindow);

+  hRgnClient = CreateRectRgnIndirect (&rcClient);

+  CombineRgn (hRgnWindow, hRgnWindow, hRgnClient, RGN_DIFF);

+  CombineRgn (hRgn, hRgnWindow, hRgn, RGN_OR);

+

+

+  SetWindowRgn (pRLWinPriv->hWnd, hRgn, TRUE);

+

+  DeleteObject (hRgnWindow);

+  DeleteObject (hRgnClient);

+}

+

+void

+winMWExtWMUnmapFrame (RootlessFrameID wid)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMUnmapFrame (%08x)\n", (int) pRLWinPriv);

+#endif

+

+  g_fNoConfigureWindow = TRUE;

+  //ShowWindow (pRLWinPriv->hWnd, SW_MINIMIZE);

+  ShowWindow (pRLWinPriv->hWnd, SW_HIDE);

+  g_fNoConfigureWindow = FALSE;

+}

+

+/*

+ * Fixme: Code sharing with winshadgdi.c and other engine support

+ */

+void

+winMWExtWMStartDrawing (RootlessFrameID wid, char **pixelData, int *bytesPerRow)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+  winPrivScreenPtr	pScreenPriv = NULL;

+  winScreenInfo		*pScreenInfo = NULL;

+  ScreenPtr		pScreen = NULL;

+  DIBSECTION		dibsection;

+  Bool			fReturn = TRUE;

+  HDC			hdcNew;

+  HBITMAP		hbmpNew;

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMStartDrawing (%08x) %08x\n", (int) pRLWinPriv, pRLWinPriv->fDestroyed);

+#endif

+

+  if (!pRLWinPriv->fDestroyed)

+    {

+      pScreen = pRLWinPriv->pFrame->win->drawable.pScreen;

+      if (pScreen) pScreenPriv = winGetScreenPriv(pScreen);

+      if (pScreenPriv) pScreenInfo = pScreenPriv->pScreenInfo;

+      

+#if CYGMULTIWINDOW_DEBUG

+      winDebug ("\tpScreenPriv %08X\n", (int) pScreenPriv);

+      winDebug ("\tpScreenInfo %08X\n", (int) pScreenInfo);

+      winDebug ("\t(%d, %d)\n", (int)pRLWinPriv->pFrame->width,

+		(int) pRLWinPriv->pFrame->height);

+#endif

+      if (pRLWinPriv->hdcScreen == NULL)

+	{

+	  InitWin32RootlessEngine (pRLWinPriv);

+	}

+      

+      if (pRLWinPriv->fResized)

+	{

+          /* width * bpp must be multiple of 4 to match 32bit alignment */

+	  int stridesize;

+	  int misalignment;

+         

+	  pRLWinPriv->pbmihShadow->biWidth = pRLWinPriv->pFrame->width;

+	  pRLWinPriv->pbmihShadow->biHeight = -pRLWinPriv->pFrame->height;

+ 

+	  stridesize = pRLWinPriv->pFrame->width * (pScreenInfo->dwBPP >> 3);

+	  misalignment = stridesize & 3; 

+	  if (misalignment != 0)

+	  {

+	    stridesize += 4 - misalignment;

+	    pRLWinPriv->pbmihShadow->biWidth = stridesize / (pScreenInfo->dwBPP >> 3);

+	    winDebug("\tresizing to %d (was %d)\n", 

+		    pRLWinPriv->pbmihShadow->biWidth, pRLWinPriv->pFrame->width);

+	  }

+	  

+	  hdcNew = CreateCompatibleDC (pRLWinPriv->hdcScreen);

+	  /* Create a DI shadow bitmap with a bit pointer */

+	  hbmpNew = CreateDIBSection (pRLWinPriv->hdcScreen,

+				      (BITMAPINFO *) pRLWinPriv->pbmihShadow,

+				      DIB_RGB_COLORS,

+				      (VOID**) &pRLWinPriv->pfb,

+				      NULL,

+				      0);

+	  if (hbmpNew == NULL || pRLWinPriv->pfb == NULL)

+	    {

+	      ErrorF ("winMWExtWMStartDrawing - CreateDIBSection failed\n");

+	      //return FALSE;

+	    }

+	  else

+	    {

+#if CYGMULTIWINDOW_DEBUG

+	      winDebug ("winMWExtWMStartDrawing - Shadow buffer allocated\n");

+#endif

+	    }

+	  

+	  /* Get information about the bitmap that was allocated */

+	  GetObject (hbmpNew, sizeof (dibsection), &dibsection);

+	  

+#if CYGMULTIWINDOW_DEBUG

+	  /* Print information about bitmap allocated */

+	  winDebug ("winMWExtWMStartDrawing - Dibsection width: %d height: %d "

+		    "depth: %d size image: %d\n",

+		    (unsigned int)dibsection.dsBmih.biWidth,

+		    (unsigned int)dibsection.dsBmih.biHeight,

+		    (unsigned int)dibsection.dsBmih.biBitCount,

+		    (unsigned int)dibsection.dsBmih.biSizeImage);

+#endif

+	  

+	  /* Select the shadow bitmap into the shadow DC */

+	  SelectObject (hdcNew, hbmpNew);

+	  

+#if CYGMULTIWINDOW_DEBUG

+	  winDebug ("winMWExtWMStartDrawing - Attempting a shadow blit\n");

+#endif

+	  

+	  /* Blit from the old shadow to the new shadow */

+	  fReturn = BitBlt (hdcNew,

+			    0, 0,

+			    pRLWinPriv->pFrame->width, pRLWinPriv->pFrame->height,

+			    pRLWinPriv->hdcShadow,

+			    0, 0,

+			    SRCCOPY);

+	  if (fReturn)

+	    {

+	      winDebug ("winMWExtWMStartDrawing - Shadow blit success\n");

+	    }

+	  else

+	    {

+	      ErrorF ("winMWExtWMStartDrawing - Shadow blit failure\n");

+	    }

+	  

+	  /* Look for height weirdness */

+	  if (dibsection.dsBmih.biHeight < 0)

+	    {

+	      /* FIXME: Figure out why biHeight is sometimes negative */

+	      ErrorF ("winMWExtWMStartDrawing - WEIRDNESS - "

+                  "biHeight still negative: %d\n", 

+                  (int) dibsection.dsBmih.biHeight);

+	      ErrorF ("winMWExtWMStartDrawing - WEIRDNESS - "

+                  "Flipping biHeight sign\n");

+	      dibsection.dsBmih.biHeight = -dibsection.dsBmih.biHeight;

+	    }

+	  

+	  pRLWinPriv->dwWidthBytes = dibsection.dsBm.bmWidthBytes;

+	  

+	  winDebug ("winMWExtWMStartDrawing - bytesPerRow: %d\n",

+		    (unsigned int)dibsection.dsBm.bmWidthBytes);

+	  

+	  /* Free the old shadow bitmap */

+	  DeleteObject (pRLWinPriv->hdcShadow);

+	  DeleteObject (pRLWinPriv->hbmpShadow);

+	  

+	  pRLWinPriv->hdcShadow = hdcNew;

+	  pRLWinPriv->hbmpShadow = hbmpNew;

+	  

+	  pRLWinPriv->fResized = FALSE;

+	  winDebug ("winMWExtWMStartDrawing - 0x%08x %d\n",

+		(unsigned int)pRLWinPriv->pfb, 

+		(unsigned int)dibsection.dsBm.bmWidthBytes);

+	}

+    }

+  else

+    {

+      ErrorF ("winMWExtWMStartDrawing - Already window was destroyed \n"); 

+    }

+  winDebug ("winMWExtWMStartDrawing - done (0x%08x) 0x%08x %d\n",

+	    (int) pRLWinPriv,

+	    (unsigned int)pRLWinPriv->pfb, (unsigned int)pRLWinPriv->dwWidthBytes);

+  *pixelData = pRLWinPriv->pfb;

+  *bytesPerRow = pRLWinPriv->dwWidthBytes;

+}

+

+void

+winMWExtWMStopDrawing (RootlessFrameID wid, Bool fFlush)

+{

+}

+

+void

+winMWExtWMUpdateRegion (RootlessFrameID wid, RegionPtr pDamage)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+  if (!g_fNoConfigureWindow) UpdateWindow (pRLWinPriv->hWnd);

+}

+

+void

+winMWExtWMDamageRects (RootlessFrameID wid, int nCount, const BoxRec *pRects,

+			     int shift_x, int shift_y)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+  const BoxRec *pEnd;

+  winDebug ("winMWExtWMDamageRects (%08x, %d, %08x, %d, %d)\n",

+	    pRLWinPriv, nCount, pRects, shift_x, shift_y);

+

+  for (pEnd = pRects + nCount; pRects < pEnd; pRects++) {

+        RECT rcDmg;

+        rcDmg.left = pRects->x1 + shift_x;

+        rcDmg.top = pRects->y1 + shift_y;

+        rcDmg.right = pRects->x2 + shift_x;

+        rcDmg.bottom = pRects->y2 + shift_y;

+

+	InvalidateRect (pRLWinPriv->hWnd, &rcDmg, FALSE);

+    }

+}

+

+void

+winMWExtWMRootlessSwitchWindow (RootlessWindowPtr pFrame, WindowPtr oldWin)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) pFrame->wid;

+  winDebug ("winMWExtWMRootlessSwitchWindow (%08x) %08x\n",

+	    (int) pRLWinPriv, (int) pRLWinPriv->hWnd);

+  pRLWinPriv->pFrame = pFrame;

+  pRLWinPriv->fResized = TRUE;

+

+  /* Set the window extended style flags */

+  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE, WS_EX_TOOLWINDOW);

+

+  /* Set the window standard style flags */

+  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE,

+		    WS_POPUP | WS_CLIPCHILDREN);

+

+  DeleteProperty (serverClient, oldWin, AtmWindowsWmNativeHwnd ());

+  winMWExtWMSetNativeProperty (pFrame);

+}

+

+void

+winMWExtWMCopyBytes (unsigned int width, unsigned int height,

+			   const void *src, unsigned int srcRowBytes,

+			   void *dst, unsigned int dstRowBytes)

+{

+  winDebug ("winMWExtWMCopyBytes - Not implemented\n");

+}

+

+void

+winMWExtWMFillBytes (unsigned int width, unsigned int height, unsigned int value,

+			   void *dst, unsigned int dstRowBytes)

+{

+  winDebug ("winMWExtWMFillBytes - Not implemented\n");

+}

+

+int

+winMWExtWMCompositePixels (unsigned int width, unsigned int height, unsigned int function,

+				 void *src[2], unsigned int srcRowBytes[2],

+				 void *mask, unsigned int maskRowBytes,

+				 void *dst[2], unsigned int dstRowBytes[2])

+{

+  winDebug ("winMWExtWMCompositePixels - Not implemented\n");

+  return 0;

+}

+

+

+void

+winMWExtWMCopyWindow (RootlessFrameID wid, int nDstRects, const BoxRec *pDstRects,

+			    int nDx, int nDy)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) wid;

+  const BoxRec *pEnd;

+  RECT rcDmg;

+  winDebug ("winMWExtWMCopyWindow (%08x, %d, %08x, %d, %d)\n",

+	  (int) pRLWinPriv, nDstRects, (int) pDstRects, nDx, nDy);

+

+  for (pEnd = pDstRects + nDstRects; pDstRects < pEnd; pDstRects++)

+    {

+      winDebug ("BitBlt (%d, %d, %d, %d) (%d, %d)\n",

+	      pDstRects->x1, pDstRects->y1,

+	      pDstRects->x2 - pDstRects->x1,

+	      pDstRects->y2 - pDstRects->y1,

+	      pDstRects->x1 + nDx,

+	      pDstRects->y1 + nDy);

+

+      if (!BitBlt (pRLWinPriv->hdcShadow,

+		   pDstRects->x1, pDstRects->y1,

+		   pDstRects->x2 - pDstRects->x1,

+		   pDstRects->y2 - pDstRects->y1,

+		   pRLWinPriv->hdcShadow,

+		   pDstRects->x1 + nDx,  pDstRects->y1 + nDy,

+		   SRCCOPY))

+	{

+	  ErrorF ("winMWExtWMCopyWindow - BitBlt failed.\n");

+	}

+      

+      rcDmg.left = pDstRects->x1;

+      rcDmg.top = pDstRects->y1;

+      rcDmg.right = pDstRects->x2;

+      rcDmg.bottom = pDstRects->y2;

+      

+      InvalidateRect (pRLWinPriv->hWnd, &rcDmg, FALSE);

+    }

+  winDebug ("winMWExtWMCopyWindow - done\n");

+}

+

+

+/*

+ * winMWExtWMSetNativeProperty

+ */

+

+static void

+winMWExtWMSetNativeProperty (RootlessWindowPtr pFrame)

+{

+  win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) pFrame->wid;

+  long lData;

+

+  /* FIXME: move this to WindowsWM extension */

+

+  lData = (long) pRLWinPriv->hWnd;

+  dixChangeWindowProperty(serverClient, pFrame->win, AtmWindowsWmNativeHwnd(),

+			  XA_INTEGER, 32, PropModeReplace, 1, &lData, TRUE);

+}

diff --git a/xorg-server/hw/xwin/winwin32rootlesswindow.c b/xorg-server/hw/xwin/winwin32rootlesswindow.c
index 3a49ead69..60e1f8bea 100644
--- a/xorg-server/hw/xwin/winwin32rootlesswindow.c
+++ b/xorg-server/hw/xwin/winwin32rootlesswindow.c
@@ -1,476 +1,476 @@
-/*
- *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
- *
- *Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- *"Software"), to deal in the Software without restriction, including
- *without limitation the rights to use, copy, modify, merge, publish,
- *distribute, sublicense, and/or sell copies of the Software, and to
- *permit persons to whom the Software is furnished to do so, subject to
- *the following conditions:
- *
- *The above copyright notice and this permission notice shall be
- *included in all copies or substantial portions of the Software.
- *
- *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
- *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- *Except as contained in this notice, the name of the XFree86 Project
- *shall not be used in advertising or otherwise to promote the sale, use
- *or other dealings in this Software without prior written authorization
- *from the XFree86 Project.
- *
- * Authors:	Kensuke Matsuzaki
- *		Earle F. Philhower, III
- *		Harold L Hunt II
- */
-
-#ifdef HAVE_XWIN_CONFIG_H
-#include <xwin-config.h>
-#endif
-#include "win.h"
-#include "winprefs.h"
-
-#if 0
-/*
- * winMWExtWMReorderWindows
- */
-
-void
-winMWExtWMReorderWindows (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  HWND hwnd = NULL;
-  win32RootlessWindowPtr pRLWin = NULL;
-  win32RootlessWindowPtr pRLWinSib = NULL;
-  DWORD dwCurrentProcessID = GetCurrentProcessId ();
-  DWORD dwWindowProcessID = 0;
-  XID vlist[2];
-
-#if CYGMULTIWINDOW_DEBUG && FALSE
-  winDebug ("winMWExtWMReorderWindows\n");
-#endif
-
-  pScreenPriv->fRestacking = TRUE;
-
-  if (pScreenPriv->fWindowOrderChanged)
-    {
-#if CYGMULTIWINDOW_DEBUG
-      winDebug ("winMWExtWMReorderWindows - Need to restack\n");
-#endif
-      hwnd = GetTopWindow (NULL);
-
-      while (hwnd)
-	{
-	  GetWindowThreadProcessId (hwnd, &dwWindowProcessID);
-
-	  if ((dwWindowProcessID == dwCurrentProcessID)
-	      && GetProp (hwnd, WIN_WINDOW_PROP))
-	    {
-	      pRLWinSib = pRLWin;
-	      pRLWin = (win32RootlessWindowPtr)GetProp (hwnd, WIN_WINDOW_PROP);
-	      
-	      if (pRLWinSib)
-		{
-		  vlist[0] = pRLWinSib->pFrame->win->drawable.id;
-		  vlist[1] = Below;
-
-		  ConfigureWindow (pRLWin->pFrame->win, CWSibling | CWStackMode,
-				   vlist, wClient(pRLWin->pFrame->win));
-		}
-	      else
-		{
-		  /* 1st window - raise to the top */
-		  vlist[0] = Above;
-
-		  ConfigureWindow (pRLWin->pFrame->win, CWStackMode,
-				   vlist, wClient(pRLWin->pFrame->win));
-		}
-	    }
-	  hwnd = GetNextWindow (hwnd, GW_HWNDNEXT);
-	}
-    }
-
-  pScreenPriv->fRestacking = FALSE;
-  pScreenPriv->fWindowOrderChanged = FALSE;
-}
-#endif
-
-
-/*
- * winMWExtWMMoveXWindow
- */
-
-void
-winMWExtWMMoveXWindow (WindowPtr pWin, int x, int y)
-{
-  CARD32 *vlist = malloc(sizeof(CARD32)*2);
-
-  vlist[0] = x;
-  vlist[1] = y;
-  ConfigureWindow (pWin, CWX | CWY, vlist, wClient(pWin));
-  free(vlist);
-}
-
-
-/*
- * winMWExtWMResizeXWindow
- */
-
-void
-winMWExtWMResizeXWindow (WindowPtr pWin, int w, int h)
-{
-  CARD32 *vlist = malloc(sizeof(CARD32)*2);
-
-  vlist[0] = w;
-  vlist[1] = h;
-  ConfigureWindow (pWin, CWWidth | CWHeight, vlist, wClient(pWin));
-  free(vlist);
-}
-
-
-/*
- * winMWExtWMMoveResizeXWindow
- */
-
-void
-winMWExtWMMoveResizeXWindow (WindowPtr pWin, int x, int y, int w, int h)
-{
-  CARD32 *vlist = malloc(sizeof(long)*4);
-
-  vlist[0] = x;
-  vlist[1] = y;
-  vlist[2] = w;
-  vlist[3] = h;
-
-  ConfigureWindow (pWin, CWX | CWY | CWWidth | CWHeight, vlist, wClient(pWin));
-  free(vlist);
-}
-
-
-/*
- * winMWExtWMUpdateIcon
- * Change the Windows window icon
- */
-
-void
-winMWExtWMUpdateIcon (Window id)
-{
-  WindowPtr		pWin;
-  HICON			hIcon, hiconOld;
-
-  dixLookupResourceByType((pointer) &pWin, id, RT_WINDOW, NullClient, DixUnknownAccess);
-  hIcon = winOverrideIcon ((unsigned long)pWin);
-
-  if (!hIcon)
-    hIcon = winXIconToHICON (pWin, GetSystemMetrics(SM_CXICON));
-
-  if (hIcon)
-    {
-      win32RootlessWindowPtr pRLWinPriv
-	= (win32RootlessWindowPtr) RootlessFrameForWindow (pWin, FALSE);
-
-      if (pRLWinPriv->hWnd)
-	{
-
-          hiconOld = (HICON) SendMessage (pRLWinPriv->hWnd,
-                     WM_SETICON, ICON_BIG, (LPARAM) hIcon);
-          winDestroyIcon(hiconOld);
-	}
-      hIcon=NULL;
-    }
-}
-
-
-/*
- * winMWExtWMDecorateWindow - Update window style. Called by EnumWindows.
- */
-
-wBOOL CALLBACK
-winMWExtWMDecorateWindow (HWND hwnd, LPARAM lParam)
-{
-  win32RootlessWindowPtr pRLWinPriv = NULL;
-  ScreenPtr		pScreen = NULL;
-  winPrivScreenPtr	pScreenPriv = NULL;
-  winScreenInfo		*pScreenInfo = NULL;
-
-  /* Check if the Windows window property for our X window pointer is valid */
-  if ((pRLWinPriv = (win32RootlessWindowPtr)GetProp (hwnd, WIN_WINDOW_PROP)) != NULL)
-    {
-      pScreen				= pRLWinPriv->pFrame->win->drawable.pScreen;
-      if (pScreen) pScreenPriv		= winGetScreenPriv(pScreen);
-      if (pScreenPriv) pScreenInfo	= pScreenPriv->pScreenInfo;
-      if (pRLWinPriv && pScreenInfo) winMWExtWMUpdateWindowDecoration (pRLWinPriv, pScreenInfo);
-    }
-  return TRUE;
-}
-
-
-/*
- * winMWExtWMUpdateWindowDecoration - Update window style.
- */
-
-void
-winMWExtWMUpdateWindowDecoration (win32RootlessWindowPtr pRLWinPriv,
-				  winScreenInfoPtr pScreenInfo)
-{
-  Bool		fDecorate = FALSE;
-  DWORD		dwExStyle = 0;
-  DWORD		dwStyle = 0;
-  WINDOWPLACEMENT wndPlace;
-  UINT		showCmd = 0;
-
-  wndPlace.length = sizeof (WINDOWPLACEMENT);
-
-  /* Get current window placement */
-  GetWindowPlacement (pRLWinPriv->hWnd, &wndPlace);
-
-  if (winIsInternalWMRunning(pScreenInfo))
-    {
-      if (!pRLWinPriv->pFrame->win->overrideRedirect)
-	fDecorate = TRUE;
-    }
-#if 0
-  if (wndPlace.showCmd == SW_HIDE)
-    return;//showCmd = SWP_HIDEWINDOW;
-  else
-    showCmd = SWP_SHOWWINDOW;
-#else
-  if (wndPlace.showCmd == SW_HIDE)
-    return;
-
-  if (IsWindowVisible (pRLWinPriv->hWnd))
-    showCmd = SWP_SHOWWINDOW;
-#endif
-
-  showCmd |= SWP_NOMOVE | SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOZORDER;
-
-  winDebug ("winMWExtWMUpdateWindowDecoration %08x %s\n",
-	    (int)pRLWinPriv, fDecorate?"Decorate":"Bare");
-
-  /* Get the standard and extended window style information */
-  dwExStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE);
-  dwStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE);
-
-  if (fDecorate)
-    {
-      RECT		rcNew;
-      int		iDx, iDy;
-      winWMMessageRec	wmMsg;
-      winScreenPriv(pScreenInfo->pScreen);
-
-      /* */
-      if (!(dwExStyle & WS_EX_APPWINDOW))
-	{
-	  winDebug ("\tBare=>Decorate\n");
-	  /* Setup a rectangle with the X window position and size */
-	  SetRect (&rcNew,
-		   pRLWinPriv->pFrame->x,
-		   pRLWinPriv->pFrame->y,
-		   pRLWinPriv->pFrame->x + pRLWinPriv->pFrame->width,
-		   pRLWinPriv->pFrame->y + pRLWinPriv->pFrame->height);
-
-#ifdef CYGMULTIWINDOW_DEBUG
-          winDebug("\tWindow extend {%d, %d, %d, %d}, {%d, %d}\n", 
-              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,
-              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);
-#endif
-	  /* */
-	  AdjustWindowRectEx (&rcNew,
-			      WS_POPUP | WS_SIZEBOX | WS_OVERLAPPEDWINDOW,
-			      FALSE,
-			      WS_EX_APPWINDOW);
-
-#ifdef CYGMULTIWINDOW_DEBUG
-          winDebug("\tAdjusted {%d, %d, %d, %d}, {%d, %d}\n", 
-              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,
-              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);
-#endif
-	  /* Calculate position deltas */
-	  iDx = pRLWinPriv->pFrame->x - rcNew.left;
-	  iDy = pRLWinPriv->pFrame->y - rcNew.top;
-
-	  /* Calculate new rectangle */
-	  rcNew.left += iDx;
-	  rcNew.right += iDx;
-	  rcNew.top += iDy;
-	  rcNew.bottom += iDy;
-
-	  /* Set the window extended style flags */
-	  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE, WS_EX_APPWINDOW);
-
-	  /* Set the window standard style flags */
-	  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE,
-			    WS_POPUP | WS_SIZEBOX | WS_OVERLAPPEDWINDOW);
-
-#ifdef CYGMULTIWINDOW_DEBUG
-          winDebug("\tWindowStyle: %08x %08x\n",
-              WS_POPUP | WS_SIZEBOX | WS_OVERLAPPEDWINDOW,
-              WS_EX_APPWINDOW);
-#endif
-	  /* Position the Windows window */
-#ifdef CYGMULTIWINDOW_DEBUG
-          winDebug("\tMoved {%d, %d, %d, %d}, {%d, %d}\n", 
-              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,
-              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);
-#endif
-	  SetWindowPos (pRLWinPriv->hWnd, NULL,
-			rcNew.left, rcNew.top,
-			rcNew.right - rcNew.left, rcNew.bottom - rcNew.top,
-			showCmd);
-            
-
-	  wmMsg.hwndWindow = pRLWinPriv->hWnd;
-	  wmMsg.iWindow	= (Window)pRLWinPriv->pFrame->win->drawable.id;
-	  wmMsg.msg = WM_WM_NAME_EVENT;
-	  winSendMessageToWM (pScreenPriv->pWMInfo, &wmMsg);
-
-	  winMWExtWMReshapeFrame ((RootlessFrameID)pRLWinPriv ,
-				  wBoundingShape(pRLWinPriv->pFrame->win));
-	}
-    }
-  else
-    {
-      RECT		rcNew;
-
-      /* */
-      if (dwExStyle & WS_EX_APPWINDOW)
-	{
-	  winDebug ("\tDecorate=>Bare\n");
-	  /* Setup a rectangle with the X window position and size */
-	  SetRect (&rcNew,
-		   pRLWinPriv->pFrame->x,
-		   pRLWinPriv->pFrame->y,
-		   pRLWinPriv->pFrame->x + pRLWinPriv->pFrame->width,
-		   pRLWinPriv->pFrame->y + pRLWinPriv->pFrame->height);
-#if 0
-	  /* */
-	  AdjustWindowRectEx (&rcNew,
-			      WS_POPUP | WS_CLIPCHILDREN,
-			      FALSE,
-			      WS_EX_TOOLWINDOW);
-
-	  /* Calculate position deltas */
-	  iDx = pRLWinPriv->pFrame->x - rcNew.left;
-	  iDy = pRLWinPriv->pFrame->y - rcNew.top;
-
-	  /* Calculate new rectangle */
-	  rcNew.left += iDx;
-	  rcNew.right += iDx;
-	  rcNew.top += iDy;
-	  rcNew.bottom += iDy;
-#endif
-
-	  /* Hide window temporary to remove from taskbar. */
-	  ShowWindow( pRLWinPriv->hWnd, SW_HIDE );
-
-	  /* Set the window extended style flags */
-	  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE, WS_EX_TOOLWINDOW);
-
-	  /* Set the window standard style flags */
-	  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE,
-			    WS_POPUP | WS_CLIPCHILDREN);
-
-	  /* Position the Windows window */
-	  SetWindowPos (pRLWinPriv->hWnd, NULL,
-			rcNew.left, rcNew.top,
-			rcNew.right - rcNew.left, rcNew.bottom - rcNew.top,
-			showCmd);
-
-	  winMWExtWMReshapeFrame ((RootlessFrameID)pRLWinPriv ,
-				  wBoundingShape(pRLWinPriv->pFrame->win));
-	}
-    }
-}
-
-
-/*
- * winIsInternalWMRunning (winScreenInfoPtr pScreenInfo)
- */
-Bool
-winIsInternalWMRunning (winScreenInfoPtr pScreenInfo)
-{
-  return pScreenInfo->fInternalWM && !pScreenInfo->fAnotherWMRunning;
-}
-
-
-/*
- * winMWExtWMRestackWindows
- */
-
-void
-winMWExtWMRestackWindows (ScreenPtr pScreen)
-{
-  winScreenPriv(pScreen);
-  WindowPtr pRoot = WindowTable[pScreen->myNum];
-  WindowPtr pWin = NULL;
-  WindowPtr pWinPrev = NULL;
-  win32RootlessWindowPtr pRLWin = NULL;
-  win32RootlessWindowPtr pRLWinPrev = NULL;
-  int  nWindow = 0;
-  HDWP hWinPosInfo = NULL;
-
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMRestackWindows\n");
-#endif
-
-  pScreenPriv->fRestacking = TRUE;
-
-  if (pRoot != NULL)
-    {
-      for (pWin = pRoot->firstChild; pWin; pWin = pWin->nextSib)
-	nWindow ++;
-
-      hWinPosInfo = BeginDeferWindowPos(nWindow);
-
-      for (pWin = pRoot->firstChild; pWin; pWin = pWin->nextSib)
-	{
-	  if (pWin->realized)
-	    {
-	      UINT uFlags;
-
-	      pRLWin = (win32RootlessWindowPtr) RootlessFrameForWindow (pWin, FALSE);
-	      if (pRLWin == NULL) continue;
-
-	      if (pWinPrev)
-		pRLWinPrev = (win32RootlessWindowPtr) RootlessFrameForWindow (pWinPrev, FALSE);
-
-	      uFlags = SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW;
-	      if (pRLWinPrev != NULL) uFlags |= SWP_NOACTIVATE;
-
-#if CYGMULTIWINDOW_DEBUG
-	      winDebug ("winMWExtWMRestackWindows - DeferWindowPos (%08x, %08x)\n",
-			pRLWin->hWnd,
-			pRLWinPrev ? pRLWinPrev->hWnd : HWND_TOP);
-#endif
-	      hWinPosInfo = DeferWindowPos (hWinPosInfo, pRLWin->hWnd,
-					    pRLWinPrev ? pRLWinPrev->hWnd : HWND_TOP,
-					    0, 0, 0, 0,
-					    uFlags);
-	      if (hWinPosInfo == NULL)
-		{
-		  ErrorF ("winMWExtWMRestackWindows - DeferWindowPos () failed: %d\n",
-			  (int) GetLastError ());
-		  return;
-		}
-	      pWinPrev = pWin;
-	    }
-	}
-      if (!EndDeferWindowPos (hWinPosInfo))
-	{
-	  ErrorF ("winMWExtWMRestackWindows - EndDeferWindowPos () failed: %d\n",
-		  (int) GetLastError ());
-	  return;
-	}
-    }
-
-#if CYGMULTIWINDOW_DEBUG
-  winDebug ("winMWExtWMRestackWindows - done\n");
-#endif
-  pScreenPriv->fRestacking = FALSE;
-}
+/*

+ *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.

+ *

+ *Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ *"Software"), to deal in the Software without restriction, including

+ *without limitation the rights to use, copy, modify, merge, publish,

+ *distribute, sublicense, and/or sell copies of the Software, and to

+ *permit persons to whom the Software is furnished to do so, subject to

+ *the following conditions:

+ *

+ *The above copyright notice and this permission notice shall be

+ *included in all copies or substantial portions of the Software.

+ *

+ *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR

+ *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

+ *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ *Except as contained in this notice, the name of the XFree86 Project

+ *shall not be used in advertising or otherwise to promote the sale, use

+ *or other dealings in this Software without prior written authorization

+ *from the XFree86 Project.

+ *

+ * Authors:	Kensuke Matsuzaki

+ *		Earle F. Philhower, III

+ *		Harold L Hunt II

+ */

+

+#ifdef HAVE_XWIN_CONFIG_H

+#include <xwin-config.h>

+#endif

+#include "win.h"

+#include "winprefs.h"

+

+#if 0

+/*

+ * winMWExtWMReorderWindows

+ */

+

+void

+winMWExtWMReorderWindows (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  HWND hwnd = NULL;

+  win32RootlessWindowPtr pRLWin = NULL;

+  win32RootlessWindowPtr pRLWinSib = NULL;

+  DWORD dwCurrentProcessID = GetCurrentProcessId ();

+  DWORD dwWindowProcessID = 0;

+  XID vlist[2];

+

+#if CYGMULTIWINDOW_DEBUG && FALSE

+  winDebug ("winMWExtWMReorderWindows\n");

+#endif

+

+  pScreenPriv->fRestacking = TRUE;

+

+  if (pScreenPriv->fWindowOrderChanged)

+    {

+#if CYGMULTIWINDOW_DEBUG

+      winDebug ("winMWExtWMReorderWindows - Need to restack\n");

+#endif

+      hwnd = GetTopWindow (NULL);

+

+      while (hwnd)

+	{

+	  GetWindowThreadProcessId (hwnd, &dwWindowProcessID);

+

+	  if ((dwWindowProcessID == dwCurrentProcessID)

+	      && GetProp (hwnd, WIN_WINDOW_PROP))

+	    {

+	      pRLWinSib = pRLWin;

+	      pRLWin = (win32RootlessWindowPtr)GetProp (hwnd, WIN_WINDOW_PROP);

+	      

+	      if (pRLWinSib)

+		{

+		  vlist[0] = pRLWinSib->pFrame->win->drawable.id;

+		  vlist[1] = Below;

+

+		  ConfigureWindow (pRLWin->pFrame->win, CWSibling | CWStackMode,

+				   vlist, wClient(pRLWin->pFrame->win));

+		}

+	      else

+		{

+		  /* 1st window - raise to the top */

+		  vlist[0] = Above;

+

+		  ConfigureWindow (pRLWin->pFrame->win, CWStackMode,

+				   vlist, wClient(pRLWin->pFrame->win));

+		}

+	    }

+	  hwnd = GetNextWindow (hwnd, GW_HWNDNEXT);

+	}

+    }

+

+  pScreenPriv->fRestacking = FALSE;

+  pScreenPriv->fWindowOrderChanged = FALSE;

+}

+#endif

+

+

+/*

+ * winMWExtWMMoveXWindow

+ */

+

+void

+winMWExtWMMoveXWindow (WindowPtr pWin, int x, int y)

+{

+  CARD32 *vlist = malloc(sizeof(CARD32)*2);

+

+  vlist[0] = x;

+  vlist[1] = y;

+  ConfigureWindow (pWin, CWX | CWY, vlist, wClient(pWin));

+  free(vlist);

+}

+

+

+/*

+ * winMWExtWMResizeXWindow

+ */

+

+void

+winMWExtWMResizeXWindow (WindowPtr pWin, int w, int h)

+{

+  CARD32 *vlist = malloc(sizeof(CARD32)*2);

+

+  vlist[0] = w;

+  vlist[1] = h;

+  ConfigureWindow (pWin, CWWidth | CWHeight, vlist, wClient(pWin));

+  free(vlist);

+}

+

+

+/*

+ * winMWExtWMMoveResizeXWindow

+ */

+

+void

+winMWExtWMMoveResizeXWindow (WindowPtr pWin, int x, int y, int w, int h)

+{

+  CARD32 *vlist = malloc(sizeof(long)*4);

+

+  vlist[0] = x;

+  vlist[1] = y;

+  vlist[2] = w;

+  vlist[3] = h;

+

+  ConfigureWindow (pWin, CWX | CWY | CWWidth | CWHeight, vlist, wClient(pWin));

+  free(vlist);

+}

+

+

+/*

+ * winMWExtWMUpdateIcon

+ * Change the Windows window icon

+ */

+

+void

+winMWExtWMUpdateIcon (Window id)

+{

+  WindowPtr		pWin;

+  HICON			hIcon, hiconOld;

+

+  dixLookupResourceByType((pointer) &pWin, id, RT_WINDOW, NullClient, DixUnknownAccess);

+  hIcon = winOverrideIcon ((unsigned long)pWin);

+

+  if (!hIcon)

+    hIcon = winXIconToHICON (pWin, GetSystemMetrics(SM_CXICON));

+

+  if (hIcon)

+    {

+      win32RootlessWindowPtr pRLWinPriv

+	= (win32RootlessWindowPtr) RootlessFrameForWindow (pWin, FALSE);

+

+      if (pRLWinPriv->hWnd)

+	{

+

+          hiconOld = (HICON) SendMessage (pRLWinPriv->hWnd,

+                     WM_SETICON, ICON_BIG, (LPARAM) hIcon);

+          winDestroyIcon(hiconOld);

+	}

+      hIcon=NULL;

+    }

+}

+

+

+/*

+ * winMWExtWMDecorateWindow - Update window style. Called by EnumWindows.

+ */

+

+wBOOL CALLBACK

+winMWExtWMDecorateWindow (HWND hwnd, LPARAM lParam)

+{

+  win32RootlessWindowPtr pRLWinPriv = NULL;

+  ScreenPtr		pScreen = NULL;

+  winPrivScreenPtr	pScreenPriv = NULL;

+  winScreenInfo		*pScreenInfo = NULL;

+

+  /* Check if the Windows window property for our X window pointer is valid */

+  if ((pRLWinPriv = (win32RootlessWindowPtr)GetProp (hwnd, WIN_WINDOW_PROP)) != NULL)

+    {

+      pScreen				= pRLWinPriv->pFrame->win->drawable.pScreen;

+      if (pScreen) pScreenPriv		= winGetScreenPriv(pScreen);

+      if (pScreenPriv) pScreenInfo	= pScreenPriv->pScreenInfo;

+      if (pRLWinPriv && pScreenInfo) winMWExtWMUpdateWindowDecoration (pRLWinPriv, pScreenInfo);

+    }

+  return TRUE;

+}

+

+

+/*

+ * winMWExtWMUpdateWindowDecoration - Update window style.

+ */

+

+void

+winMWExtWMUpdateWindowDecoration (win32RootlessWindowPtr pRLWinPriv,

+				  winScreenInfoPtr pScreenInfo)

+{

+  Bool		fDecorate = FALSE;

+  DWORD		dwExStyle = 0;

+  DWORD		dwStyle = 0;

+  WINDOWPLACEMENT wndPlace;

+  UINT		showCmd = 0;

+

+  wndPlace.length = sizeof (WINDOWPLACEMENT);

+

+  /* Get current window placement */

+  GetWindowPlacement (pRLWinPriv->hWnd, &wndPlace);

+

+  if (winIsInternalWMRunning(pScreenInfo))

+    {

+      if (!pRLWinPriv->pFrame->win->overrideRedirect)

+	fDecorate = TRUE;

+    }

+#if 0

+  if (wndPlace.showCmd == SW_HIDE)

+    return;//showCmd = SWP_HIDEWINDOW;

+  else

+    showCmd = SWP_SHOWWINDOW;

+#else

+  if (wndPlace.showCmd == SW_HIDE)

+    return;

+

+  if (IsWindowVisible (pRLWinPriv->hWnd))

+    showCmd = SWP_SHOWWINDOW;

+#endif

+

+  showCmd |= SWP_NOMOVE | SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOZORDER;

+

+  winDebug ("winMWExtWMUpdateWindowDecoration %08x %s\n",

+	    (int)pRLWinPriv, fDecorate?"Decorate":"Bare");

+

+  /* Get the standard and extended window style information */

+  dwExStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE);

+  dwStyle = GetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE);

+

+  if (fDecorate)

+    {

+      RECT		rcNew;

+      int		iDx, iDy;

+      winWMMessageRec	wmMsg;

+      winScreenPriv(pScreenInfo->pScreen);

+

+      /* */

+      if (!(dwExStyle & WS_EX_APPWINDOW))

+	{

+	  winDebug ("\tBare=>Decorate\n");

+	  /* Setup a rectangle with the X window position and size */

+	  SetRect (&rcNew,

+		   pRLWinPriv->pFrame->x,

+		   pRLWinPriv->pFrame->y,

+		   pRLWinPriv->pFrame->x + pRLWinPriv->pFrame->width,

+		   pRLWinPriv->pFrame->y + pRLWinPriv->pFrame->height);

+

+#ifdef CYGMULTIWINDOW_DEBUG

+          winDebug("\tWindow extend {%d, %d, %d, %d}, {%d, %d}\n", 

+              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,

+              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);

+#endif

+	  /* */

+	  AdjustWindowRectEx (&rcNew,

+			      WS_POPUP | WS_SIZEBOX | WS_OVERLAPPEDWINDOW,

+			      FALSE,

+			      WS_EX_APPWINDOW);

+

+#ifdef CYGMULTIWINDOW_DEBUG

+          winDebug("\tAdjusted {%d, %d, %d, %d}, {%d, %d}\n", 

+              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,

+              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);

+#endif

+	  /* Calculate position deltas */

+	  iDx = pRLWinPriv->pFrame->x - rcNew.left;

+	  iDy = pRLWinPriv->pFrame->y - rcNew.top;

+

+	  /* Calculate new rectangle */

+	  rcNew.left += iDx;

+	  rcNew.right += iDx;

+	  rcNew.top += iDy;

+	  rcNew.bottom += iDy;

+

+	  /* Set the window extended style flags */

+	  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE, WS_EX_APPWINDOW);

+

+	  /* Set the window standard style flags */

+	  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE,

+			    WS_POPUP | WS_SIZEBOX | WS_OVERLAPPEDWINDOW);

+

+#ifdef CYGMULTIWINDOW_DEBUG

+          winDebug("\tWindowStyle: %08x %08x\n",

+              WS_POPUP | WS_SIZEBOX | WS_OVERLAPPEDWINDOW,

+              WS_EX_APPWINDOW);

+#endif

+	  /* Position the Windows window */

+#ifdef CYGMULTIWINDOW_DEBUG

+          winDebug("\tMoved {%d, %d, %d, %d}, {%d, %d}\n", 

+              rcNew.left, rcNew.top, rcNew.right, rcNew.bottom,

+              rcNew.right - rcNew.left, rcNew.bottom - rcNew.top);

+#endif

+	  SetWindowPos (pRLWinPriv->hWnd, NULL,

+			rcNew.left, rcNew.top,

+			rcNew.right - rcNew.left, rcNew.bottom - rcNew.top,

+			showCmd);

+            

+

+	  wmMsg.hwndWindow = pRLWinPriv->hWnd;

+	  wmMsg.iWindow	= (Window)pRLWinPriv->pFrame->win->drawable.id;

+	  wmMsg.msg = WM_WM_NAME_EVENT;

+	  winSendMessageToWM (pScreenPriv->pWMInfo, &wmMsg);

+

+	  winMWExtWMReshapeFrame ((RootlessFrameID)pRLWinPriv ,

+				  wBoundingShape(pRLWinPriv->pFrame->win));

+	}

+    }

+  else

+    {

+      RECT		rcNew;

+

+      /* */

+      if (dwExStyle & WS_EX_APPWINDOW)

+	{

+	  winDebug ("\tDecorate=>Bare\n");

+	  /* Setup a rectangle with the X window position and size */

+	  SetRect (&rcNew,

+		   pRLWinPriv->pFrame->x,

+		   pRLWinPriv->pFrame->y,

+		   pRLWinPriv->pFrame->x + pRLWinPriv->pFrame->width,

+		   pRLWinPriv->pFrame->y + pRLWinPriv->pFrame->height);

+#if 0

+	  /* */

+	  AdjustWindowRectEx (&rcNew,

+			      WS_POPUP | WS_CLIPCHILDREN,

+			      FALSE,

+			      WS_EX_TOOLWINDOW);

+

+	  /* Calculate position deltas */

+	  iDx = pRLWinPriv->pFrame->x - rcNew.left;

+	  iDy = pRLWinPriv->pFrame->y - rcNew.top;

+

+	  /* Calculate new rectangle */

+	  rcNew.left += iDx;

+	  rcNew.right += iDx;

+	  rcNew.top += iDy;

+	  rcNew.bottom += iDy;

+#endif

+

+	  /* Hide window temporary to remove from taskbar. */

+	  ShowWindow( pRLWinPriv->hWnd, SW_HIDE );

+

+	  /* Set the window extended style flags */

+	  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_EXSTYLE, WS_EX_TOOLWINDOW);

+

+	  /* Set the window standard style flags */

+	  SetWindowLongPtr (pRLWinPriv->hWnd, GWL_STYLE,

+			    WS_POPUP | WS_CLIPCHILDREN);

+

+	  /* Position the Windows window */

+	  SetWindowPos (pRLWinPriv->hWnd, NULL,

+			rcNew.left, rcNew.top,

+			rcNew.right - rcNew.left, rcNew.bottom - rcNew.top,

+			showCmd);

+

+	  winMWExtWMReshapeFrame ((RootlessFrameID)pRLWinPriv ,

+				  wBoundingShape(pRLWinPriv->pFrame->win));

+	}

+    }

+}

+

+

+/*

+ * winIsInternalWMRunning (winScreenInfoPtr pScreenInfo)

+ */

+Bool

+winIsInternalWMRunning (winScreenInfoPtr pScreenInfo)

+{

+  return pScreenInfo->fInternalWM && !pScreenInfo->fAnotherWMRunning;

+}

+

+

+/*

+ * winMWExtWMRestackWindows

+ */

+

+void

+winMWExtWMRestackWindows (ScreenPtr pScreen)

+{

+  winScreenPriv(pScreen);

+  WindowPtr pRoot = pScreen->root;

+  WindowPtr pWin = NULL;

+  WindowPtr pWinPrev = NULL;

+  win32RootlessWindowPtr pRLWin = NULL;

+  win32RootlessWindowPtr pRLWinPrev = NULL;

+  int  nWindow = 0;

+  HDWP hWinPosInfo = NULL;

+

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMRestackWindows\n");

+#endif

+

+  pScreenPriv->fRestacking = TRUE;

+

+  if (pRoot != NULL)

+    {

+      for (pWin = pRoot->firstChild; pWin; pWin = pWin->nextSib)

+	nWindow ++;

+

+      hWinPosInfo = BeginDeferWindowPos(nWindow);

+

+      for (pWin = pRoot->firstChild; pWin; pWin = pWin->nextSib)

+	{

+	  if (pWin->realized)

+	    {

+	      UINT uFlags;

+

+	      pRLWin = (win32RootlessWindowPtr) RootlessFrameForWindow (pWin, FALSE);

+	      if (pRLWin == NULL) continue;

+

+	      if (pWinPrev)

+		pRLWinPrev = (win32RootlessWindowPtr) RootlessFrameForWindow (pWinPrev, FALSE);

+

+	      uFlags = SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW;

+	      if (pRLWinPrev != NULL) uFlags |= SWP_NOACTIVATE;

+

+#if CYGMULTIWINDOW_DEBUG

+	      winDebug ("winMWExtWMRestackWindows - DeferWindowPos (%08x, %08x)\n",

+			pRLWin->hWnd,

+			pRLWinPrev ? pRLWinPrev->hWnd : HWND_TOP);

+#endif

+	      hWinPosInfo = DeferWindowPos (hWinPosInfo, pRLWin->hWnd,

+					    pRLWinPrev ? pRLWinPrev->hWnd : HWND_TOP,

+					    0, 0, 0, 0,

+					    uFlags);

+	      if (hWinPosInfo == NULL)

+		{

+		  ErrorF ("winMWExtWMRestackWindows - DeferWindowPos () failed: %d\n",

+			  (int) GetLastError ());

+		  return;

+		}

+	      pWinPrev = pWin;

+	    }

+	}

+      if (!EndDeferWindowPos (hWinPosInfo))

+	{

+	  ErrorF ("winMWExtWMRestackWindows - EndDeferWindowPos () failed: %d\n",

+		  (int) GetLastError ());

+	  return;

+	}

+    }

+

+#if CYGMULTIWINDOW_DEBUG

+  winDebug ("winMWExtWMRestackWindows - done\n");

+#endif

+  pScreenPriv->fRestacking = FALSE;

+}

diff --git a/xorg-server/hw/xwin/winwindow.c b/xorg-server/hw/xwin/winwindow.c
index 8156671cd..117a04b00 100644
--- a/xorg-server/hw/xwin/winwindow.c
+++ b/xorg-server/hw/xwin/winwindow.c
@@ -135,25 +135,25 @@ winCopyWindowNativeGDI (WindowPtr pWin,
   winScreenPriv(pScreen);

 

   /* Get a pointer to the root window */

-  pwinRoot = WindowTable[pWin->drawable.pScreen->myNum];

+  pwinRoot = pWin->drawable.pScreen->root;

 

   /* Create a region for the destination */

-  prgnDst = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);

+  prgnDst = RegionCreate(NULL, 1);

 

   /* Calculate the shift from the source to the destination */

   dx = ptOldOrg.x - pWin->drawable.x;

   dy = ptOldOrg.y - pWin->drawable.y;

 

   /* Translate the region from the destination to the source? */

-  REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);

-  REGION_INTERSECT(pWin->drawable.pScreen, prgnDst, &pWin->borderClip,

+  RegionTranslate(prgnSrc, -dx, -dy);

+  RegionIntersect(prgnDst, &pWin->borderClip,

 		   prgnSrc);

 

   /* Get a pointer to the first box in the region to be copied */

-  pBox = REGION_RECTS(prgnDst);

+  pBox = RegionRects(prgnDst);

   

   /* Get the number of boxes in the region */

-  nbox = REGION_NUM_RECTS(prgnDst);

+  nbox = RegionNumRects(prgnDst);

 

   /* Allocate source points for each box */

   if(!(pptSrc = (DDXPointPtr )malloc(nbox * sizeof(DDXPointRec))))

@@ -170,7 +170,7 @@ winCopyWindowNativeGDI (WindowPtr pWin,
     }

 

   /* Setup loop pointers again */

-  pBoxDst = REGION_RECTS(prgnDst);

+  pBoxDst = RegionRects(prgnDst);

   ppt = pptSrc;

 

   /* BitBlt each source to the destination point */

@@ -186,7 +186,7 @@ winCopyWindowNativeGDI (WindowPtr pWin,
 

   /* Cleanup the regions, etc. */

   free(pptSrc);

-  REGION_DESTROY(pWin->drawable.pScreen, prgnDst);

+  RegionDestroy(prgnDst);

 }

 

 

@@ -413,15 +413,15 @@ winMapWindowRootless (WindowPtr pWin)
 

 

 void

-winSetShapeRootless (WindowPtr pWin)

+winSetShapeRootless (WindowPtr pWin, int kind)

 {

   ScreenPtr		pScreen = pWin->drawable.pScreen;

   winScreenPriv(pScreen);

 

-  winDebug ("winSetShapeRootless (%p)\n", pWin);

+  winDebug ("winSetShapeRootless (%p, %i)\n", pWin, kind);

 

   WIN_UNWRAP(SetShape); 

-  (*pScreen->SetShape)(pWin);

+  (*pScreen->SetShape)(pWin, kind);

   WIN_WRAP(SetShape, winSetShapeRootless);

   

   winReshapeRootless (pWin);

@@ -522,7 +522,6 @@ void
 winReshapeRootless (WindowPtr pWin)

 {

   int		nRects;

-  /* ScreenPtr	pScreen = pWin->drawable.pScreen;*/

   RegionRec	rrNewShape;

   BoxPtr	pShape, pRects, pEnd;

   HRGN		hRgn, hRgnRect;

@@ -549,13 +548,13 @@ winReshapeRootless (WindowPtr pWin)
   if (!wBoundingShape (pWin))

     return;

 

-  REGION_NULL(pScreen, &rrNewShape);

-  REGION_COPY(pScreen, &rrNewShape, wBoundingShape(pWin));

-  REGION_TRANSLATE(pScreen, &rrNewShape, pWin->borderWidth,

+  RegionNull(&rrNewShape);

+  RegionCopy(&rrNewShape, wBoundingShape(pWin));

+  RegionTranslate(&rrNewShape, pWin->borderWidth,

                    pWin->borderWidth);

   

-  nRects = REGION_NUM_RECTS(&rrNewShape);

-  pShape = REGION_RECTS(&rrNewShape);

+  nRects = RegionNumRects(&rrNewShape);

+  pShape = RegionRects(&rrNewShape);

   

   if (nRects > 0)

     {

@@ -587,7 +586,7 @@ winReshapeRootless (WindowPtr pWin)
       pWinPriv->hRgn = hRgn;

     }

 

-  REGION_UNINIT(pScreen, &rrNewShape);

+  RegionUninit(&rrNewShape);

   

   return;

 }

diff --git a/xorg-server/hw/xwin/winwindowswm.c b/xorg-server/hw/xwin/winwindowswm.c
index c8f2a7073..0d262c1ea 100644
--- a/xorg-server/hw/xwin/winwindowswm.c
+++ b/xorg-server/hw/xwin/winwindowswm.c
@@ -414,7 +414,6 @@ ProcWindowsWMFrameDraw (register ClientPtr client)
   RECT rcNew;

   int nCmdShow, rc;

   RegionRec newShape;

-  ScreenPtr pScreen;

 

   REQUEST_SIZE_MATCH (xWindowsWMFrameDrawReq);

 

@@ -476,15 +475,14 @@ ProcWindowsWMFrameDraw (register ClientPtr client)
 

   if (wBoundingShape(pWin) != NULL)

     {

-      pScreen = pWin->drawable.pScreen;

       /* wBoundingShape is relative to *inner* origin of window.

 	 Translate by borderWidth to get the outside-relative position. */

       

-      REGION_NULL(pScreen, &newShape);

-      REGION_COPY(pScreen, &newShape, wBoundingShape(pWin));

-      REGION_TRANSLATE(pScreen, &newShape, pWin->borderWidth, pWin->borderWidth);

+      RegionNull(&newShape);

+      RegionCopy(&newShape, wBoundingShape(pWin));

+      RegionTranslate(&newShape, pWin->borderWidth, pWin->borderWidth);

       winMWExtWMReshapeFrame (pRLWinPriv, &newShape);

-      REGION_UNINIT(pScreen, &newShape);

+      RegionUninit(&newShape);

     }

   winDebug ("ProcWindowsWMFrameDraw - done\n");