aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/Xserver/hw
diff options
context:
space:
mode:
authorMihai Moldovan <ionic@ionic.de>2016-05-13 06:19:21 +0200
committerMihai Moldovan <ionic@ionic.de>2016-05-13 06:19:21 +0200
commitaba2a534f630f5b65a53e0ea7cdba17b77263f87 (patch)
tree8c4e2be57984a1d9e6143944d080e19f6c3049ec /nx-X11/programs/Xserver/hw
parent6c6b6b962654ac3c15d27aafbe583ee74e4f2266 (diff)
parent52dc49607e244c0e39b5d7cbdb8b41755f078aac (diff)
downloadnx-libs-aba2a534f630f5b65a53e0ea7cdba17b77263f87.tar.gz
nx-libs-aba2a534f630f5b65a53e0ea7cdba17b77263f87.tar.bz2
nx-libs-aba2a534f630f5b65a53e0ea7cdba17b77263f87.zip
Merge branch 'sunweaver-pr/nxagent-no-compiler-warnings' into arctica-3.6.x
Attributes GH PR #102: https://github.com/ArcticaProject/nx-libs/pull/102
Diffstat (limited to 'nx-X11/programs/Xserver/hw')
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Clipboard.c16
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Colormap.c2
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Display.c10
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Drawable.c234
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Drawable.h8
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Events.c121
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Extensions.c3
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/GC.c47
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/GCOps.c72
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Handlers.c3
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Holder.c1
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Image.c4
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Imakefile5
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Keyboard.c9
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Keystroke.c2
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXdamage.c86
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c12
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c3
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXevents.c65
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXglyph.c4
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c2
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c116
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c169
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXpicture.c24
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXrender.c2
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/NXwindow.c126
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Pixmap.c12
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Render.c18
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Rootless.c2
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Screen.c176
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Screen.h2
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Splash.c1
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Split.c14
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Utils.h4
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Window.c130
35 files changed, 711 insertions, 794 deletions
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c b/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
index 10606a24f..82a1ed77e 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
@@ -269,7 +269,9 @@ void nxagentClearSelection(XEvent *X)
void nxagentRequestSelection(XEvent *X)
{
+ #ifdef DEBUG
int result;
+ #endif
int i = 0;
XSelectionEvent eventSelection;
@@ -311,7 +313,7 @@ FIXME: Do we need this?
if (X->xselectionrequest.target == serverTARGETS)
{
Atom xa_STRING = XA_STRING;
- result = XChangeProperty (nxagentDisplay,
+ XChangeProperty (nxagentDisplay,
X->xselectionrequest.requestor,
X->xselectionrequest.property,
XInternAtom(nxagentDisplay, "ATOM", 0),
@@ -329,7 +331,7 @@ FIXME: Do we need this?
if (i < NumCurrentSelections)
{
- result = XChangeProperty(nxagentDisplay,
+ XChangeProperty(nxagentDisplay,
X->xselectionrequest.requestor,
X->xselectionrequest.property,
X->xselectionrequest.target,
@@ -349,7 +351,10 @@ FIXME: Do we need this?
eventSelection.target = X->xselectionrequest.target;
eventSelection.time = X->xselectionrequest.time;
- result = XSendEvent(nxagentDisplay,
+ #ifdef DEBUG
+ result =
+ #endif
+ XSendEvent(nxagentDisplay,
eventSelection.requestor,
False,
0L,
@@ -463,7 +468,10 @@ FIXME: Do we need this?
eventSelection.property = None;
eventSelection.time = X->xselectionrequest.time;
- result = XSendEvent(nxagentDisplay,
+ #ifdef DEBUG
+ result =
+ #endif
+ XSendEvent(nxagentDisplay,
eventSelection.requestor,
False,
0L,
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
index 3a47e270e..fe3b6ce1d 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
@@ -572,10 +572,8 @@ static void nxagentReconnectColormap(void * p0, XID x1, void * p2)
Bool nxagentReconnectAllColormap(void *p0)
{
- int flexibility;
int cid;
Bool success = True;
- flexibility = *(int*)p0;
#if defined(NXAGENT_RECONNECT_DEBUG) || defined(NXAGENT_RECONNECT_COLORMAP_DEBUG)
fprintf(stderr, "nxagentReconnectAllColormap\n");
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Display.c b/nx-X11/programs/Xserver/hw/nxagent/Display.c
index abc6a9380..628c4c495 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Display.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Display.c
@@ -62,7 +62,11 @@ is" without express or implied warranty.
#include "Init.h"
#include "Args.h"
#include "Image.h"
+
+#define Pixmap XlibPixmap
#include "Icons.h"
+#undef Pixmap
+
#include "Render.h"
#include "Font.h"
#include "Reconnect.h"
@@ -1934,7 +1938,7 @@ Bool nxagentMakeIcon(Display *display, Pixmap *nxIcon, Pixmap *nxMask)
XlibPixmap IconPixmap;
XlibPixmap IconShape;
char* agent_icon_name;
- char* agentIconData;
+ char** agentIconData;
/*
* selecting x2go icon when running as X2Go agent
@@ -2446,7 +2450,6 @@ Bool nxagentReconnectDisplay(void *p0)
{
int i;
int flexibility = *(int*)p0;
- int packMethod, packQuality;
#if defined(NXAGENT_RECONNECT_DEBUG) || defined(NXAGENT_RECONNECT_DISPLAY_DEBUG)
fprintf(stderr, "nxagentReconnectDisplay\n");
@@ -2464,9 +2467,6 @@ Bool nxagentReconnectDisplay(void *p0)
* Reset the values to their defaults.
*/
- packMethod = nxagentPackMethod;
- packQuality = nxagentPackQuality;
-
nxagentPackMethod = -1;
nxagentPackQuality = -1;
nxagentSplitThreshold = -1;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
index 34781e816..51d41db23 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
@@ -47,7 +47,7 @@
/*
* The list of rectangles composing a region
* s returned by nxagentGetOptimizedRegion-
- * Boxes() instead of REGION_RECTS().
+ * Boxes() instead of RegionRects().
*/
#define USE_OPTIMIZED_BOXES
@@ -412,10 +412,10 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
clipRegion = NullRegion;
#ifdef COLLECTED_UPDATES
- REGION_INIT(pDrawable -> pScreen, &collectedUpdates, NullBox, 1);
+ RegionInit(&collectedUpdates, NullBox, 1);
#endif
- REGION_INIT(pDrawable -> pScreen, &exposeRegion, NullBox, 1);
+ RegionInit(&exposeRegion, NullBox, 1);
if (nxagentDrawableBitmap(pDrawable) != NullPixmap &&
nxagentDrawableStatus((DrawablePtr) nxagentDrawableBitmap(pDrawable)) == Synchronized)
@@ -447,7 +447,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable)) -> extents.y1,
nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable)) -> extents.x2,
nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable)) -> extents.y2,
- REGION_NUM_RECTS(nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable))));
+ RegionNumRects(nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable))));
#endif
clipRegion = nxagentCreateRegion(pDrawable, NULL, 0, 0, pDrawable -> width, pDrawable -> height);
@@ -458,7 +458,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
* a previous loop.
*/
- REGION_INTERSECT(pDrawable -> pScreen, clipRegion, clipRegion,
+ RegionIntersect(clipRegion, clipRegion,
nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable)));
/*
@@ -470,14 +470,14 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
* ronization will fix the error.
*/
- REGION_INTERSECT(pDrawable -> pScreen, clipRegion, clipRegion,
+ RegionIntersect(clipRegion, clipRegion,
nxagentCorruptedRegion(pDrawable));
/*
* The bitmap to synchronize is clipped.
*/
- if (REGION_NIL(clipRegion) == 1)
+ if (RegionNil(clipRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentSynchronizeRegion: The bitmap region [%d,%d,%d,%d] is not viewable. "
@@ -499,7 +499,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
}
else
{
- if (pRegion != NullRegion && REGION_NIL(pRegion) == 1)
+ if (pRegion != NullRegion && RegionNil(pRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentSynchronizeRegion: Region [%d,%d,%d,%d] is nil. Skipping synchronization.\n",
@@ -531,9 +531,9 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
* can skip the synchronization.
*/
- REGION_INTERSECT(pDrawable -> pScreen, clipRegion, clipRegion, nxagentCorruptedRegion(pDrawable));
+ RegionIntersect(clipRegion, clipRegion, nxagentCorruptedRegion(pDrawable));
- if (REGION_NIL(clipRegion) == 1)
+ if (RegionNil(clipRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentSynchronizeRegion: The corrupted region [%d,%d,%d,%d] is not viewable "
@@ -554,9 +554,9 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
if (pRegion != NullRegion)
{
- REGION_INTERSECT(pDrawable -> pScreen, clipRegion, clipRegion, pRegion);
+ RegionIntersect(clipRegion, clipRegion, pRegion);
- if (REGION_NIL(clipRegion) == 1)
+ if (RegionNil(clipRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentSynchronizeRegion: Region requested [%d,%d,%d,%d] already "
@@ -604,7 +604,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
#ifdef TEST
fprintf(stderr, "nxagentSynchronizeRegion: Going to synchronize [%ld] rects of [%s] at [%p].\n",
- REGION_NUM_RECTS(clipRegion), nxagentDrawableType(pDrawable), (void *) pDrawable);
+ RegionNumRects(clipRegion), nxagentDrawableType(pDrawable), (void *) pDrawable);
fprintf(stderr, "nxagentSynchronizeRegion: Extents geometry [%d,%d,%d,%d].\n",
clipRegion -> extents.x1, clipRegion -> extents.y1, clipRegion -> extents.x2, clipRegion -> extents.y2);
@@ -647,8 +647,8 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
if (length == 0)
{
- fprintf(stderr, "nxagentSynchronizeRegion: Drawable [%s] at [%p] with region geometry [%ld][%d,%d,%d,%d].\n",
- nxagentDrawableType(pDrawable), (void *) pDrawable, REGION_NUM_RECTS(clipRegion),
+ fprintf(stderr, "nxagentSynchronizeRegion: Drawable [%s] at [%p] with region geometry [%d][%d,%d,%d,%d].\n",
+ nxagentDrawableType(pDrawable), (void *) pDrawable, RegionNumRects(clipRegion),
clipRegion -> extents.x1, clipRegion -> extents.y1,
clipRegion -> extents.x2, clipRegion -> extents.y2);
}
@@ -660,7 +660,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
#ifndef USE_OPTIMIZED_BOXES
- pBox = REGION_RECTS(clipRegion);
+ pBox = RegionRects(clipRegion);
#else
@@ -668,7 +668,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
#endif /* USE_OPTIMIZED_BOXES */
- nBox = REGION_NUM_RECTS(clipRegion);
+ nBox = RegionNumRects(clipRegion);
now = GetTimeInMillis();
@@ -794,12 +794,12 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
* region.
*/
- REGION_INIT(pDrawable -> pScreen, &tileRegion, &tileBox, 1);
+ RegionInit(&tileRegion, &tileBox, 1);
- REGION_UNION(pDrawable -> pScreen, &exposeRegion, &exposeRegion, &tileRegion);
+ RegionUnion(&exposeRegion, &exposeRegion, &tileRegion);
#ifdef COLLECTED_UPDATES
- REGION_APPEND(pDrawable -> pScreen, &collectedUpdates, &tileRegion);
+ RegionAppend(&collectedUpdates, &tileRegion);
#endif
if (useStoredBitmap != 0)
@@ -812,7 +812,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
* associated to this pixmap.
*/
- REGION_SUBTRACT(pDrawable -> pScreen, nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)),
+ RegionSubtract(nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)),
nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)), &tileRegion);
/*
@@ -875,7 +875,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
(void *) nxagentDrawableBitmap(pDrawable));
#endif
- REGION_SUBTRACT(pDrawable -> pScreen, nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)),
+ RegionSubtract(nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)),
nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)), &tileRegion);
}
}
@@ -888,7 +888,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
nxagentRealizeImage(pDrawable, pGC, pDrawable -> depth,
x, y, w, h, leftPad, format, data);
- REGION_UNINIT(pDrawable -> pScreen, &tileRegion);
+ RegionUninit(&tileRegion);
#if !defined(COLLECTED_UPDATES)
@@ -990,7 +990,7 @@ nxagentSynchronizeRegionStop:
if (pDrawable -> type == DRAWABLE_PIXMAP &&
nxagentIsCorruptedBackground((PixmapPtr) pDrawable) == 1 &&
- REGION_NIL(&exposeRegion) == 0)
+ RegionNil(&exposeRegion) == 0)
{
struct nxagentExposeBackground eb;
@@ -1016,14 +1016,14 @@ nxagentSynchronizeRegionStop:
{
int overlap = 0;
- REGION_VALIDATE(pDrawable -> pScreen, &collectedUpdates, &overlap);
+ RegionValidate(&collectedUpdates, &overlap);
- for (i = 0; i < REGION_NUM_RECTS(&collectedUpdates); i++)
+ for (i = 0; i < RegionNumRects(&collectedUpdates); i++)
{
- x = REGION_RECTS(&collectedUpdates)[i].x1;
- y = REGION_RECTS(&collectedUpdates)[i].y1;
- w = REGION_RECTS(&collectedUpdates)[i].x2 - REGION_RECTS(&collectedUpdates)[i].x1;
- h = REGION_RECTS(&collectedUpdates)[i].y2 - REGION_RECTS(&collectedUpdates)[i].y1;
+ x = RegionRects(&collectedUpdates)[i].x1;
+ y = RegionRects(&collectedUpdates)[i].y1;
+ w = RegionRects(&collectedUpdates)[i].x2 - RegionRects(&collectedUpdates)[i].x1;
+ h = RegionRects(&collectedUpdates)[i].y2 - RegionRects(&collectedUpdates)[i].y1;
if (nxagentOption(Shadow) == 1 &&
(nxagentOption(XRatio) != DONT_SCALE ||
@@ -1063,11 +1063,11 @@ nxagentSynchronizeRegionFree:
xfree(data);
}
- REGION_UNINIT(pDrawable -> pScreen, &exposeRegion);
+ RegionUninit(&exposeRegion);
#ifdef COLLECTED_UPDATES
- REGION_UNINIT(pDrawable -> pScreen, &collectedUpdates);
+ RegionUninit(&collectedUpdates);
#endif /* #ifdef COLLECTED_UPDATES */
@@ -1108,7 +1108,7 @@ void nxagentSynchronizeBox(DrawablePtr pDrawable, BoxPtr pBox, unsigned int brea
pBox -> x2 - pBox -> x1, pBox -> y2 - pBox -> y1);
- if (REGION_NIL(pRegion) == 1)
+ if (RegionNil(pRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentSynchronizeBox: Resulting region [%d,%d,%d,%d] is nil. Skipping synchronization.\n",
@@ -1273,7 +1273,7 @@ FIXME: This condition sounds only as a
"with [%ld] rects.\n", nxagentCorruptedRegion(pDrawable) -> extents.x1,
nxagentCorruptedRegion(pDrawable) -> extents.y1, nxagentCorruptedRegion(pDrawable) ->
extents.x2, nxagentCorruptedRegion(pDrawable) -> extents.y2,
- REGION_NUM_RECTS(nxagentCorruptedRegion(pDrawable)));
+ RegionNumRects(nxagentCorruptedRegion(pDrawable)));
#endif
/*
@@ -1518,7 +1518,7 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
box.x2 = x + width;
box.y2 = y + height;
- pRegion = REGION_CREATE(pDrawable -> pScreen, &box, 1);
+ pRegion = RegionCreate(&box, 1);
/*
* Clipping the region.
@@ -1543,11 +1543,11 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
tmpBox.x2 = pDrawable -> width;
tmpBox.y2 = pDrawable -> height;
- REGION_INIT(pDrawable -> pScreen, &tmpRegion, &tmpBox, 1);
+ RegionInit(&tmpRegion, &tmpBox, 1);
- REGION_INTERSECT(pDrawable -> pScreen, pRegion, &tmpRegion, pRegion);
+ RegionIntersect(pRegion, &tmpRegion, pRegion);
- REGION_UNINIT(pDrawable -> pScreen, &tmpRegion);
+ RegionUninit(&tmpRegion);
}
}
else
@@ -1558,19 +1558,19 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
* by its children.
*/
- REGION_TRANSLATE(pDrawable -> pScreen, pRegion,
+ RegionTranslate(pRegion,
pDrawable -> x, pDrawable -> y);
if (nxagentWindowPriv((WindowPtr) pDrawable) -> hasTransparentChildren == 1)
{
- REGION_INTERSECT(pDrawable -> pScreen, pRegion, pRegion, &((WindowPtr) pDrawable) -> borderClip);
+ RegionIntersect(pRegion, pRegion, &((WindowPtr) pDrawable) -> borderClip);
}
else
{
- REGION_INTERSECT(pDrawable -> pScreen, pRegion, pRegion, &((WindowPtr) pDrawable) -> clipList);
+ RegionIntersect(pRegion, pRegion, &((WindowPtr) pDrawable) -> clipList);
}
- REGION_TRANSLATE(pDrawable -> pScreen, pRegion,
+ RegionTranslate(pRegion,
-pDrawable -> x, -pDrawable -> y);
}
@@ -1585,15 +1585,15 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
* to intersect it with the GC's clipmask.
*/
- if (REGION_NIL(pRegion) == 0 &&
+ if (RegionNil(pRegion) == 0 &&
pGC != NULL && pGC -> clientClip != NULL &&
pGC -> clientClipType == CT_REGION)
{
RegionRec clipRegion;
- REGION_INIT(pDrawable -> pScreen, &clipRegion, NullBox, 1);
+ RegionInit(&clipRegion, NullBox, 1);
- REGION_COPY(pDrawable -> pScreen, &clipRegion, (RegionPtr) pGC -> clientClip);
+ RegionCopy(&clipRegion, (RegionPtr) pGC -> clientClip);
/*
* The clip origin is relative to the origin of
@@ -1603,7 +1603,7 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
if (pGC -> clipOrg.x != 0 || pGC -> clipOrg.y != 0)
{
- REGION_TRANSLATE(pDrawable -> pScreen, &clipRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
+ RegionTranslate(&clipRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
}
#ifdef TEST
@@ -1612,9 +1612,9 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
clipRegion.extents.x2, clipRegion.extents.y2);
#endif
- REGION_INTERSECT(pDrawable -> pScreen, pRegion, pRegion, &clipRegion);
+ RegionIntersect(pRegion, pRegion, &clipRegion);
- REGION_UNINIT(pDrawable -> pScreen, &clipRegion);
+ RegionUninit(&clipRegion);
}
return pRegion;
@@ -1627,7 +1627,7 @@ void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
int width;
int height;
- if (pRegion != NullRegion && REGION_NIL(pRegion) == 1)
+ if (pRegion != NullRegion && RegionNil(pRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentMarkCorruptedRegion: Region [%d,%d,%d,%d] is nil. Skipping operation.\n",
@@ -1672,7 +1672,7 @@ void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
nxagentValidateSplit(pDrawable, pRegion);
- REGION_UNION(pDrawable -> pScreen, nxagentCorruptedRegion(pDrawable),
+ RegionUnion(nxagentCorruptedRegion(pDrawable),
nxagentCorruptedRegion(pDrawable), pRegion);
nxagentFreeRegion(pDrawable, pRegion);
@@ -1695,7 +1695,7 @@ void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
nxagentValidateSplit(pDrawable, pRegion);
- REGION_UNION(pDrawable -> pScreen, nxagentCorruptedRegion(pDrawable),
+ RegionUnion(nxagentCorruptedRegion(pDrawable),
nxagentCorruptedRegion(pDrawable), pRegion);
}
}
@@ -1704,7 +1704,7 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
{
int oldStatus;
- if (pRegion != NullRegion && REGION_NIL(pRegion) == 1)
+ if (pRegion != NullRegion && RegionNil(pRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentUnmarkCorruptedRegion: Region [%d,%d,%d,%d] is nil. Skipping operation.\n",
@@ -1735,7 +1735,7 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
nxagentValidateSplit(pDrawable, NULL);
- REGION_EMPTY(pDrawable -> pScreen, nxagentCorruptedRegion(pDrawable));
+ RegionEmpty(nxagentCorruptedRegion(pDrawable));
}
else
{
@@ -1749,7 +1749,7 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
nxagentValidateSplit(pDrawable, pRegion);
- REGION_SUBTRACT(pDrawable -> pScreen, nxagentCorruptedRegion(pDrawable),
+ RegionSubtract(nxagentCorruptedRegion(pDrawable),
nxagentCorruptedRegion(pDrawable), pRegion);
}
@@ -1817,7 +1817,7 @@ void nxagentMoveCorruptedRegion(WindowPtr pWin, unsigned int mask)
nx, ny, (void *) pWin);
#endif
- REGION_TRANSLATE(pWin -> pScreen, nxagentCorruptedRegion((DrawablePtr) pWin),
+ RegionTranslate(nxagentCorruptedRegion((DrawablePtr) pWin),
nx, ny);
/*
@@ -1886,9 +1886,9 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion)
int nBoxOptim;
#endif
- pBox = REGION_RECTS(pRegion);
+ pBox = RegionRects(pRegion);
- nBox = REGION_NUM_RECTS(pRegion);
+ nBox = RegionNumRects(pRegion);
#ifdef TEST
fprintf(stderr, "nxagentGetOptimizedRegionBoxes: Going to optimize region at [%p] with [%d] rects.\n",
@@ -2183,7 +2183,7 @@ unsigned long nxagentGetRegionColor(DrawablePtr pDrawable, RegionPtr pRegion)
{
int xPicker, yPicker;
- if (REGION_NIL(pRegion) == 1)
+ if (RegionNil(pRegion) == 1)
{
return nxagentGetDrawableColor(pDrawable);
}
@@ -2251,7 +2251,7 @@ void nxagentClearRegion(DrawablePtr pDrawable, RegionPtr pRegion)
return;
}
- if (pRegion == NullRegion || REGION_NIL(pRegion) == 1)
+ if (pRegion == NullRegion || RegionNil(pRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentClearRegion: The region is empty. Exiting.\n");
@@ -2306,7 +2306,7 @@ void nxagentClearRegion(DrawablePtr pDrawable, RegionPtr pRegion)
pBox = nxagentGetOptimizedRegionBoxes(pRegion);
- nBox = REGION_NUM_RECTS(pRegion);
+ nBox = RegionNumRects(pRegion);
for (i = 0; i < nBox; i++)
{
@@ -2348,14 +2348,14 @@ void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion)
int nrects;
int i;
- if (REGION_NIL(pRegion) == 1)
+ if (RegionNil(pRegion) == 1)
{
return;
}
pGC = nxagentGetGraphicContext(pDrawable);
- nrects = REGION_NUM_RECTS(pRegion);
+ nrects = RegionNumRects(pRegion);
#ifdef TEST
fprintf(stderr, "nxagentFillRemoteRegion: Going to fill remote region [%d,%d,%d,%d] rects [%d] with color [%lu].\n",
@@ -2372,7 +2372,7 @@ void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion)
}
else
{
- pBox = REGION_RECTS(pRegion);
+ pBox = RegionRects(pRegion);
pRects = xalloc(nrects * sizeof(XRectangle));
@@ -2440,7 +2440,7 @@ void nxagentPointsToDirtyRegion(DrawablePtr pDrawable, int mode,
np = nPoints;
xp = pPoints;
- pRegion = REGION_CREATE(pDrawable -> pScreen, NullBox, 1);
+ pRegion = RegionCreate(NullBox, 1);
while (np--)
{
@@ -2465,28 +2465,28 @@ void nxagentPointsToDirtyRegion(DrawablePtr pDrawable, int mode,
* this loop could become less expensive.
*/
- REGION_INIT(pDrawable -> pScreen, &tmpRegion, &box, 1);
+ RegionInit(&tmpRegion, &box, 1);
- REGION_UNION(pDrawable -> pScreen, pRegion, pRegion, &tmpRegion);
+ RegionUnion(pRegion, pRegion, &tmpRegion);
- REGION_UNINIT(pDrawable -> pScreen, &tmpRegion);
+ RegionUninit(&tmpRegion);
xp++;
}
- extents = *REGION_EXTENTS(pDrawable -> pScreen, pRegion);
+ extents = *RegionExtents(pRegion);
- REGION_RESET(pDrawable -> pScreen, pRegion, &extents);
+ RegionReset(pRegion, &extents);
#ifdef TEST
fprintf(stderr, "nxagentPointsToDirtyRegion: The resulting dirty region has [%ld] rects and"
- " extents (%d,%d,%d,%d).\n", REGION_NUM_RECTS(pRegion), extents.x1,
+ " extents (%d,%d,%d,%d).\n", RegionNumRects(pRegion), extents.x1,
extents.y1, extents.x2, extents.y2);
#endif
nxagentMarkCorruptedRegion(pDrawable, pRegion);
- REGION_DESTROY(pDrawable -> pScreen, pRegion);
+ RegionDestroy(pRegion);
}
#ifdef DUMP
@@ -2533,20 +2533,20 @@ void nxagentCorruptedRegionOnWindow(void *p0, XID x, void *p2)
clipRegion = nxagentCreateRegion((DrawablePtr) pWin, NULL, 0, 0,
pWin -> drawable.width, pWin -> drawable.height);
- REGION_INIT(pWin -> drawable.pScreen, &visRegion, NullBox, 1);
+ RegionInit(&visRegion, NullBox, 1);
- REGION_INTERSECT(pWin -> drawable.pScreen, &visRegion, clipRegion, nxagentCorruptedRegion((DrawablePtr) pWin));
+ RegionIntersect(&visRegion, clipRegion, nxagentCorruptedRegion((DrawablePtr) pWin));
nxagentFreeRegion(pWin -> drawable.pScreen, clipRegion);
- if (REGION_NIL(&visRegion) == 1)
+ if (RegionNil(&visRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentCorruptedRegionOnWindow: The corrupted region of window at [%p] is hidden.\n",
(void *) pWin);
#endif
- REGION_UNINIT(pWin -> drawable.pScreen, &visRegion);
+ RegionUninit(&visRegion);
return;
}
@@ -2569,7 +2569,7 @@ void nxagentCorruptedRegionOnWindow(void *p0, XID x, void *p2)
gc = XCreateGC(nxagentDisplay, nxagentWindow(pWin), GCForeground | GCSubwindowMode, &value);
- nrectangles = REGION_NUM_RECTS(&visRegion);
+ nrectangles = RegionNumRects(&visRegion);
#ifdef TEST
fprintf(stderr, "nxagentCorruptedRegionOnWindow: Going to draw the region with extents [%d,%d,%d,%d] and [%d] rects.\n",
@@ -2594,7 +2594,7 @@ void nxagentCorruptedRegionOnWindow(void *p0, XID x, void *p2)
XFreeGC(nxagentDisplay, gc);
- REGION_UNINIT(pWin -> drawable.pScreen, &visRegion);
+ RegionUninit(&visRegion);
}
void nxagentRegionsOnScreen()
@@ -2673,9 +2673,9 @@ void nxagentCreateDrawableBitmap(DrawablePtr pDrawable)
pClipRegion = nxagentCreateRegion(pDrawable, NULL, 0, 0, pDrawable -> width, pDrawable -> height);
- REGION_INTERSECT(pDrawable -> pScreen, pClipRegion, pClipRegion, nxagentCorruptedRegion(pDrawable));
+ RegionIntersect(pClipRegion, pClipRegion, nxagentCorruptedRegion(pDrawable));
- if (REGION_NIL(pClipRegion) == 1)
+ if (RegionNil(pClipRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentCreateDrawableBitmap: The corrupted region is not visible. Skipping bitmap creation.\n");
@@ -2716,7 +2716,7 @@ void nxagentCreateDrawableBitmap(DrawablePtr pDrawable)
nxagentCopyArea(pDrawable, (DrawablePtr) pBitmap, pGC, x, y, w, h, x, y);
- REGION_UNION(pDrawable -> pScreen, nxagentCorruptedRegion((DrawablePtr) pBitmap),
+ RegionUnion(nxagentCorruptedRegion((DrawablePtr) pBitmap),
nxagentCorruptedRegion((DrawablePtr) pBitmap), pClipRegion);
if (pDrawable -> type == DRAWABLE_PIXMAP)
@@ -3002,19 +3002,19 @@ void nxagentUnmarkExposedRegion(WindowPtr pWin, RegionPtr pRegion, RegionPtr pOt
{
RegionRec clipRegion;
- if (pRegion != NullRegion && REGION_NIL(pRegion) == 0 &&
+ if (pRegion != NullRegion && RegionNil(pRegion) == 0 &&
nxagentDrawableStatus((DrawablePtr) pWin) == NotSynchronized)
{
- REGION_INIT(pWin -> drawable.pScreen, &clipRegion, NullBox, 1);
+ RegionInit(&clipRegion, NullBox, 1);
- REGION_COPY(pWin -> drawable.pScreen, &clipRegion, pRegion);
+ RegionCopy(&clipRegion, pRegion);
- if (pOther != NullRegion && REGION_NIL(pOther) == 0)
+ if (pOther != NullRegion && RegionNil(pOther) == 0)
{
- REGION_UNION(pWin -> drawable.pScreen, &clipRegion, &clipRegion, pOther);
+ RegionUnion(&clipRegion, &clipRegion, pOther);
}
- REGION_TRANSLATE(pWin -> drawable.pScreen, &clipRegion, -pWin -> drawable.x, -pWin -> drawable.y);
+ RegionTranslate(&clipRegion, -pWin -> drawable.x, -pWin -> drawable.y);
#ifdef TEST
fprintf(stderr, "nxagentUnmarkExposedRegion: Validating expose region [%d,%d,%d,%d] "
@@ -3024,7 +3024,7 @@ void nxagentUnmarkExposedRegion(WindowPtr pWin, RegionPtr pRegion, RegionPtr pOt
nxagentUnmarkCorruptedRegion((DrawablePtr) pWin, &clipRegion);
- REGION_UNINIT(pWin -> drawable.pScreen, &clipRegion);
+ RegionUninit(&clipRegion);
}
}
@@ -3061,7 +3061,7 @@ void nxagentSendBackgroundExpose(WindowPtr pWin, PixmapPtr pBackground, RegionPt
RegionRec expose;
miBSWindowPtr pBackingStore;
- REGION_INIT(pWin -> pScreen, &expose, NullBox, 1);
+ RegionInit(&expose, NullBox, 1);
#ifdef DEBUG
fprintf(stderr, "nxagentSendBackgroundExpose: Original expose region is [%d,%d,%d,%d].\n",
@@ -3084,25 +3084,25 @@ void nxagentSendBackgroundExpose(WindowPtr pWin, PixmapPtr pBackground, RegionPt
pWin -> drawable.width, pWin -> drawable.height);
#endif
- REGION_COPY(pWin -> pScreen, &expose, &pWin -> winSize);
+ RegionCopy(&expose, &pWin -> winSize);
}
else
{
- REGION_COPY(pWin -> pScreen, &expose, pExpose);
+ RegionCopy(&expose, pExpose);
- REGION_TRANSLATE(pWin -> pScreen, &expose, pWin -> drawable.x, pWin -> drawable.y);
+ RegionTranslate(&expose, pWin -> drawable.x, pWin -> drawable.y);
}
- REGION_SUBTRACT(pWin -> pScreen, &expose, &expose, nxagentCorruptedRegion((DrawablePtr) pWin));
+ RegionSubtract(&expose, &expose, nxagentCorruptedRegion((DrawablePtr) pWin));
- if (REGION_NIL(&pWin -> clipList) != 0)
+ if (RegionNil(&pWin -> clipList) != 0)
{
#ifdef TEST
fprintf(stderr, "nxagentSendBackgroundExpose: Exposures deferred because the window "
"is hidden.\n");
#endif
- REGION_UNION(pWin -> pScreen, nxagentDeferredBackgroundExposures,
+ RegionUnion(nxagentDeferredBackgroundExposures,
nxagentDeferredBackgroundExposures, &expose);
nxagentWindowPriv(pWin) -> deferredBackgroundExpose = 1;
@@ -3121,32 +3121,32 @@ void nxagentSendBackgroundExpose(WindowPtr pWin, PixmapPtr pBackground, RegionPt
pBackingStore = (miBSWindowPtr)pWin->backStorage;
- if ((pBackingStore != NULL) && (REGION_NIL(&pBackingStore->SavedRegion) == 0))
+ if ((pBackingStore != NULL) && (RegionNil(&pBackingStore->SavedRegion) == 0))
{
- REGION_TRANSLATE(pWin -> pScreen, &expose, -pWin -> drawable.x, -pWin -> drawable.y);
+ RegionTranslate(&expose, -pWin -> drawable.x, -pWin -> drawable.y);
- REGION_SUBTRACT(pWin -> pScreen, &expose, &expose, &pBackingStore -> SavedRegion);
+ RegionSubtract(&expose, &expose, &pBackingStore -> SavedRegion);
- REGION_TRANSLATE(pWin -> pScreen, &expose, pWin -> drawable.x, pWin -> drawable.y);
+ RegionTranslate(&expose, pWin -> drawable.x, pWin -> drawable.y);
}
- REGION_INTERSECT(pWin -> pScreen, &expose, &expose, &pWin -> clipList);
+ RegionIntersect(&expose, &expose, &pWin -> clipList);
/*
* Reduce the overall region to expose.
*/
- REGION_TRANSLATE(pWin -> pScreen, &expose, -pWin -> drawable.x, -pWin -> drawable.y);
+ RegionTranslate(&expose, -pWin -> drawable.x, -pWin -> drawable.y);
- REGION_SUBTRACT(pWin -> pScreen, pExpose, pExpose, &expose);
+ RegionSubtract(pExpose, pExpose, &expose);
- REGION_TRANSLATE(pWin -> pScreen, &expose, pWin -> drawable.x, pWin -> drawable.y);
+ RegionTranslate(&expose, pWin -> drawable.x, pWin -> drawable.y);
miWindowExposures(pWin, &expose, &expose);
nxagentSendBackgroundExposeEnd:
- REGION_UNINIT(pWin -> pScreen, &expose);
+ RegionUninit(&expose);
}
void nxagentExposeBackgroundPredicate(void *p0, XID x1, void *p2)
@@ -3156,7 +3156,7 @@ void nxagentExposeBackgroundPredicate(void *p0, XID x1, void *p2)
struct nxagentExposeBackground *pPair = p2;
- if (REGION_NIL(pPair -> pExpose) != 0)
+ if (RegionNil(pPair -> pExpose) != 0)
{
return;
}
@@ -3217,21 +3217,21 @@ int nxagentClipAndSendClearExpose(WindowPtr pWin, void * ptr)
if (nxagentWindowPriv(pWin) -> deferredBackgroundExpose == 1)
{
- exposeRgn = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1);
+ exposeRgn = RegionCreate(NULL, 1);
#ifdef DEBUG
- box = *REGION_EXTENTS(pWin->drawable.pScreen, remoteExposeRgn);
+ box = *RegionExtents(remoteExposeRgn);
fprintf(stderr, "nxagentClipAndSendClearExpose: Background expose extents: [%d,%d,%d,%d].\n",
box.x1, box.y1, box.x2, box.y2);
- box = *REGION_EXTENTS(pWin->drawable.pScreen, &pWin -> clipList);
+ box = *RegionExtents(&pWin -> clipList);
fprintf(stderr, "nxagentClipAndSendClearExpose: Clip list extents for window at [%p]: [%d,%d,%d,%d].\n",
(void *) pWin, box.x1, box.y1, box.x2, box.y2);
#endif
- REGION_INTERSECT(pWin -> drawable.pScreen, exposeRgn, remoteExposeRgn, &pWin -> clipList);
+ RegionIntersect(exposeRgn, remoteExposeRgn, &pWin -> clipList);
/*
* If the region will be synchronized,
@@ -3239,28 +3239,28 @@ int nxagentClipAndSendClearExpose(WindowPtr pWin, void * ptr)
* be ignored.
*/
- REGION_SUBTRACT(pWin -> drawable.pScreen, exposeRgn, exposeRgn, nxagentCorruptedRegion((DrawablePtr) pWin));
+ RegionSubtract(exposeRgn, exposeRgn, nxagentCorruptedRegion((DrawablePtr) pWin));
- if (REGION_NOTEMPTY(pWin -> drawable.pScreen, exposeRgn))
+ if (RegionNotEmpty(exposeRgn))
{
#ifdef DEBUG
- box = *REGION_EXTENTS(pWin->drawable.pScreen, exposeRgn);
+ box = *RegionExtents(exposeRgn);
fprintf(stderr, "nxagentClipAndSendClearExpose: Forwarding expose [%d,%d,%d,%d] to window at [%p] pWin.\n",
box.x1, box.y1, box.x2, box.y2, (void *) pWin);
#endif
- REGION_SUBTRACT(pWin -> drawable.pScreen, remoteExposeRgn, remoteExposeRgn, exposeRgn);
+ RegionSubtract(remoteExposeRgn, remoteExposeRgn, exposeRgn);
miWindowExposures(pWin, exposeRgn, exposeRgn);
}
- REGION_DESTROY(pWin -> drawable.pScreen, exposeRgn);
+ RegionDestroy(exposeRgn);
nxagentWindowPriv(pWin) -> deferredBackgroundExpose = 0;
}
- if (REGION_NOTEMPTY(pWin -> drawable.pScreen, remoteExposeRgn))
+ if (RegionNotEmpty(remoteExposeRgn))
{
#ifdef DEBUG
fprintf(stderr, "nxagentClipAndSendClearExpose: Region not empty. Walk children.\n");
@@ -3283,10 +3283,10 @@ void nxagentSendDeferredBackgroundExposures(void)
{
if (nxagentDeferredBackgroundExposures == NullRegion)
{
- nxagentDeferredBackgroundExposures = REGION_CREATE(WindowTable[0] -> drawable.pScreen, NullBox, 1);
+ nxagentDeferredBackgroundExposures = RegionCreate(NullBox, 1);
}
- if (REGION_NOTEMPTY(WindowTable[0] -> drawable.pScreen, nxagentDeferredBackgroundExposures) != 0)
+ if (RegionNotEmpty(nxagentDeferredBackgroundExposures) != 0)
{
#ifdef TEST
fprintf(stderr, "nxagentSendDeferredBackgroundExposures: Going to send deferred exposures to the root window.\n");
@@ -3294,7 +3294,7 @@ void nxagentSendDeferredBackgroundExposures(void)
TraverseTree(WindowTable[0], nxagentClipAndSendClearExpose, (void *) nxagentDeferredBackgroundExposures);
- REGION_EMPTY(WindowTable[0] -> drawable.pScreen, nxagentDeferredBackgroundExposures);
+ RegionEmpty(nxagentDeferredBackgroundExposures);
}
}
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.h b/nx-X11/programs/Xserver/hw/nxagent/Drawable.h
index 4ebbc928e..d05eebf19 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Drawable.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Drawable.h
@@ -107,7 +107,7 @@ enum SynchronizationPredicate
nxagentWindowCorruptedRegion((WindowPtr) pDrawable))
#define nxagentDrawableStatus(pDrawable) \
- (REGION_NIL(nxagentCorruptedRegion(pDrawable)) ? \
+ (RegionNil(nxagentCorruptedRegion(pDrawable)) ? \
Synchronized : NotSynchronized)
#define nxagentDrawableContainGlyphs(pDrawable) \
@@ -155,7 +155,7 @@ extern RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, in
int width, int height);
#define nxagentFreeRegion(pDrawable, pRegion) \
- REGION_DESTROY((pDrawable) -> pScreen, pRegion);
+ RegionDestroy(pRegion);
extern void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion);
extern void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion);
@@ -204,8 +204,8 @@ do \
break; \
} \
\
- numRects = REGION_NUM_RECTS(pRegion); \
- pBox = REGION_RECTS(pRegion); \
+ numRects = RegionNumRects(pRegion); \
+ pBox = RegionRects(pRegion); \
\
fprintf(stderr, "printRegionBoxes:: Region " strRegion " at [%p] has [%d] boxes:\n", \
(void *) (pRegion), numRects); \
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Events.c b/nx-X11/programs/Xserver/hw/nxagent/Events.c
index c04481c92..5ad81f781 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Events.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Events.c
@@ -1834,9 +1834,7 @@ FIXME: Don't enqueue the KeyRelease event if the key was
{
#ifdef DEBUG
fprintf(stderr, "nxagentDispatchEvents: Going to handle new Expose event.\n");
- #endif
- #ifdef DEBUG
fprintf(stderr, "nxagentDispatchEvents: WARNING! Received Expose event "
"for drawable [%lx] geometry [%d, %d, %d, %d] count [%d].\n",
X.xexpose.window, X.xexpose.x, X.xexpose.y, X.xexpose.width,
@@ -1851,9 +1849,7 @@ FIXME: Don't enqueue the KeyRelease event if the key was
{
#ifdef DEBUG
fprintf(stderr, "nxagentDispatchEvents: Going to handle new GraphicsExpose event.\n");
- #endif
- #ifdef DEBUG
fprintf(stderr, "nxagentDispatchEvents: WARNING! Received GraphicsExpose event "
"for drawable [%lx] geometry [%d, %d, %d, %d] count [%d].\n",
X.xgraphicsexpose.drawable, X.xgraphicsexpose.x, X.xgraphicsexpose.y,
@@ -1869,9 +1865,7 @@ FIXME: Don't enqueue the KeyRelease event if the key was
{
#ifdef DEBUG
fprintf(stderr, "nxagentDispatchEvents: Going to handle new NoExpose event.\n");
- #endif
- #ifdef DEBUG
fprintf(stderr, "nxagentDispatchEvents: WARNING! Received NoExpose event for "
"drawable [%lx].\n", X.xnoexpose.drawable);
#endif
@@ -2401,9 +2395,7 @@ int nxagentHandleExposeEvent(XEvent *X)
#ifdef DEBUG
fprintf(stderr, "nxagentHandleExposeEvent: Checking remote expose events.\n");
- #endif
- #ifdef DEBUG
fprintf(stderr, "nxagentHandleExposeEvent: Looking for window id [%ld].\n",
X -> xexpose.window);
#endif
@@ -2414,7 +2406,7 @@ int nxagentHandleExposeEvent(XEvent *X)
if (pWin != NULL)
{
- REGION_INIT(pWin -> drawable.pScreen, &sum, (BoxRec *) NULL, 1);
+ RegionInit(&sum, (BoxRec *) NULL, 1);
/*
FIXME: This can be maybe optimized by consuming the
events that do not match the predicate.
@@ -2445,11 +2437,11 @@ FIXME: This can be maybe optimized by consuming the
box.x2 = box.x1 + X -> xexpose.width;
box.y2 = box.y1 + X -> xexpose.height;
- REGION_INIT(pWin -> drawable.pScreen, &add, &box, 1);
+ RegionInit(&add, &box, 1);
- REGION_APPEND(pWin -> drawable.pScreen, &sum, &add);
+ RegionAppend(&sum, &add);
- REGION_UNINIT(pWin -> drawable.pScreen, &add);
+ RegionUninit(&add);
if (X -> xexpose.count == 0)
{
@@ -2459,9 +2451,9 @@ FIXME: This can be maybe optimized by consuming the
while (nxagentCheckEvents(nxagentDisplay, X, nxagentExposurePredicate,
(XPointer) &window) == 1);
- REGION_VALIDATE(pWin -> drawable.pScreen, &sum, &overlap);
+ RegionValidate(&sum, &overlap);
- REGION_INTERSECT(pWin->drawable.pScreen, &sum, &sum,
+ RegionIntersect(&sum, &sum,
&WindowTable[pWin->drawable.pScreen->myNum]->winSize);
#ifdef DEBUG
@@ -2482,14 +2474,14 @@ FIXME: This can be maybe optimized by consuming the
}
else
{
- REGION_TRANSLATE(pWin -> drawable.pScreen, &sum, -pWin -> drawable.x, -pWin -> drawable.y);
+ RegionTranslate(&sum, -pWin -> drawable.x, -pWin -> drawable.y);
if (nxagentExposeQueue.exposures[index].remoteRegion == NullRegion)
{
- nxagentExposeQueue.exposures[index].remoteRegion = REGION_CREATE(pwin -> drawable.pScreen, NULL, 1);
+ nxagentExposeQueue.exposures[index].remoteRegion = RegionCreate(NULL, 1);
}
- REGION_UNION(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[index].remoteRegion,
+ RegionUnion(nxagentExposeQueue.exposures[index].remoteRegion,
nxagentExposeQueue.exposures[index].remoteRegion, &sum);
#ifdef TEST
@@ -2521,7 +2513,7 @@ FIXME: This can be maybe optimized by consuming the
}
}
- REGION_UNINIT(pWin -> drawable.pScreen, &sum);
+ RegionUninit(&sum);
}
return 1;
@@ -2538,7 +2530,6 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
RegionPtr exposeRegion;
BoxRec rect;
WindowPtr pWin;
- ScreenPtr pScreen;
StoringPixmapPtr pStoringPixmapRec = NULL;
miBSWindowPtr pBSwindow = NULL;
int drawableType;
@@ -2581,8 +2572,6 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
pWin = pStoringPixmapRec -> pSavedWindow;
}
- pScreen = pWin -> drawable.pScreen;
-
/*
* Rectangle affected by GraphicsExpose
* event.
@@ -2593,7 +2582,7 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
rect.x2 = rect.x1 + X -> xgraphicsexpose.width;
rect.y2 = rect.y1 + X -> xgraphicsexpose.height;
- exposeRegion = REGION_CREATE(pScreen, &rect, 0);
+ exposeRegion = RegionCreate(&rect, 0);
if (drawableType == DRAWABLE_PIXMAP)
{
@@ -2610,7 +2599,7 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
* window.
*/
- REGION_TRANSLATE(pScreen, exposeRegion, pStoringPixmapRec -> backingStoreX,
+ RegionTranslate(exposeRegion, pStoringPixmapRec -> backingStoreX,
pStoringPixmapRec -> backingStoreY);
/*
@@ -2618,7 +2607,7 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
* affected by the GraphicsExpose event.
*/
- REGION_SUBTRACT(pScreen, &(pBSwindow -> SavedRegion), &(pBSwindow -> SavedRegion),
+ RegionSubtract(&(pBSwindow -> SavedRegion), &(pBSwindow -> SavedRegion),
exposeRegion);
}
@@ -2628,18 +2617,17 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
* must be relative to the screen.
*/
- REGION_TRANSLATE(pScreen, exposeRegion, pWin -> drawable.x, pWin -> drawable.y);
+ RegionTranslate(exposeRegion, pWin -> drawable.x, pWin -> drawable.y);
- REGION_UNION(pScreen, nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, exposeRegion);
+ RegionUnion(nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, exposeRegion);
- REGION_DESTROY(pScreen, exposeRegion);
+ RegionDestroy(exposeRegion);
return 1;
}
int nxagentHandleClientMessageEvent(XEvent *X, enum HandleEventResult *result)
{
- ScreenPtr pScreen;
WindowPtr pWin;
xEvent x;
@@ -2691,7 +2679,9 @@ int nxagentHandleClientMessageEvent(XEvent *X, enum HandleEventResult *result)
if (message_type == MakeAtom("WM_PROTOCOLS", strlen("WM_PROTOCOLS"), False))
{
+ #ifdef TEST
char *message_data;
+ #endif
x.u.u.type = ClientMessage;
x.u.u.detail = X -> xclient.format;
@@ -2710,12 +2700,12 @@ int nxagentHandleClientMessageEvent(XEvent *X, enum HandleEventResult *result)
return 0;
}
+ #ifdef TEST
else
{
message_data = validateString(NameForAtom(x.u.clientMessage.u.l.longs0));
}
- #ifdef TEST
fprintf(stderr, "nxagentHandleClientMessageEvent: Sent client message of type WM_PROTOCOLS "
"and value [%s].\n", message_data);
#endif
@@ -2757,8 +2747,6 @@ int nxagentHandleClientMessageEvent(XEvent *X, enum HandleEventResult *result)
if (X -> xclient.window == nxagentIconWindow)
{
- pScreen = nxagentScreen(X -> xmap.window);
-
XMapRaised(nxagentDisplay, nxagentFullscreenWindow);
XIconifyWindow(nxagentDisplay, nxagentIconWindow,
@@ -3125,28 +3113,6 @@ int nxagentCheckWindowConfiguration(XConfigureEvent* X)
unsigned int nchildren_return = 0;
Status result;
- WindowPtr pWin;
-
- pWin = nxagentWindowPtr(X -> window);
-
- /*
- * This optimization has some problems to
- * work in rootless mode inside NXWin. To
- * verify this you can launch xterm and
- * another application, f.e. firefox. By
- * raising xterm above firefox, the stack
- * order seems to become incoherent showing
- * the underneath window content in the
- * overlapping area when the mouse botton is
- * pressed with the pointer inside of such area.
- *
- * if ((pWin != NULL) && X -> override_redirect == 0)
- * {
- * return 1;
- * }
- *
- */
-
if (win == X -> window)
{
if (x != X -> x ||
@@ -4091,30 +4057,30 @@ void nxagentSynchronizeExpose(void)
{
if ((nxagentExposeQueueHead.localRegion) != NullRegion)
{
- REGION_TRANSLATE(pWin -> drawable.pScreen, (nxagentExposeQueueHead.localRegion),
+ RegionTranslate((nxagentExposeQueueHead.localRegion),
pWin -> drawable.x, pWin -> drawable.y);
}
if ((nxagentExposeQueueHead.remoteRegion) != NullRegion)
{
- REGION_TRANSLATE(pWin -> drawable.pScreen, (nxagentExposeQueueHead.remoteRegion),
+ RegionTranslate((nxagentExposeQueueHead.remoteRegion),
pWin -> drawable.x, pWin -> drawable.y);
}
if ((nxagentExposeQueueHead.localRegion) != NullRegion &&
(nxagentExposeQueueHead.remoteRegion) != NullRegion)
{
- REGION_SUBTRACT(pWin -> drawable.pScreen, (nxagentExposeQueueHead.remoteRegion),
+ RegionSubtract((nxagentExposeQueueHead.remoteRegion),
(nxagentExposeQueueHead.remoteRegion),
(nxagentExposeQueueHead.localRegion));
- if (REGION_NIL(nxagentExposeQueueHead.remoteRegion) == 0 &&
+ if (RegionNil(nxagentExposeQueueHead.remoteRegion) == 0 &&
((pWin -> eventMask|wOtherEventMasks(pWin)) & ExposureMask))
{
#ifdef TEST
fprintf(stderr, "nxagentSynchronizeExpose: Going to call miWindowExposures"
" for window [%ld] - rects [%ld].\n", nxagentWindow(pWin),
- REGION_NUM_RECTS(nxagentExposeQueueHead.remoteRegion));
+ RegionNumRects(nxagentExposeQueueHead.remoteRegion));
#endif
miWindowExposures(pWin, nxagentExposeQueueHead.remoteRegion, NullRegion);
@@ -4126,14 +4092,14 @@ void nxagentSynchronizeExpose(void)
if (nxagentExposeQueueHead.localRegion != NullRegion)
{
- REGION_DESTROY(nxagentDefaultScreen, nxagentExposeQueueHead.localRegion);
+ RegionDestroy(nxagentExposeQueueHead.localRegion);
}
nxagentExposeQueueHead.localRegion = NullRegion;
if (nxagentExposeQueueHead.remoteRegion != NullRegion)
{
- REGION_DESTROY(nxagentDefaultScreen, nxagentExposeQueueHead.remoteRegion);
+ RegionDestroy(nxagentExposeQueueHead.remoteRegion);
}
nxagentExposeQueueHead.remoteRegion = NullRegion;
@@ -4260,7 +4226,7 @@ void nxagentInitRemoteExposeRegion(void)
{
if (nxagentRemoteExposeRegion == NULL)
{
- nxagentRemoteExposeRegion = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1);
+ nxagentRemoteExposeRegion = RegionCreate(NULL, 1);
if (nxagentRemoteExposeRegion == NULL)
{
@@ -4273,7 +4239,7 @@ void nxagentInitRemoteExposeRegion(void)
void nxagentForwardRemoteExpose(void)
{
- if (REGION_NOTEMPTY(WindowTable[0] -> drawable.pScreen, nxagentRemoteExposeRegion))
+ if (RegionNotEmpty(nxagentRemoteExposeRegion))
{
#ifdef DEBUG
fprintf(stderr, "nxagentForwardRemoteExpose: Going to forward events.\n");
@@ -4285,7 +4251,7 @@ void nxagentForwardRemoteExpose(void)
* Now this region should be empty.
*/
- REGION_EMPTY(WindowTable[0] -> drawable.pScreen, nxagentRemoteExposeRegion);
+ RegionEmpty(nxagentRemoteExposeRegion);
}
}
@@ -4298,21 +4264,22 @@ void nxagentAddRectToRemoteExposeRegion(BoxPtr rect)
return;
}
- REGION_INIT(nxagentDefaultScreen, &exposeRegion, rect, 1);
+ RegionInit(&exposeRegion, rect, 1);
- REGION_UNION(nxagentDefaultScreen, nxagentRemoteExposeRegion,
+ RegionUnion(nxagentRemoteExposeRegion,
nxagentRemoteExposeRegion, &exposeRegion);
- REGION_UNINIT(nxagentDefaultScreen, &exposeRegion);
+ RegionUninit(&exposeRegion);
}
int nxagentClipAndSendExpose(WindowPtr pWin, void * ptr)
{
RegionPtr exposeRgn;
RegionPtr remoteExposeRgn;
- BoxRec box;
#ifdef DEBUG
+ BoxRec box;
+
fprintf(stderr, "nxagentClipAndSendExpose: Called.\n");
#endif
@@ -4320,25 +4287,23 @@ int nxagentClipAndSendExpose(WindowPtr pWin, void * ptr)
if (pWin -> drawable.class != InputOnly)
{
- exposeRgn = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1);
-
- box = *REGION_EXTENTS(pWin->drawable.pScreen, remoteExposeRgn);
+ exposeRgn = RegionCreate(NULL, 1);
#ifdef DEBUG
+ box = *RegionExtents(remoteExposeRgn);
+
fprintf(stderr, "nxagentClipAndSendExpose: Root expose extents: [%d] [%d] [%d] [%d].\n",
box.x1, box.y1, box.x2, box.y2);
- #endif
- box = *REGION_EXTENTS(pWin->drawable.pScreen, &pWin -> clipList);
+ box = *RegionExtents(&pWin -> clipList);
- #ifdef DEBUG
fprintf(stderr, "nxagentClipAndSendExpose: Clip list extents for window at [%p]: [%d] [%d] [%d] [%d].\n",
pWin, box.x1, box.y1, box.x2, box.y2);
#endif
- REGION_INTERSECT(pWin -> drawable.pScreen, exposeRgn, remoteExposeRgn, &pWin -> clipList);
+ RegionIntersect(exposeRgn, remoteExposeRgn, &pWin -> clipList);
- if (REGION_NOTEMPTY(pWin -> drawable.pScreen, exposeRgn))
+ if (RegionNotEmpty(exposeRgn))
{
#ifdef DEBUG
fprintf(stderr, "nxagentClipAndSendExpose: Forwarding expose to window at [%p] pWin.\n",
@@ -4351,15 +4316,15 @@ int nxagentClipAndSendExpose(WindowPtr pWin, void * ptr)
* ration must be done before calling it.
*/
- REGION_SUBTRACT(pWin -> drawable.pScreen, remoteExposeRgn, remoteExposeRgn, exposeRgn);
+ RegionSubtract(remoteExposeRgn, remoteExposeRgn, exposeRgn);
miWindowExposures(pWin, exposeRgn, NullRegion);
}
- REGION_DESTROY(pWin -> drawable.pScreen, exposeRgn);
+ RegionDestroy(exposeRgn);
}
- if (REGION_NOTEMPTY(pWin -> drawable.pScreen, remoteExposeRgn))
+ if (RegionNotEmpty(remoteExposeRgn))
{
#ifdef DEBUG
fprintf(stderr, "nxagentClipAndSendExpose: Region not empty. Walk children.\n");
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Extensions.c b/nx-X11/programs/Xserver/hw/nxagent/Extensions.c
index d77d27674..dfa511448 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Extensions.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Extensions.c
@@ -156,7 +156,6 @@ int nxagentRandRGetInfo(ScreenPtr pScreen, Rotation *pRotations)
static int nxagentRandRInitSizes(ScreenPtr pScreen)
{
RRScreenSizePtr pSize;
- rrScrPrivPtr pRandRScrPriv = rrGetScrPriv(pScreen);
int width;
int height;
@@ -260,7 +259,6 @@ int nxagentRandRSetConfig(ScreenPtr pScreen, Rotation rotation,
int rate, RRScreenSizePtr pSize)
{
int r;
- rrScrPrivPtr pRandRScrPriv;
UpdateCurrentTime();
@@ -319,7 +317,6 @@ int nxagentRandRScreenSetSize(ScreenPtr pScreen, CARD16 width, CARD16 height,
CARD32 mmWidth, CARD32 mmHeight)
{
int result;
- rrScrPrivPtr pRandRScrPriv;
UpdateCurrentTime();
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GC.c b/nx-X11/programs/Xserver/hw/nxagent/GC.c
index 808220346..7450c1e6c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GC.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GC.c
@@ -633,11 +633,11 @@ void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
case CT_YXSORTED:
case CT_YXBANDED:
{
- RegionPtr pReg = RECTS_TO_REGION(pGC->pScreen, nRects, (xRectangle *)pValue, type);
+ RegionPtr pReg = RegionFromRects(nRects, (xRectangle *)pValue, type);
clipsMatch = nxagentCompareRegions(pGC -> clientClip, pReg);
- REGION_DESTROY(pGC->pScreen, pReg);
+ RegionDestroy(pReg);
break;
}
@@ -671,10 +671,10 @@ void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
{
if (clipsMatch == 0 && nxagentGCTrap == 0)
{
- nRects = REGION_NUM_RECTS((RegionPtr)pValue);
+ nRects = RegionNumRects((RegionPtr)pValue);
size = nRects * sizeof(*pRects);
pRects = (XRectangle *) xalloc(size);
- pBox = REGION_RECTS((RegionPtr)pValue);
+ pBox = RegionRects((RegionPtr)pValue);
for (i = nRects; i-- > 0;)
{
@@ -768,7 +768,7 @@ void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
* CT_REGION client clips.
*/
- pGC->clientClip = (void *) RECTS_TO_REGION(pGC->pScreen, nRects,
+ pGC->clientClip = (void *) RegionFromRects(nRects,
(xRectangle *)pValue, type);
xfree(pValue);
@@ -820,7 +820,7 @@ void nxagentDestroyClipHelper(GCPtr pGC)
case CT_NONE:
break;
case CT_REGION:
- REGION_DESTROY(pGC->pScreen, pGC->clientClip);
+ RegionDestroy(pGC->clientClip);
break;
case CT_PIXMAP:
nxagentDestroyPixmap((PixmapPtr)pGC->clientClip);
@@ -848,8 +848,8 @@ void nxagentCopyClip(GCPtr pGCDst, GCPtr pGCSrc)
case CT_REGION:
if (nxagentGCPriv(pGCSrc)->pPixmap == NULL)
{
- pRgn = REGION_CREATE(pGCDst->pScreen, NULL, 1);
- REGION_COPY(pGCDst->pScreen, pRgn, pGCSrc->clientClip);
+ pRgn = RegionCreate(NULL, 1);
+ RegionCopy(pRgn, pGCSrc->clientClip);
nxagentChangeClip(pGCDst, CT_REGION, pRgn, 0);
}
else
@@ -1151,12 +1151,9 @@ static void nxagentReconnectGC(void *param0, XID param1, void * param2)
Bool nxagentReconnectAllGCs(void *p0)
{
- int flexibility;
int cid;
Bool GCSuccess = True;
- flexibility = *(int*)p0;
-
#ifdef DEBUG
fprintf(stderr, "nxagentReconnectAllGCs\n");
#endif
@@ -1281,10 +1278,10 @@ static void nxagentReconnectClip(GCPtr pGC, int type, void * pValue, int nRects)
case CT_REGION:
if (nxagentGCPriv(pGC)->pPixmap == NULL)
{
- nRects = REGION_NUM_RECTS((RegionPtr)pValue);
+ nRects = RegionNumRects((RegionPtr)pValue);
size = nRects * sizeof(*pRects);
pRects = (XRectangle *) xalloc(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;
@@ -1370,7 +1367,7 @@ static void nxagentReconnectClip(GCPtr pGC, int type, void * pValue, int nRects)
* CT_PIXMAP and CT_REGION client clips.
*/
- pGC->clientClip = (void *) RECTS_TO_REGION(pGC->pScreen, nRects,
+ pGC->clientClip = (void *) RegionFromRects(nRects,
(xRectangle *)pValue, type);
xfree(pValue);
pValue = pGC->clientClip;
@@ -1403,26 +1400,26 @@ static int nxagentCompareRegions(RegionPtr r1, RegionPtr r2)
return 0;
}
- if (REGION_NUM_RECTS(r1) != REGION_NUM_RECTS(r2))
+ if (RegionNumRects(r1) != RegionNumRects(r2))
{
return 0;
}
- else if (REGION_NUM_RECTS(r1) == 0)
+ else if (RegionNumRects(r1) == 0)
{
return 1;
}
- else if ((*REGION_EXTENTS(pScreen, r1)).x1 != (*REGION_EXTENTS(pScreen, r2)).x1) return 0;
- else if ((*REGION_EXTENTS(pScreen, r1)).x2 != (*REGION_EXTENTS(pScreen, r2)).x2) return 0;
- else if ((*REGION_EXTENTS(pScreen, r1)).y1 != (*REGION_EXTENTS(pScreen, r2)).y1) return 0;
- else if ((*REGION_EXTENTS(pScreen, r1)).y2 != (*REGION_EXTENTS(pScreen, r2)).y2) return 0;
+ else if ((*RegionExtents(r1)).x1 != (*RegionExtents(r2)).x1) return 0;
+ else if ((*RegionExtents(r1)).x2 != (*RegionExtents(r2)).x2) return 0;
+ else if ((*RegionExtents(r1)).y1 != (*RegionExtents(r2)).y1) return 0;
+ else if ((*RegionExtents(r1)).y2 != (*RegionExtents(r2)).y2) return 0;
else
{
- for (i = 0; i < REGION_NUM_RECTS(r1); i++)
+ for (i = 0; i < RegionNumRects(r1); i++)
{
- if (REGION_RECTS(r1)[i].x1 != REGION_RECTS(r2)[i].x1) return 0;
- else if (REGION_RECTS(r1)[i].x2 != REGION_RECTS(r2)[i].x2) return 0;
- else if (REGION_RECTS(r1)[i].y1 != REGION_RECTS(r2)[i].y1) return 0;
- else if (REGION_RECTS(r1)[i].y2 != REGION_RECTS(r2)[i].y2) return 0;
+ if (RegionRects(r1)[i].x1 != RegionRects(r2)[i].x1) return 0;
+ else if (RegionRects(r1)[i].x2 != RegionRects(r2)[i].x2) return 0;
+ else if (RegionRects(r1)[i].y1 != RegionRects(r2)[i].y1) return 0;
+ else if (RegionRects(r1)[i].y2 != RegionRects(r2)[i].y2) return 0;
}
}
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
index 25f5fa6d7..5f753ffe4 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
@@ -306,12 +306,12 @@ FIXME: The popup could be synchronized with one
pSrcRegion -> extents.x2, pSrcRegion -> extents.y2);
#endif
- REGION_INIT(pSrcDrawable -> pScreen, &corruptedRegion, NullBox, 1);
+ RegionInit(&corruptedRegion, NullBox, 1);
- REGION_INTERSECT(pSrcDrawable -> pScreen, &corruptedRegion,
+ RegionIntersect(&corruptedRegion,
pSrcRegion, nxagentCorruptedRegion(pSrcDrawable));
- if (REGION_NIL(&corruptedRegion) == 0)
+ if (RegionNil(&corruptedRegion) == 0)
{
#ifdef TEST
fprintf(stderr, "nxagentDeferCopyArea: Forcing the synchronization of source drawable at [%p].\n",
@@ -321,7 +321,7 @@ FIXME: The popup could be synchronized with one
nxagentSynchronizeRegion(pSrcDrawable, &corruptedRegion, EVENT_BREAK, NULL);
}
- REGION_UNINIT(pSrcDrawable -> pScreen, &corruptedRegion);
+ RegionUninit(&corruptedRegion);
nxagentFreeRegion(pSrcDrawable, pSrcRegion);
@@ -361,7 +361,7 @@ FIXME: The popup could be synchronized with one
pClipRegion -> extents.x2, pClipRegion -> extents.y2);
#endif
- REGION_SUBTRACT(pSrcDrawable -> pScreen, pClipRegion, pClipRegion, nxagentCorruptedRegion(pSrcDrawable));
+ RegionSubtract(pClipRegion, pClipRegion, nxagentCorruptedRegion(pSrcDrawable));
#ifdef DEBUG
fprintf(stderr, "nxagentDeferCopyArea: Usable copy area source region is [%d,%d,%d,%d].\n",
@@ -381,11 +381,11 @@ FIXME: The popup could be synchronized with one
#endif
- REGION_TRANSLATE(pSrcDrawable -> pScreen, pClipRegion, dstx - srcx, dsty - srcy);
+ RegionTranslate(pClipRegion, dstx - srcx, dsty - srcy);
}
else
{
- REGION_INIT(pDstDrawable -> pScreen, &tmpRegion, NullBox, 1);
+ RegionInit(&tmpRegion, NullBox, 1);
#ifdef DEBUG
fprintf(stderr, "nxagentDeferCopyArea: Going to modify the original GC [%p] with clip mask "
@@ -396,18 +396,18 @@ FIXME: The popup could be synchronized with one
pGC -> clipOrg.x, pGC -> clipOrg.y);
#endif
- REGION_COPY(pDstDrawable -> pScreen, &tmpRegion, (RegionPtr) pGC -> clientClip);
+ RegionCopy(&tmpRegion, (RegionPtr) pGC -> clientClip);
if (pGC -> clipOrg.x != 0 || pGC -> clipOrg.y != 0)
{
- REGION_TRANSLATE(pDstDrawable -> pScreen, &tmpRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
+ RegionTranslate(&tmpRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
}
- REGION_TRANSLATE(pSrcDrawable -> pScreen, pClipRegion, dstx - srcx, dsty - srcy);
+ RegionTranslate(pClipRegion, dstx - srcx, dsty - srcy);
- REGION_INTERSECT(pSrcDrawable -> pScreen, pClipRegion, &tmpRegion, pClipRegion);
+ RegionIntersect(pClipRegion, &tmpRegion, pClipRegion);
- REGION_UNINIT(pSrcDrawable -> pScreen, &tmpRegion);
+ RegionUninit(&tmpRegion);
}
/*
@@ -416,18 +416,18 @@ FIXME: The popup could be synchronized with one
* destination that we are not going to copy.
*/
- REGION_SUBTRACT(pSrcDrawable -> pScreen, pCorruptedRegion, pCorruptedRegion, pClipRegion);
+ RegionSubtract(pCorruptedRegion, pCorruptedRegion, pClipRegion);
#ifdef DEBUG
fprintf(stderr, "nxagentDeferCopyArea: Recomputed clip region is [%d,%d,%d,%d][%ld].\n",
pClipRegion -> extents.x1, pClipRegion -> extents.y1,
pClipRegion -> extents.x2, pClipRegion -> extents.y2,
- REGION_NUM_RECTS(pClipRegion));
+ RegionNumRects(pClipRegion));
fprintf(stderr, "nxagentDeferCopyArea: Inherited corrupted region is [%d,%d,%d,%d][%ld].\n",
pCorruptedRegion -> extents.x1, pCorruptedRegion -> extents.y1,
pCorruptedRegion -> extents.x2, pCorruptedRegion -> extents.y2,
- REGION_NUM_RECTS(pCorruptedRegion));
+ RegionNumRects(pCorruptedRegion));
#endif
/*
@@ -435,17 +435,17 @@ FIXME: The popup could be synchronized with one
* synchronized and the corrupted region.
*/
- if (REGION_NIL(pClipRegion) == 0)
+ if (RegionNil(pClipRegion) == 0)
{
nxagentUnmarkCorruptedRegion(pDstDrawable, pClipRegion);
}
- if (REGION_NIL(pCorruptedRegion) == 0)
+ if (RegionNil(pCorruptedRegion) == 0)
{
nxagentMarkCorruptedRegion(pDstDrawable, pCorruptedRegion);
}
- if (REGION_NIL(pClipRegion) == 0)
+ if (RegionNil(pClipRegion) == 0)
{
GCPtr targetGC;
@@ -468,7 +468,7 @@ FIXME: The popup could be synchronized with one
GCClipXOrigin | GCClipYOrigin | GCClipMask | GCForeground |
GCBackground | GCGraphicsExposures);
- if (REGION_NUM_RECTS(pClipRegion) == 1)
+ if (RegionNumRects(pClipRegion) == 1)
{
/*
* If the region to copy is formed by one
@@ -563,12 +563,12 @@ FIXME: The popup could be synchronized with one
pSrcRegion -> extents.x2, pSrcRegion -> extents.y2);
#endif
- REGION_INIT(pSrcDrawable -> pScreen, &corruptedRegion, NullBox, 1);
+ RegionInit(&corruptedRegion, NullBox, 1);
- REGION_INTERSECT(pSrcDrawable -> pScreen, &corruptedRegion,
+ RegionIntersect(&corruptedRegion,
pSrcRegion, nxagentCorruptedRegion(pSrcDrawable));
- if (REGION_NIL(&corruptedRegion) == 0)
+ if (RegionNil(&corruptedRegion) == 0)
{
#ifdef TEST
fprintf(stderr, "nxagentDeferCopyArea: Forcing the synchronization of source drawable at [%p].\n",
@@ -578,7 +578,7 @@ FIXME: The popup could be synchronized with one
nxagentSynchronizeRegion(pSrcDrawable, &corruptedRegion /*pSrcRegion*/, NEVER_BREAK, NULL);
}
- REGION_UNINIT(pSrcDrawable -> pScreen, &corruptedRegion);
+ RegionUninit(&corruptedRegion);
nxagentFreeRegion(pSrcDrawable, pSrcRegion);
}
@@ -594,8 +594,6 @@ RegionPtr nxagentCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
unsigned int format;
unsigned long planeMask = 0xffffffff;
- int oldDstxyValue;
-
RegionPtr pDstRegion;
int skip = 0;
@@ -651,8 +649,6 @@ RegionPtr nxagentCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
}
}
- oldDstxyValue = dsty;
-
if (dsty + pDstDrawable->y + height > 32767)
{
#ifdef WARNING
@@ -1032,12 +1028,12 @@ RegionPtr nxagentCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
{
pSrcRegion = nxagentCreateRegion(pSrcDrawable, NULL, srcx, srcy, width, height);
- REGION_INIT(pSrcDrawable -> pScreen, &corruptedRegion, NullBox, 1);
+ RegionInit(&corruptedRegion, NullBox, 1);
- REGION_INTERSECT(pSrcDrawable -> pScreen, &corruptedRegion,
+ RegionIntersect(&corruptedRegion,
pSrcRegion, nxagentCorruptedRegion(pSrcDrawable));
- if (REGION_NIL(&corruptedRegion) == 0)
+ if (RegionNil(&corruptedRegion) == 0)
{
#ifdef TEST
fprintf(stderr, "nxagentCopyPlane: Forcing the synchronization of source drawable at [%p].\n",
@@ -1053,7 +1049,7 @@ RegionPtr nxagentCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
nxagentFreeRegion(pDstDrawable, pDstRegion);
}
- REGION_UNINIT(pSrcDrawable -> pScreen, &corruptedRegion);
+ RegionUninit(&corruptedRegion);
nxagentFreeRegion(pSrcDrawable, pSrcRegion);
}
@@ -1615,24 +1611,24 @@ void nxagentPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
if (inheritCorruptedRegion == 1 || nxagentDrawableStatus(pDrawable) == NotSynchronized)
{
- rectRegion = RECTS_TO_REGION(pDrawable -> pScreen, nRectangles, pRectangles, CT_REGION);
+ rectRegion = RegionFromRects(nRectangles, pRectangles, CT_REGION);
if (pGC -> clientClip != NULL)
{
RegionRec tmpRegion;
- REGION_INIT(pDrawable -> pScreen, &tmpRegion, NullBox, 1);
+ RegionInit(&tmpRegion, NullBox, 1);
- REGION_COPY(pDrawable -> pScreen, &tmpRegion, ((RegionPtr) pGC -> clientClip));
+ RegionCopy(&tmpRegion, ((RegionPtr) pGC -> clientClip));
if (pGC -> clipOrg.x != 0 || pGC -> clipOrg.y != 0)
{
- REGION_TRANSLATE(pDrawable -> pScreen, &tmpRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
+ RegionTranslate(&tmpRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
}
- REGION_INTERSECT(pDrawable -> pScreen, rectRegion, rectRegion, &tmpRegion);
+ RegionIntersect(rectRegion, rectRegion, &tmpRegion);
- REGION_UNINIT(pDrawable -> pScreen, &tmpRegion);
+ RegionUninit(&tmpRegion);
}
if (inheritCorruptedRegion == 1)
@@ -1672,7 +1668,7 @@ void nxagentPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
}
}
- REGION_DESTROY(pDrawable -> pScreen, rectRegion);
+ RegionDestroy(rectRegion);
}
if ((pDrawable)->type == DRAWABLE_PIXMAP)
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Handlers.c b/nx-X11/programs/Xserver/hw/nxagent/Handlers.c
index 0396a458e..aee983253 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Handlers.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Handlers.c
@@ -729,7 +729,6 @@ void nxagentShadowBlockHandler(void * data, struct timeval **timeout, void * mas
int changed;
int suspended = 0;
- int result;
int width_, height_;
#ifdef BLOCKS
@@ -796,7 +795,7 @@ void nxagentShadowBlockHandler(void * data, struct timeval **timeout, void * mas
nxagentShadowPoll(nxagentShadowPixmapPtr, nxagentShadowGCPtr, nxagentShadowDepth, nxagentShadowWidth,
nxagentShadowHeight, nxagentShadowBuffer, &changed, &suspended);
- result = nxagentShadowSendUpdates(&suspended);
+ nxagentShadowSendUpdates(&suspended);
if (nxagentBlocking == 0)
{
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Holder.c b/nx-X11/programs/Xserver/hw/nxagent/Holder.c
index 64ffb24a4..db43acafc 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Holder.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Holder.c
@@ -23,6 +23,7 @@
#include "scrnintstr.h"
#include "Agent.h"
#define GC XlibGC
+#define Pixmap XlibPixmap
#define PIXEL_ALREADY_TYPEDEFED
#endif /* _XSERVER64 */
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Image.c b/nx-X11/programs/Xserver/hw/nxagent/Image.c
index 1f0b735b0..c84d3b7ed 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Image.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Image.c
@@ -566,7 +566,7 @@ void nxagentPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
pRegion = nxagentCreateRegion(pDrawable, pGC, dstX, dstY, dstWidth, dstHeight);
- if (REGION_NIL(pRegion) == 1)
+ if (RegionNil(pRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentPutImage: WARNING! Prevented operation on fully clipped "
@@ -1036,7 +1036,7 @@ void nxagentRealizeImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
clipRegion = nxagentCreateRegion(pDrawable, pGC, x, y, w, h);
}
- if (clipRegion == NullRegion || REGION_NIL(clipRegion) == 0)
+ if (clipRegion == NullRegion || RegionNil(clipRegion) == 0)
{
nxagentPutSubImage(pDrawable, pGC, depth, x, y, w, h,
leftPad, format, data, pVisual);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Imakefile b/nx-X11/programs/Xserver/hw/nxagent/Imakefile
index 160d01e60..b0aff4b07 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Imakefile
+++ b/nx-X11/programs/Xserver/hw/nxagent/Imakefile
@@ -141,7 +141,8 @@ INCLUDES = -I. -I../../../../../nxcomp -I../../../../../nxcompext -I../../../../
-I../../GL/glx -I../../GL/include -I../../../../lib/GL/include -I../../Xext \
-I$(EXTINCSRC) -I$(XINCLUDESRC) \
$(VFBINCLUDES) \
- `pkg-config --cflags-only-I libxml-2.0`
+ `pkg-config --cflags-only-I libxml-2.0` \
+ `pkg-config --cflags-only-I pixman-1`
#ifdef SunArchitecture
INCLUDES = -I. -I../../../../../nxcomp -I../../../../../nxcompext -I../../../../../nxcompshad \
-I../../../../extras/Mesa/include \
@@ -153,6 +154,7 @@ INCLUDES = -I. -I../../../../../nxcomp -I../../../../../nxcompext -I../../../../
-I$(EXTINCSRC) -I$(XINCLUDESRC) \
$(VFBINCLUDES) \
`pkg-config --cflags-only-I libxml-2.0`
+ `pkg-config --cflags-only-I pixman-1`
#else
#ifdef cygwinArchitecture
INCLUDES = -I. -I$(XBUILDINCDIR) \
@@ -164,6 +166,7 @@ INCLUDES = -I. -I$(XBUILDINCDIR) \
-I$(EXTINCSRC) -I$(XINCLUDESRC) \
$(VFBINCLUDES) \
`pkg-config --cflags-only-I libxml-2.0`
+ `pkg-config --cflags-only-I pixman-1`
#endif
#endif
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
index 9ead48de1..8d1fbd4c1 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
@@ -685,7 +685,9 @@ int nxagentKeyboardProc(DeviceIntPtr pDev, int onoff)
int free_model = 0, free_layout = 0;
XkbDescPtr xkb = NULL;
+ #ifdef TEST
int ret;
+ #endif
switch (onoff)
{
@@ -842,7 +844,10 @@ XkbError:
memmove((char *) defaultKeyboardControl.autoRepeats,
(char *) values.auto_repeats, sizeof(values.auto_repeats));
- ret = InitKeyboardDeviceStruct((DevicePtr) pDev, &keySyms, modmap,
+ #ifdef TEST
+ ret =
+ #endif
+ InitKeyboardDeviceStruct((DevicePtr) pDev, &keySyms, modmap,
nxagentBell, nxagentChangeKeyboardControl);
#ifdef TEST
@@ -1208,11 +1213,9 @@ void nxagentNotifyKeyboardChanges(int oldMinKeycode, int oldMaxKeycode)
if (!noXkbExtension)
{
DeviceIntPtr dev;
- XkbDescPtr xkb;
xkbNewKeyboardNotify nkn;
dev = inputInfo.keyboard;
- xkb = dev -> key -> xkbInfo -> desc;
memset(&nkn, 0, sizeof(xkbNewKeyboardNotify));
nkn.deviceID = nkn.oldDeviceID = dev -> id;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Keystroke.c b/nx-X11/programs/Xserver/hw/nxagent/Keystroke.c
index 404ed035d..212fcd93c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Keystroke.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Keystroke.c
@@ -168,7 +168,7 @@ static int read_binding_from_xmlnode(xmlNode *node, struct nxagentSpecialKeystro
/* ignore attributes without data (which should never happen anyways) */
if (attr->children->content == NULL)
{
- char *aname = (attr->name)?(attr->name):"unknown";
+ char *aname = (attr->name)?((char *)attr->name):"unknown";
fprintf(stderr, "attribute %s with NULL value", aname);
continue;
}
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c b/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c
index d18840dad..278e0727c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c
@@ -154,7 +154,7 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
#endif
/* short circuit for empty regions */
- if (!REGION_NOTEMPTY(pScreen, pRegion))
+ if (!RegionNotEmpty(pRegion))
return;
#ifdef COMPOSITE
@@ -169,7 +169,7 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
screen_y = ((PixmapPtr) pDrawable)->screen_y - pDrawable->y;
}
if (screen_x || screen_y)
- REGION_TRANSLATE (pScreen, pRegion, screen_x, screen_y);
+ RegionTranslate(pRegion, screen_x, screen_y);
#endif
if (pDrawable->type == DRAWABLE_WINDOW &&
@@ -177,22 +177,22 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
{
if (subWindowMode == ClipByChildren)
{
- REGION_INTERSECT(pScreen, pRegion, pRegion,
+ RegionIntersect(pRegion, pRegion,
&((WindowPtr)(pDrawable))->clipList);
}
else if (subWindowMode == IncludeInferiors)
{
RegionPtr pTempRegion =
NotClippedByChildren((WindowPtr)(pDrawable));
- REGION_INTERSECT(pScreen, pRegion, pRegion, pTempRegion);
- REGION_DESTROY(pScreen, pTempRegion);
+ RegionIntersect(pRegion, pRegion, pTempRegion);
+ RegionDestroy(pTempRegion);
}
/* If subWindowMode is set to an invalid value, don't perform
* any drawable-based clipping. */
}
- REGION_NULL (pScreen, &clippedRec);
+ RegionNull(&clippedRec);
for (; pDamage; pDamage = pNext)
{
pNext = pDamage->pNext;
@@ -240,7 +240,7 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
{
pDamageRegion = &clippedRec;
if (pDamage->pDrawable->type == DRAWABLE_WINDOW) {
- REGION_INTERSECT (pScreen, pDamageRegion, pRegion,
+ RegionIntersect(pDamageRegion, pRegion,
&((WindowPtr)(pDamage->pDrawable))->borderClip);
} else {
BoxRec box;
@@ -248,14 +248,14 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
box.y1 = draw_y;
box.x2 = draw_x + pDamage->pDrawable->width;
box.y2 = draw_y + pDamage->pDrawable->height;
- REGION_INIT(pScreen, &pixClip, &box, 1);
- REGION_INTERSECT (pScreen, pDamageRegion, pRegion, &pixClip);
- REGION_UNINIT(pScreen, &pixClip);
+ RegionInit(&pixClip, &box, 1);
+ RegionIntersect(pDamageRegion, pRegion, &pixClip);
+ RegionUninit(&pixClip);
}
/*
* Short circuit empty results
*/
- if (!REGION_NOTEMPTY(pScreen, pDamageRegion))
+ if (!RegionNotEmpty(pDamageRegion))
continue;
}
@@ -270,39 +270,39 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
* Move region to target coordinate space
*/
if (draw_x || draw_y)
- REGION_TRANSLATE (pScreen, pDamageRegion, -draw_x, -draw_y);
+ RegionTranslate(pDamageRegion, -draw_x, -draw_y);
switch (pDamage->damageLevel) {
case DamageReportRawRegion:
(*pDamage->damageReport) (pDamage, pDamageRegion, pDamage->closure);
break;
case DamageReportDeltaRegion:
- REGION_NULL (pScreen, &tmpRegion);
- REGION_SUBTRACT (pScreen, &tmpRegion, pDamageRegion, &pDamage->damage);
- if (REGION_NOTEMPTY (pScreen, &tmpRegion))
+ RegionNull(&tmpRegion);
+ RegionSubtract(&tmpRegion, pDamageRegion, &pDamage->damage);
+ if (RegionNotEmpty(&tmpRegion))
{
- REGION_UNION(pScreen, &pDamage->damage,
+ RegionUnion(&pDamage->damage,
&pDamage->damage, pDamageRegion);
(*pDamage->damageReport) (pDamage, &tmpRegion, pDamage->closure);
}
- REGION_UNINIT(pScreen, &tmpRegion);
+ RegionUninit(&tmpRegion);
break;
case DamageReportBoundingBox:
- tmpBox = *REGION_EXTENTS (pScreen, &pDamage->damage);
- REGION_UNION(pScreen, &pDamage->damage,
+ tmpBox = *RegionExtents(&pDamage->damage);
+ RegionUnion(&pDamage->damage,
&pDamage->damage, pDamageRegion);
- if (!BOX_SAME (&tmpBox, REGION_EXTENTS (pScreen, &pDamage->damage)))
+ if (!BOX_SAME (&tmpBox, RegionExtents(&pDamage->damage)))
(*pDamage->damageReport) (pDamage, &pDamage->damage, pDamage->closure);
break;
case DamageReportNonEmpty:
- was_empty = !REGION_NOTEMPTY(pScreen, &pDamage->damage);
- REGION_UNION(pScreen, &pDamage->damage, &pDamage->damage,
+ was_empty = !RegionNotEmpty(&pDamage->damage);
+ RegionUnion(&pDamage->damage, &pDamage->damage,
pDamageRegion);
- if (was_empty && REGION_NOTEMPTY(pScreen, &pDamage->damage))
+ if (was_empty && RegionNotEmpty(&pDamage->damage))
(*pDamage->damageReport) (pDamage, &pDamage->damage, pDamage->closure);
break;
case DamageReportNone:
- REGION_UNION(pScreen, &pDamage->damage, &pDamage->damage,
+ RegionUnion(&pDamage->damage, &pDamage->damage,
pDamageRegion);
break;
}
@@ -310,14 +310,14 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
* translate original region back
*/
if (pDamageRegion == pRegion && (draw_x || draw_y))
- REGION_TRANSLATE (pScreen, pDamageRegion, draw_x, draw_y);
+ RegionTranslate(pDamageRegion, draw_x, draw_y);
}
#ifdef COMPOSITE
if (screen_x || screen_y)
- REGION_TRANSLATE (pScreen, pRegion, -screen_x, -screen_y);
+ RegionTranslate(pRegion, -screen_x, -screen_y);
#endif
- REGION_UNINIT (pScreen, &clippedRec);
+ RegionUninit(&clippedRec);
}
#if DAMAGE_DEBUG_ENABLE
@@ -331,13 +331,13 @@ damageDamageBox (DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode)
{
RegionRec region;
- REGION_INIT (pDrawable->pScreen, &region, pBox, 1);
+ RegionInit(&region, pBox, 1);
#if DAMAGE_DEBUG_ENABLE
_damageDamageRegion (pDrawable, &region, TRUE, subWindowMode, where);
#else
damageDamageRegion (pDrawable, &region, TRUE, subWindowMode);
#endif
- REGION_UNINIT (pDrawable->pScreen, &region);
+ RegionUninit(&region);
}
static void damageValidateGC(GCPtr, unsigned long, DrawablePtr);
@@ -506,7 +506,7 @@ damageDestroyClip(GCPtr pGC)
#define checkGCDamage(d,g) (getDrawableDamage(d) && \
(!g->pCompositeClip ||\
- REGION_NOTEMPTY(d->pScreen, \
+ RegionNotEmpty(\
g->pCompositeClip)))
#ifdef RENDER
@@ -520,7 +520,7 @@ damageDestroyClip(GCPtr pGC)
}
#define checkPictureDamage(p) (getDrawableDamage(p->pDrawable) && \
- REGION_NOTEMPTY(pScreen, p->pCompositeClip))
+ RegionNotEmpty(p->pCompositeClip))
static void
damageComposite (CARD8 op,
@@ -1722,9 +1722,9 @@ damageCopyWindow(WindowPtr pWindow,
* The region comes in source relative, but the damage occurs
* at the destination location. Translate back and forth.
*/
- REGION_TRANSLATE (pScreen, prgnSrc, dx, dy);
+ RegionTranslate(prgnSrc, dx, dy);
damageDamageRegion (&pWindow->drawable, prgnSrc, FALSE, -1);
- REGION_TRANSLATE (pScreen, prgnSrc, -dx, -dy);
+ RegionTranslate(prgnSrc, -dx, -dy);
}
unwrap (pScrPriv, pScreen, CopyWindow);
(*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc);
@@ -1927,7 +1927,7 @@ DamageCreate (DamageReportFunc damageReport,
return 0;
pDamage->pNext = 0;
pDamage->pNextWin = 0;
- REGION_NULL(pScreen, &pDamage->damage);
+ RegionNull(&pDamage->damage);
pDamage->damageLevel = damageLevel;
pDamage->isInternal = isInternal;
@@ -2016,7 +2016,7 @@ DamageDestroy (DamagePtr pDamage)
{
if (pDamage->damageDestroy)
(*pDamage->damageDestroy) (pDamage, pDamage->closure);
- REGION_UNINIT (pDamage->pDrawable->pScreen, &pDamage->damage);
+ RegionUninit(&pDamage->damage);
xfree (pDamage);
}
@@ -2028,7 +2028,7 @@ DamageSubtract (DamagePtr pDamage,
RegionRec pixmapClip;
DrawablePtr pDrawable = pDamage->pDrawable;
- REGION_SUBTRACT (pDrawable->pScreen, &pDamage->damage, &pDamage->damage, pRegion);
+ RegionSubtract(&pDamage->damage, &pDamage->damage, pRegion);
if (pDrawable)
{
if (pDrawable->type == DRAWABLE_WINDOW)
@@ -2041,22 +2041,22 @@ DamageSubtract (DamagePtr pDamage,
box.y1 = pDrawable->y;
box.x2 = pDrawable->x + pDrawable->width;
box.y2 = pDrawable->y + pDrawable->height;
- REGION_INIT (pDrawable->pScreen, &pixmapClip, &box, 1);
+ RegionInit(&pixmapClip, &box, 1);
pClip = &pixmapClip;
}
- REGION_TRANSLATE (pDrawable->pScreen, &pDamage->damage, pDrawable->x, pDrawable->y);
- REGION_INTERSECT (pDrawable->pScreen, &pDamage->damage, &pDamage->damage, pClip);
- REGION_TRANSLATE (pDrawable->pScreen, &pDamage->damage, -pDrawable->x, -pDrawable->y);
+ RegionTranslate(&pDamage->damage, pDrawable->x, pDrawable->y);
+ RegionIntersect(&pDamage->damage, &pDamage->damage, pClip);
+ RegionTranslate(&pDamage->damage, -pDrawable->x, -pDrawable->y);
if (pDrawable->type != DRAWABLE_WINDOW)
- REGION_UNINIT(pDrawable->pScreen, &pixmapClip);
+ RegionUninit(&pixmapClip);
}
- return REGION_NOTEMPTY (pDrawable->pScreen, &pDamage->damage);
+ return RegionNotEmpty(&pDamage->damage);
}
void
DamageEmpty (DamagePtr pDamage)
{
- REGION_EMPTY (pDamage->pDrawable->pScreen, &pDamage->damage);
+ RegionEmpty(&pDamage->damage);
}
RegionPtr
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
index 704bfcc0d..6a1f2ac6a 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
@@ -1669,11 +1669,11 @@ ProcTranslateCoords(register ClientPtr client)
* borderSize
*/
&& (!wBoundingShape(pWin) ||
- POINT_IN_REGION(pWin->drawable.pScreen,
+ RegionContainsPoint(
&pWin->borderSize, x, y, &box))
&& (!wInputShape(pWin) ||
- POINT_IN_REGION(pWin->drawable.pScreen,
+ RegionContainsPoint(
wInputShape(pWin),
x - pWin->drawable.x,
y - pWin->drawable.y, &box))
@@ -2291,7 +2291,7 @@ ProcCopyArea(register ClientPtr client)
(*pDst->pScreen->SendGraphicsExpose)
(client, pRgn, stuff->dstDrawable, X_CopyArea, 0);
if (pRgn)
- REGION_DESTROY(pDst->pScreen, pRgn);
+ RegionDestroy(pRgn);
}
return(client->noClientException);
@@ -2339,7 +2339,7 @@ ProcCopyPlane(register ClientPtr client)
(*pdstDraw->pScreen->SendGraphicsExpose)
(client, pRgn, stuff->dstDrawable, X_CopyPlane, 0);
if (pRgn)
- REGION_DESTROY(pdstDraw->pScreen, pRgn);
+ RegionDestroy(pRgn);
}
return(client->noClientException);
}
@@ -2777,7 +2777,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
pVisibleRegion = NotClippedByChildren((WindowPtr)pDraw);
if (pVisibleRegion)
{
- REGION_TRANSLATE(pDraw->pScreen, pVisibleRegion, -pDraw->x, -pDraw->y);
+ RegionTranslate(pVisibleRegion, -pDraw->x, -pDraw->y);
}
}
#endif
@@ -2871,7 +2871,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
}
#ifdef XCSECURITY
if (pVisibleRegion)
- REGION_DESTROY(pDraw->pScreen, pVisibleRegion);
+ RegionDestroy(pVisibleRegion);
#endif
if (!im_return)
DEALLOCATE_LOCAL(pBuf);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
index 2f3a75147..33b0ea93d 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
@@ -73,7 +73,6 @@ Equipment Corporation.
#include <dix-config.h>
#endif
-#include <X11/fonts/fontstruct.h>
#include <nx-X11/X.h>
#include <nx-X11/Xmd.h>
#include <nx-X11/Xproto.h>
@@ -177,6 +176,8 @@ _NXGetFontPathError:
#define QUERYCHARINFO(pci, pr) *(pr) = (pci)->metrics
+extern void register_fpe_functions(void);
+
extern void * fosNaturalParams;
extern FontPtr defaultFont;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
index 11ff62947..f871cad13 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
@@ -379,14 +379,14 @@ XineramaSetCursorPosition(
x += panoramiXdataPtr[0].x;
y += panoramiXdataPtr[0].y;
- if(!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
+ if(!RegionContainsPoint(&XineramaScreenRegions[pScreen->myNum],
x, y, &box))
{
FOR_NSCREENS(i)
{
if(i == pScreen->myNum)
continue;
- if(POINT_IN_REGION(pScreen, &XineramaScreenRegions[i], x, y, &box))
+ if(RegionContainsPoint(&XineramaScreenRegions[i], x, y, &box))
{
pScreen = screenInfo.screens[i];
break;
@@ -516,7 +516,7 @@ XineramaCheckVirtualMotion(
i = PanoramiXNumScreens - 1;
- REGION_COPY(sprite.screen, &sprite.Reg2,
+ RegionCopy(&sprite.Reg2,
&sprite.windows[i]->borderSize);
off_x = panoramiXdataPtr[i].x;
off_y = panoramiXdataPtr[i].y;
@@ -526,16 +526,16 @@ XineramaCheckVirtualMotion(
y = off_y - panoramiXdataPtr[i].y;
if(x || y)
- REGION_TRANSLATE(sprite.screen, &sprite.Reg2, x, y);
+ RegionTranslate(&sprite.Reg2, x, y);
- REGION_UNION(sprite.screen, &sprite.Reg2, &sprite.Reg2,
+ RegionUnion(&sprite.Reg2, &sprite.Reg2,
&sprite.windows[i]->borderSize);
off_x = panoramiXdataPtr[i].x;
off_y = panoramiXdataPtr[i].y;
}
- lims = *REGION_EXTENTS(sprite.screen, &sprite.Reg2);
+ lims = *RegionExtents(&sprite.Reg2);
if (sprite.hot.x < lims.x1)
#ifdef XEVIE
@@ -558,7 +558,7 @@ XineramaCheckVirtualMotion(
#endif
sprite.hot.y = lims.y2 - 1;
- if (REGION_NUM_RECTS(&sprite.Reg2) > 1)
+ if (RegionNumRects(&sprite.Reg2) > 1)
ConfineToShape(&sprite.Reg2, &sprite.hot.x, &sprite.hot.y);
if (qe)
@@ -665,7 +665,7 @@ XineramaConfineCursorToWindow(WindowPtr pWin, Bool generateEvents)
i = PanoramiXNumScreens - 1;
- REGION_COPY(sprite.screen, &sprite.Reg1,
+ RegionCopy(&sprite.Reg1,
&sprite.windows[i]->borderSize);
off_x = panoramiXdataPtr[i].x;
off_y = panoramiXdataPtr[i].y;
@@ -675,18 +675,18 @@ XineramaConfineCursorToWindow(WindowPtr pWin, Bool generateEvents)
y = off_y - panoramiXdataPtr[i].y;
if(x || y)
- REGION_TRANSLATE(sprite.screen, &sprite.Reg1, x, y);
+ RegionTranslate(&sprite.Reg1, x, y);
- REGION_UNION(sprite.screen, &sprite.Reg1, &sprite.Reg1,
+ RegionUnion(&sprite.Reg1, &sprite.Reg1,
&sprite.windows[i]->borderSize);
off_x = panoramiXdataPtr[i].x;
off_y = panoramiXdataPtr[i].y;
}
- sprite.hotLimits = *REGION_EXTENTS(sprite.screen, &sprite.Reg1);
+ sprite.hotLimits = *RegionExtents(&sprite.Reg1);
- if(REGION_NUM_RECTS(&sprite.Reg1) > 1)
+ if(RegionNumRects(&sprite.Reg1) > 1)
sprite.hotShape = &sprite.Reg1;
else
sprite.hotShape = NullRegion;
@@ -765,9 +765,9 @@ ConfineToShape(RegionPtr shape, int *px, int *py)
int x = *px, y = *py;
int incx = 1, incy = 1;
- if (POINT_IN_REGION(sprite.hot.pScreen, shape, x, y, &box))
+ if (RegionContainsPoint(shape, x, y, &box))
return;
- box = *REGION_EXTENTS(sprite.hot.pScreen, shape);
+ box = *RegionExtents(shape);
/* this is rather crude */
do {
x += incx;
@@ -789,7 +789,7 @@ ConfineToShape(RegionPtr shape, int *px, int *py)
else if (y < box.y1)
return; /* should never get here! */
}
- } while (!POINT_IN_REGION(sprite.hot.pScreen, shape, x, y, &box));
+ } while (!RegionContainsPoint(shape, x, y, &box));
*px = x;
*py = y;
}
@@ -877,7 +877,7 @@ CheckVirtualMotion(
#endif
sprite.hot.x = sprite.hot.y = 0;
}
- lims = *REGION_EXTENTS(pWin->drawable.pScreen, &pWin->borderSize);
+ lims = *RegionExtents(&pWin->borderSize);
if (sprite.hot.x < lims.x1)
#ifdef XEVIE
xeviehot.x =
@@ -931,7 +931,7 @@ ConfineCursorToWindow(WindowPtr pWin, Bool generateEvents, Bool confineToScreen)
}
else
{
- sprite.hotLimits = *REGION_EXTENTS( pScreen, &pWin->borderSize);
+ sprite.hotLimits = *RegionExtents(&pWin->borderSize);
#ifdef SHAPE
sprite.hotShape = wBoundingShape(pWin) ? &pWin->borderSize
: NullRegion;
@@ -2117,7 +2117,7 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
{
BoxRec box;
- if(POINT_IN_REGION(pWin->drawable.pScreen, &pWin->borderSize, x, y, &box))
+ if(RegionContainsPoint(&pWin->borderSize, x, y, &box))
return TRUE;
#ifdef PANORAMIX
@@ -2125,7 +2125,7 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
int i;
for(i = 1; i < PanoramiXNumScreens; i++) {
- if(POINT_IN_REGION(sprite.screen,
+ if(RegionContainsPoint(
&sprite.windows[i]->borderSize,
x + panoramiXdataPtr[0].x - panoramiXdataPtr[i].x,
y + panoramiXdataPtr[0].y - panoramiXdataPtr[i].y,
@@ -2180,7 +2180,7 @@ XYToWindow(int x, int y)
*/
&& (!wBoundingShape(pWin) || PointInBorderSize(pWin, x, y))
&& (!wInputShape(pWin) ||
- POINT_IN_REGION(pWin->drawable.pScreen,
+ RegionContainsPoint(
wInputShape(pWin),
x - pWin->drawable.x,
y - pWin->drawable.y, &box))
@@ -2313,7 +2313,6 @@ WindowsRestructured()
* compute correctly. */
void ReinitializeRootWindow(WindowPtr win, int xoff, int yoff)
{
- ScreenPtr pScreen = win->drawable.pScreen;
GrabPtr grab;
if (noPanoramiXExtension) return;
@@ -2329,10 +2328,10 @@ void ReinitializeRootWindow(WindowPtr win, int xoff, int yoff)
sprite.hotLimits.x2 -= xoff;
sprite.hotLimits.y2 -= yoff;
- if (REGION_NOTEMPTY(sprite.screen, &sprite.Reg1))
- REGION_TRANSLATE(sprite.screen, &sprite.Reg1, xoff, yoff);
- if (REGION_NOTEMPTY(sprite.screen, &sprite.Reg2))
- REGION_TRANSLATE(sprite.screen, &sprite.Reg2, xoff, yoff);
+ if (RegionNotEmpty(&sprite.Reg1))
+ RegionTranslate(&sprite.Reg1, xoff, yoff);
+ if (RegionNotEmpty(&sprite.Reg2))
+ RegionTranslate(&sprite.Reg2, xoff, yoff);
/* FIXME: if we call ConfineCursorToWindow, must we do anything else? */
if ((grab = inputInfo.pointer->grab) && grab->confineTo) {
@@ -2388,8 +2387,8 @@ DefineInitialRootWindow(register WindowPtr win)
#endif
sprite.screen = pScreen;
/* gotta UNINIT these someplace */
- REGION_NULL(pScreen, &sprite.Reg1);
- REGION_NULL(pScreen, &sprite.Reg2);
+ RegionNull(&sprite.Reg1);
+ RegionNull(&sprite.Reg2);
}
#endif
@@ -2461,13 +2460,12 @@ XineramaPointInWindowIsVisible(
int y
)
{
- ScreenPtr pScreen = pWin->drawable.pScreen;
BoxRec box;
int i, xoff, yoff;
if (!pWin->realized) return FALSE;
- if (POINT_IN_REGION(pScreen, &pWin->borderClip, x, y, &box))
+ if (RegionContainsPoint(&pWin->borderClip, x, y, &box))
return TRUE;
if(!XineramaSetWindowPntrs(pWin)) return FALSE;
@@ -2477,13 +2475,12 @@ XineramaPointInWindowIsVisible(
for(i = 1; i < PanoramiXNumScreens; i++) {
pWin = sprite.windows[i];
- pScreen = pWin->drawable.pScreen;
x = xoff - panoramiXdataPtr[i].x;
y = yoff - panoramiXdataPtr[i].y;
- if(POINT_IN_REGION(pScreen, &pWin->borderClip, x, y, &box)
+ if(RegionContainsPoint(&pWin->borderClip, x, y, &box)
&& (!wInputShape(pWin) ||
- POINT_IN_REGION(pWin->drawable.pScreen,
+ RegionContainsPoint(
wInputShape(pWin),
x - pWin->drawable.x,
y - pWin->drawable.y, &box)))
@@ -2659,7 +2656,7 @@ ProcWarpPointer(ClientPtr client)
static Bool
BorderSizeNotEmpty(WindowPtr pWin)
{
- if(REGION_NOTEMPTY(sprite.hotPhys.pScreen, &pWin->borderSize))
+ if(RegionNotEmpty(&pWin->borderSize))
return TRUE;
#ifdef PANORAMIX
@@ -2667,7 +2664,7 @@ BorderSizeNotEmpty(WindowPtr pWin)
int i;
for(i = 1; i < PanoramiXNumScreens; i++) {
- if(REGION_NOTEMPTY(sprite.screen, &sprite.windows[i]->borderSize))
+ if(RegionNotEmpty(&sprite.windows[i]->borderSize))
return TRUE;
}
}
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c b/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
index 47db919ef..757ffff21 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
@@ -76,11 +76,7 @@
#endif
-#if HAVE_STDINT_H
#include <stdint.h>
-#elif !defined(UINT32_MAX)
-#define UINT32_MAX 0xffffffffU
-#endif
/*
* From Knuth -- a good choice for hash/rehash values is p, p-2 where
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c b/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
index 7a1d813b3..1696ae51f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
@@ -106,7 +106,6 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
PixmapPtr ppix;
long nby;
char *pbits;
- ChangeGCVal gcval[3];
unsigned char char2b[2];
/* turn glyph index into a protocol-format char2b */
@@ -165,7 +164,6 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
fbPolyFillRect((DrawablePtr)ppix, pGC, 1, &rect);
/* draw the glyph */
- gcval[0].val = 1;
pGC->fgPixel = 1;
pGC->stateChanges |= GCForeground;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
index aa3c606f8..ad75b43f8 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
@@ -222,21 +222,21 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
if (pGC->subWindowMode == IncludeInferiors)
{
prgnSrcClip = NotClippedByChildren (pSrcWin);
- if ((RECT_IN_REGION(pscr, prgnSrcClip, &TsrcBox)) == rgnIN)
+ if ((RegionContainsRect(prgnSrcClip, &TsrcBox)) == rgnIN)
{
- REGION_DESTROY(pscr, prgnSrcClip);
+ RegionDestroy(prgnSrcClip);
return NULL;
}
}
else
{
- if ((RECT_IN_REGION(pscr, &pSrcWin->clipList, &TsrcBox)) == rgnIN)
+ if ((RegionContainsRect(&pSrcWin->clipList, &TsrcBox)) == rgnIN)
return NULL;
prgnSrcClip = &rgnSrcRec;
- REGION_NULL(pscr, prgnSrcClip);
- REGION_COPY(pscr, prgnSrcClip, &pSrcWin->clipList);
+ RegionNull(prgnSrcClip);
+ RegionCopy(prgnSrcClip, &pSrcWin->clipList);
}
- REGION_TRANSLATE(pscr, prgnSrcClip,
+ RegionTranslate(prgnSrcClip,
-pSrcDrawable->x, -pSrcDrawable->y);
}
else
@@ -253,7 +253,7 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
box.x2 = pSrcDrawable->width;
box.y2 = pSrcDrawable->height;
prgnSrcClip = &rgnSrcRec;
- REGION_INIT(pscr, prgnSrcClip, &box, 1);
+ RegionInit(prgnSrcClip, &box, 1);
pSrcWin = (WindowPtr)NULL;
}
@@ -270,11 +270,11 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
else
{
prgnDstClip = &rgnDstRec;
- REGION_NULL(pscr, prgnDstClip);
- REGION_COPY(pscr, prgnDstClip,
+ RegionNull(prgnDstClip);
+ RegionCopy(prgnDstClip,
&((WindowPtr)pDstDrawable)->clipList);
}
- REGION_TRANSLATE(pscr, prgnDstClip,
+ RegionTranslate(prgnDstClip,
-pDstDrawable->x, -pDstDrawable->y);
}
else
@@ -286,14 +286,14 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
box.x2 = pDstDrawable->width;
box.y2 = pDstDrawable->height;
prgnDstClip = &rgnDstRec;
- REGION_INIT(pscr, prgnDstClip, &box, 1);
+ RegionInit(prgnDstClip, &box, 1);
}
/* drawable-relative source region */
- REGION_INIT(pscr, &rgnExposed, &srcBox, 1);
+ RegionInit(&rgnExposed, &srcBox, 1);
/* now get the hidden parts of the source box*/
- REGION_SUBTRACT(pscr, &rgnExposed, &rgnExposed, prgnSrcClip);
+ RegionSubtract(&rgnExposed, &rgnExposed, prgnSrcClip);
if (pSrcWin && pSrcWin->backStorage)
{
@@ -311,10 +311,10 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
}
/* move them over the destination */
- REGION_TRANSLATE(pscr, &rgnExposed, dstx-srcx, dsty-srcy);
+ RegionTranslate(&rgnExposed, dstx-srcx, dsty-srcy);
/* intersect with visible areas of dest */
- REGION_INTERSECT(pscr, &rgnExposed, &rgnExposed, prgnDstClip);
+ RegionIntersect(&rgnExposed, &rgnExposed, prgnDstClip);
/*
* If we have LOTS of rectangles, we decide to take the extents
@@ -324,7 +324,7 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
* for windows.
*/
extents = pGC->graphicsExposures &&
- (REGION_NUM_RECTS(&rgnExposed) > RECTLIMIT) &&
+ (RegionNumRects(&rgnExposed) > RECTLIMIT) &&
(pDstDrawable->type != DRAWABLE_PIXMAP);
#ifdef SHAPE
if (pSrcWin)
@@ -337,7 +337,7 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
* exposed region will undo all our work!
*/
if (extents && pSrcWin && region &&
- (RECT_IN_REGION(pscr, region, &srcBox) != rgnIN))
+ (RegionContainsRect(region, &srcBox) != rgnIN))
extents = FALSE;
}
#endif
@@ -345,8 +345,8 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
{
WindowPtr pWin = (WindowPtr)pDstDrawable;
- expBox = *REGION_EXTENTS(pscr, &rgnExposed);
- REGION_RESET(pscr, &rgnExposed, &expBox);
+ expBox = *RegionExtents(&rgnExposed);
+ RegionReset(&rgnExposed, &expBox);
/* need to clear out new areas of backing store */
if (pWin->backStorage)
(void) (* pWin->drawable.pScreen->ClearBackingStore)(
@@ -363,53 +363,53 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
WindowPtr pWin = (WindowPtr)pDstDrawable;
/* make the exposed area screen-relative */
- REGION_TRANSLATE(pscr, &rgnExposed,
+ RegionTranslate(&rgnExposed,
pDstDrawable->x, pDstDrawable->y);
if (extents)
{
/* PaintWindowBackground doesn't clip, so we have to */
- REGION_INTERSECT(pscr, &rgnExposed, &rgnExposed, &pWin->clipList);
+ RegionIntersect(&rgnExposed, &rgnExposed, &pWin->clipList);
}
(*pWin->drawable.pScreen->PaintWindowBackground)(
(WindowPtr)pDstDrawable, &rgnExposed, PW_BACKGROUND);
if (extents)
{
- REGION_RESET(pscr, &rgnExposed, &expBox);
+ RegionReset(&rgnExposed, &expBox);
}
else
- REGION_TRANSLATE(pscr, &rgnExposed,
+ RegionTranslate(&rgnExposed,
-pDstDrawable->x, -pDstDrawable->y);
}
if (prgnDstClip == &rgnDstRec)
{
- REGION_UNINIT(pscr, prgnDstClip);
+ RegionUninit(prgnDstClip);
}
else if (prgnDstClip != prgnSrcClip)
{
- REGION_DESTROY(pscr, prgnDstClip);
+ RegionDestroy(prgnDstClip);
}
if (prgnSrcClip == &rgnSrcRec)
{
- REGION_UNINIT(pscr, prgnSrcClip);
+ RegionUninit(prgnSrcClip);
}
else
{
- REGION_DESTROY(pscr, prgnSrcClip);
+ RegionDestroy(prgnSrcClip);
}
if (pGC->graphicsExposures)
{
/* don't look */
- RegionPtr exposed = REGION_CREATE(pscr, NullBox, 0);
+ RegionPtr exposed = RegionCreate(NullBox, 0);
*exposed = rgnExposed;
return exposed;
}
else
{
- REGION_UNINIT(pscr, &rgnExposed);
+ RegionUninit(&rgnExposed);
return NULL;
}
}
@@ -424,7 +424,7 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
int major;
int minor;
{
- if (pRgn && !REGION_NIL(pRgn))
+ if (pRgn && !RegionNil(pRgn))
{
xEvent *pEvent;
register xEvent *pe;
@@ -432,8 +432,8 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
register int i;
int numRects;
- numRects = REGION_NUM_RECTS(pRgn);
- pBox = REGION_RECTS(pRgn);
+ numRects = RegionNumRects(pRgn);
+ pBox = RegionRects(pRgn);
if(!(pEvent = (xEvent *)ALLOCATE_LOCAL(numRects * sizeof(xEvent))))
return;
pe = pEvent;
@@ -479,8 +479,8 @@ miSendExposures(pWin, pRgn, dx, dy)
register xEvent *pEvent, *pe;
register int i;
- pBox = REGION_RECTS(pRgn);
- numRects = REGION_NUM_RECTS(pRgn);
+ pBox = RegionRects(pRgn);
+ numRects = RegionNumRects(pRgn);
if(!(pEvent = (xEvent *) ALLOCATE_LOCAL(numRects * sizeof(xEvent))))
return;
memset(pEvent, 0, numRects * sizeof(xEvent));
@@ -554,8 +554,8 @@ miWindowExposures(pWin, prgn, other_exposed)
* no areas will be repainted.
*/
exposures = (*pWin->drawable.pScreen->RestoreAreas)(pWin, prgn);
- if ((prgn && !REGION_NIL(prgn)) ||
- (exposures && !REGION_NIL(exposures)) || other_exposed)
+ if ((prgn && !RegionNil(prgn)) ||
+ (exposures && !RegionNil(exposures)) || other_exposed)
{
RegionRec expRec;
int clientInterested;
@@ -568,11 +568,11 @@ miWindowExposures(pWin, prgn, other_exposed)
{
if (exposures)
{
- REGION_UNION(pWin->drawable.pScreen, other_exposed,
+ RegionUnion(other_exposed,
exposures,
other_exposed);
if (exposures != prgn)
- REGION_DESTROY(pWin->drawable.pScreen, exposures);
+ RegionDestroy(exposures);
}
exposures = other_exposed;
}
@@ -583,12 +583,12 @@ miWindowExposures(pWin, prgn, other_exposed)
* than 4, let the function decide.
*/
- total = REGION_NUM_RECTS(exposures);
+ total = RegionNumRects(exposures);
if (clientInterested && exposures && (total > RECTLIMIT ||
(total > 4 && nxagentExtentsPredicate(total) == 1)))
#else
- if (clientInterested && exposures && (REGION_NUM_RECTS(exposures) > RECTLIMIT))
+ if (clientInterested && exposures && (RegionNumRects(exposures) > RECTLIMIT))
#endif
{
/*
@@ -599,17 +599,17 @@ miWindowExposures(pWin, prgn, other_exposed)
*/
BoxRec box;
- box = *REGION_EXTENTS( pWin->drawable.pScreen, exposures);
+ box = *RegionExtents(exposures);
if (exposures == prgn) {
exposures = &expRec;
- REGION_INIT( pWin->drawable.pScreen, exposures, &box, 1);
- REGION_RESET( pWin->drawable.pScreen, prgn, &box);
+ RegionInit(exposures, &box, 1);
+ RegionReset(prgn, &box);
} else {
- REGION_RESET( pWin->drawable.pScreen, exposures, &box);
- REGION_UNION( pWin->drawable.pScreen, prgn, prgn, exposures);
+ RegionReset(exposures, &box);
+ RegionUnion(prgn, prgn, exposures);
}
/* PaintWindowBackground doesn't clip, so we have to */
- REGION_INTERSECT( pWin->drawable.pScreen, prgn, prgn, &pWin->clipList);
+ RegionIntersect(prgn, prgn, &pWin->clipList);
/* need to clear out new areas of backing store, too */
if (pWin->backStorage)
(void) (* pWin->drawable.pScreen->ClearBackingStore)(
@@ -620,22 +620,22 @@ miWindowExposures(pWin, prgn, other_exposed)
box.y2 - box.y1,
FALSE);
}
- if (prgn && !REGION_NIL(prgn))
+ if (prgn && !RegionNil(prgn))
(*pWin->drawable.pScreen->PaintWindowBackground)(pWin, prgn, PW_BACKGROUND);
- if (clientInterested && exposures && !REGION_NIL(exposures))
+ if (clientInterested && exposures && !RegionNil(exposures))
miSendExposures(pWin, exposures,
pWin->drawable.x, pWin->drawable.y);
if (exposures == &expRec)
{
- REGION_UNINIT( pWin->drawable.pScreen, exposures);
+ RegionUninit(exposures);
}
else if (exposures && exposures != prgn && exposures != other_exposed)
- REGION_DESTROY( pWin->drawable.pScreen, exposures);
+ RegionDestroy(exposures);
if (prgn)
- REGION_EMPTY( pWin->drawable.pScreen, prgn);
+ RegionEmpty(prgn);
}
else if (exposures && exposures != prgn)
- REGION_DESTROY( pWin->drawable.pScreen, exposures);
+ RegionDestroy(exposures);
}
@@ -708,7 +708,7 @@ int what;
#define COUNT_BITS 8
ChangeGCVal gcval[7];
- ChangeGCVal newValues [COUNT_BITS];
+ ChangeGCVal newValues [COUNT_BITS] = {{ 0 }};
BITS32 gcmask, index, mask;
RegionRec prgnWin;
@@ -779,7 +779,7 @@ int what;
}
}
- prect = (xRectangle *)ALLOCATE_LOCAL(REGION_NUM_RECTS(prgn) *
+ prect = (xRectangle *)ALLOCATE_LOCAL(RegionNumRects(prgn) *
sizeof(xRectangle));
if (!prect)
return;
@@ -822,7 +822,7 @@ int what;
box.y1 = 0;
box.x2 = pScreen->width;
box.y2 = pScreen->height;
- REGION_INIT(pScreen, &pWin->clipList, &box, 1);
+ RegionInit(&pWin->clipList, &box, 1);
pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
newValues[ABSX].val = pBgWin->drawable.x;
newValues[ABSY].val = pBgWin->drawable.y;
@@ -925,8 +925,8 @@ int what;
if (pWin->drawable.serialNumber != pGC->serialNumber)
ValidateGC((DrawablePtr)pWin, pGC);
- numRects = REGION_NUM_RECTS(prgn);
- pbox = REGION_RECTS(prgn);
+ numRects = RegionNumRects(prgn);
+ pbox = RegionRects(prgn);
for (i= numRects; --i >= 0; pbox++, prect++)
{
prect->x = pbox->x1 - pWin->drawable.x;
@@ -945,7 +945,7 @@ int what;
{
if (what == PW_BORDER)
{
- REGION_UNINIT(pScreen, &pWin->clipList);
+ RegionUninit(&pWin->clipList);
pWin->clipList = prgnWin;
pWin->drawable.x = oldCorner.x;
pWin->drawable.y = oldCorner.y;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c
index a720cafbf..56237605e 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c
@@ -131,7 +131,7 @@ miClearToBackground(pWin, x, y, w, h, generateExposures)
box.y2 = y2;
pScreen = pWin->drawable.pScreen;
- REGION_INIT(pScreen, &reg, &box, 1);
+ RegionInit(&reg, &box, 1);
if (pWin->backStorage)
{
/*
@@ -145,14 +145,14 @@ miClearToBackground(pWin, x, y, w, h, generateExposures)
generateExposures);
}
- REGION_INTERSECT(pScreen, &reg, &reg, &pWin->clipList);
+ RegionIntersect(&reg, &reg, &pWin->clipList);
if (generateExposures)
(*pScreen->WindowExposures)(pWin, &reg, pBSReg);
else if (pWin->backgroundState != None)
(*pScreen->PaintWindowBackground)(pWin, &reg, PW_BACKGROUND);
- REGION_UNINIT(pScreen, &reg);
+ RegionUninit(&reg);
if (pBSReg)
- REGION_DESTROY(pScreen, pBSReg);
+ RegionDestroy(pBSReg);
}
/*
@@ -198,7 +198,7 @@ miCheckSubSaveUnder(
for (; pChild != pFirst; pChild = pChild->nextSib)
if (pChild->viewable && pChild->saveUnder)
- REGION_UNION(pScreen, pRegion, pRegion, &pChild->borderSize);
+ RegionUnion(pRegion, pRegion, &pChild->borderSize);
/*
* check region below and including first changed window
@@ -217,10 +217,10 @@ miCheckSubSaveUnder(
{
if (!subInited)
{
- REGION_NULL(pScreen, &SubRegion);
+ RegionNull(&SubRegion);
subInited = TRUE;
}
- REGION_COPY(pScreen, &SubRegion, pRegion);
+ RegionCopy(&SubRegion, pRegion);
res |= miCheckSubSaveUnder(pChild, pChild->firstChild,
&SubRegion);
}
@@ -231,12 +231,12 @@ miCheckSubSaveUnder(
}
if (pChild->saveUnder)
- REGION_UNION(pScreen, pRegion, pRegion, &pChild->borderSize);
+ RegionUnion(pRegion, pRegion, &pChild->borderSize);
}
}
if (subInited)
- REGION_UNINIT(pScreen, &SubRegion);
+ RegionUninit(&SubRegion);
}
/*
@@ -247,8 +247,8 @@ miCheckSubSaveUnder(
if (pParent->viewable &&
((pParent->eventMask | wOtherEventMasks(pParent)) & ExposureMask) &&
- REGION_NOTEMPTY(pScreen, &pParent->borderSize) &&
- RECT_IN_REGION(pScreen, pRegion, REGION_EXTENTS(pScreen,
+ RegionNotEmpty(&pParent->borderSize) &&
+ RegionContainsRect(pRegion, RegionExtents(
&pParent->borderSize)) != rgnOUT)
{
if (!pParent->DIXsaveUnder)
@@ -292,19 +292,17 @@ miChangeSaveUnder(pWin, first)
* Used when pWin was restacked */
{
RegionRec rgn; /* Area obscured by saveUnder windows */
- register ScreenPtr pScreen;
Bool res;
if (!deltaSaveUndersViewable && !numSaveUndersViewable)
return FALSE;
numSaveUndersViewable += deltaSaveUndersViewable;
deltaSaveUndersViewable = 0;
- pScreen = pWin->drawable.pScreen;
- REGION_NULL(pScreen, &rgn);
+ RegionNull(&rgn);
res = miCheckSubSaveUnder (pWin->parent,
pWin->saveUnder ? first : pWin->nextSib,
&rgn);
- REGION_UNINIT(pScreen, &rgn);
+ RegionUninit(&rgn);
return res;
}
@@ -385,9 +383,6 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
register WindowPtr pChild, pLast;
Bool anyMarked = FALSE;
MarkWindowProcPtr MarkWindow = pWin->drawable.pScreen->MarkWindow;
- ScreenPtr pScreen;
-
- pScreen = pWin->drawable.pScreen;
/* single layered systems are easy */
if (ppLayerWin) *ppLayerWin = pWin;
@@ -403,9 +398,9 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
{
if (pChild->viewable)
{
- if (REGION_BROKEN (pScreen, &pChild->winSize))
+ if (RegionBroken(&pChild->winSize))
SetWinSize (pChild);
- if (REGION_BROKEN (pScreen, &pChild->borderSize))
+ if (RegionBroken(&pChild->borderSize))
SetBorderSize (pChild);
(* MarkWindow)(pChild);
if (pChild->firstChild)
@@ -425,17 +420,17 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
}
if ( (pChild = pFirst) )
{
- box = REGION_EXTENTS(pChild->drawable.pScreen, &pWin->borderSize);
+ box = RegionExtents(&pWin->borderSize);
pLast = pChild->parent->lastChild;
while (1)
{
if (pChild->viewable)
{
- if (REGION_BROKEN (pScreen, &pChild->winSize))
+ if (RegionBroken(&pChild->winSize))
SetWinSize (pChild);
- if (REGION_BROKEN (pScreen, &pChild->borderSize))
+ if (RegionBroken(&pChild->borderSize))
SetBorderSize (pChild);
- if (RECT_IN_REGION(pScreen, &pChild->borderSize, box))
+ if (RegionContainsRect(&pChild->borderSize, box))
{
(* MarkWindow)(pChild);
anyMarked = TRUE;
@@ -470,24 +465,21 @@ miHandleValidateExposures(pWin)
{
register WindowPtr pChild;
register ValidatePtr val;
- ScreenPtr pScreen;
WindowExposuresProcPtr WindowExposures;
- pScreen = pWin->drawable.pScreen;
-
pChild = pWin;
WindowExposures = pChild->drawable.pScreen->WindowExposures;
while (1)
{
if ( (val = pChild->valdata) )
{
- if (REGION_NOTEMPTY(pScreen, &val->after.borderExposed))
+ if (RegionNotEmpty(&val->after.borderExposed))
(*pChild->drawable.pScreen->PaintWindowBorder)(pChild,
&val->after.borderExposed,
PW_BORDER);
- REGION_UNINIT(pScreen, &val->after.borderExposed);
+ RegionUninit(&val->after.borderExposed);
(*WindowExposures)(pChild, &val->after.exposed, NullRegion);
- REGION_UNINIT(pScreen, &val->after.exposed);
+ RegionUninit(&val->after.exposed);
xfree(val);
pChild->valdata = (ValidatePtr)NULL;
if (pChild->firstChild)
@@ -534,8 +526,8 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
oldpt.y = pWin->drawable.y;
if (WasViewable)
{
- oldRegion = REGION_CREATE(pScreen, NullBox, 1);
- REGION_COPY(pScreen, oldRegion, &pWin->borderClip);
+ oldRegion = RegionCreate(NullBox, 1);
+ RegionCopy(oldRegion, &pWin->borderClip);
anyMarked = (*pScreen->MarkOverlappedWindows)(pWin, pWin, &pLayerWin);
}
pWin->origin.x = x + (int)bw;
@@ -572,7 +564,7 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
{
(*pScreen->ValidateTree)(pLayerWin->parent, NullWindow, kind);
(* pWin->drawable.pScreen->CopyWindow)(pWin, oldpt, oldRegion);
- REGION_DESTROY(pScreen, oldRegion);
+ RegionDestroy(oldRegion);
/* XXX need to retile border if ParentRelative origin */
(*pScreen->HandleExposures)(pLayerWin->parent);
}
@@ -598,23 +590,21 @@ miRecomputeExposures (
register WindowPtr pWin,
void * value) /* must conform to VisitWindowProcPtr */
{
- register ScreenPtr pScreen;
RegionPtr pValid = (RegionPtr)value;
if (pWin->valdata)
{
- pScreen = pWin->drawable.pScreen;
/*
* compute exposed regions of this window
*/
- REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+ RegionSubtract(&pWin->valdata->after.exposed,
&pWin->clipList, pValid);
/*
* compute exposed regions of the border
*/
- REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+ RegionSubtract(&pWin->valdata->after.borderExposed,
&pWin->borderClip, &pWin->winSize);
- REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+ RegionSubtract(&pWin->valdata->after.borderExposed,
&pWin->valdata->after.borderExposed, pValid);
return WT_WALKCHILDREN;
}
@@ -671,8 +661,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
/*
* save the visible region of the window
*/
- oldRegion = REGION_CREATE(pScreen, NullBox, 1);
- REGION_COPY(pScreen, oldRegion, &pWin->winSize);
+ oldRegion = RegionCreate(NullBox, 1);
+ RegionCopy(oldRegion, &pWin->winSize);
/*
* categorize child windows into regions to be moved
@@ -685,8 +675,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
if (g != UnmapGravity)
{
if (!gravitate[g])
- gravitate[g] = REGION_CREATE(pScreen, NullBox, 1);
- REGION_UNION(pScreen, gravitate[g],
+ gravitate[g] = RegionCreate(NullBox, 1);
+ RegionUnion(gravitate[g],
gravitate[g], &pChild->borderClip);
}
else
@@ -701,8 +691,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
oldWinClip = NULL;
if (pWin->bitGravity != ForgetGravity)
{
- oldWinClip = REGION_CREATE(pScreen, NullBox, 1);
- REGION_COPY(pScreen, oldWinClip, &pWin->clipList);
+ oldWinClip = RegionCreate(NullBox, 1);
+ RegionCopy(oldWinClip, &pWin->clipList);
}
/*
* if the window is changing size, borderExposed
@@ -717,16 +707,16 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
if ((pWin->drawable.height != h || pWin->drawable.width != w) &&
HasBorder (pWin))
{
- borderVisible = REGION_CREATE(pScreen, NullBox, 1);
+ borderVisible = RegionCreate(NullBox, 1);
/* for tiled borders, we punt and draw the whole thing */
if (pWin->borderIsPixel || !moved)
{
if (shrunk || moved)
- REGION_SUBTRACT(pScreen, borderVisible,
+ RegionSubtract(borderVisible,
&pWin->borderClip,
&pWin->winSize);
else
- REGION_COPY(pScreen, borderVisible,
+ RegionCopy(borderVisible,
&pWin->borderClip);
}
}
@@ -753,9 +743,9 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
if (WasViewable)
{
- pRegion = REGION_CREATE(pScreen, NullBox, 1);
+ pRegion = RegionCreate(NullBox, 1);
if (pWin->backStorage)
- REGION_COPY(pScreen, pRegion, &pWin->clipList);
+ RegionCopy(pRegion, &pWin->clipList);
if (pLayerWin == pWin)
anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pFirstChange,
@@ -783,7 +773,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
* the entire window is trashed unless bitGravity
* recovers portions of it
*/
- REGION_COPY(pScreen, &pWin->valdata->after.exposed, &pWin->clipList);
+ RegionCopy(&pWin->valdata->after.exposed, &pWin->clipList);
}
GravityTranslate (x, y, oldx, oldy, dw, dh, pWin->bitGravity, &nx, &ny);
@@ -827,16 +817,16 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
dy = (oldy - ny) - offy;
if (dx || dy)
{
- REGION_TRANSLATE(pScreen, &pWin->winSize, dx, dy);
+ RegionTranslate(&pWin->winSize, dx, dy);
offx += dx;
offy += dy;
}
- REGION_INTERSECT(pScreen, gravitate[g], gravitate[g],
+ RegionIntersect(gravitate[g], gravitate[g],
&pWin->winSize);
}
/* get winSize back where it belongs */
if (offx || offy)
- REGION_TRANSLATE(pScreen, &pWin->winSize, -offx, -offy);
+ RegionTranslate(&pWin->winSize, -offx, -offy);
}
/*
* add screen bits to the appropriate bucket
@@ -847,9 +837,9 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
/*
* clip to new clipList
*/
- REGION_COPY(pScreen, pRegion, oldWinClip);
- REGION_TRANSLATE(pScreen, pRegion, nx - oldx, ny - oldy);
- REGION_INTERSECT(pScreen, oldWinClip, pRegion, &pWin->clipList);
+ RegionCopy(pRegion, oldWinClip);
+ RegionTranslate(pRegion, nx - oldx, ny - oldy);
+ RegionIntersect(oldWinClip, pRegion, &pWin->clipList);
/*
* don't step on any gravity bits which will be copied after this
* region. Note -- this assumes that the regions will be copied
@@ -858,17 +848,17 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
for (g = pWin->bitGravity + 1; g <= StaticGravity; g++)
{
if (gravitate[g])
- REGION_SUBTRACT(pScreen, oldWinClip, oldWinClip,
+ RegionSubtract(oldWinClip, oldWinClip,
gravitate[g]);
}
- REGION_TRANSLATE(pScreen, oldWinClip, oldx - nx, oldy - ny);
+ RegionTranslate(oldWinClip, oldx - nx, oldy - ny);
g = pWin->bitGravity;
if (!gravitate[g])
gravitate[g] = oldWinClip;
else
{
- REGION_UNION(pScreen, gravitate[g], gravitate[g], oldWinClip);
- REGION_DESTROY(pScreen, oldWinClip);
+ RegionUnion(gravitate[g], gravitate[g], oldWinClip);
+ RegionDestroy(oldWinClip);
}
}
@@ -892,14 +882,14 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
/* only copy the remaining useful bits */
- REGION_INTERSECT(pScreen, gravitate[g], gravitate[g], oldRegion);
+ RegionIntersect(gravitate[g], gravitate[g], oldRegion);
/* clip to not overwrite already copied areas */
if (destClip) {
- REGION_TRANSLATE(pScreen, destClip, oldpt.x - x, oldpt.y - y);
- REGION_SUBTRACT(pScreen, gravitate[g], gravitate[g], destClip);
- REGION_TRANSLATE(pScreen, destClip, x - oldpt.x, y - oldpt.y);
+ RegionTranslate(destClip, oldpt.x - x, oldpt.y - y);
+ RegionSubtract(gravitate[g], gravitate[g], destClip);
+ RegionTranslate(destClip, x - oldpt.x, y - oldpt.y);
}
/* and move those bits */
@@ -915,7 +905,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
/* remove any overwritten bits from the remaining useful bits */
- REGION_SUBTRACT(pScreen, oldRegion, oldRegion, gravitate[g]);
+ RegionSubtract(oldRegion, oldRegion, gravitate[g]);
/*
* recompute exposed regions of child windows
@@ -925,7 +915,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
{
if (pChild->winGravity != g)
continue;
- REGION_INTERSECT(pScreen, pRegion,
+ RegionIntersect(pRegion,
&pChild->borderClip, gravitate[g]);
TraverseTree (pChild, miRecomputeExposures, (void *)pRegion);
}
@@ -936,21 +926,21 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
*/
if (g == pWin->bitGravity)
- REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+ RegionSubtract(&pWin->valdata->after.exposed,
&pWin->valdata->after.exposed, gravitate[g]);
if (!destClip)
destClip = gravitate[g];
else
{
- REGION_UNION(pScreen, destClip, destClip, gravitate[g]);
- REGION_DESTROY(pScreen, gravitate[g]);
+ RegionUnion(destClip, destClip, gravitate[g]);
+ RegionDestroy(gravitate[g]);
}
}
- REGION_DESTROY(pScreen, oldRegion);
- REGION_DESTROY(pScreen, pRegion);
+ RegionDestroy(oldRegion);
+ RegionDestroy(pRegion);
if (destClip)
- REGION_DESTROY(pScreen, destClip);
+ RegionDestroy(destClip);
if (bsExposed)
{
RegionPtr valExposed = NullRegion;
@@ -959,8 +949,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
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 (anyMarked)
(*pScreen->HandleExposures)(pLayerWin->parent);
@@ -977,7 +967,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
else if (bsExposed)
{
(*pScreen->WindowExposures) (pWin, NullRegion, bsExposed);
- REGION_DESTROY(pScreen, bsExposed);
+ RegionDestroy(bsExposed);
}
if (pWin->realized)
WindowsRestructured ();
@@ -1021,8 +1011,8 @@ miSetShape(pWin)
{
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;
}
@@ -1039,8 +1029,8 @@ miSetShape(pWin)
{
if (pWin->backStorage)
{
- pOldClip = REGION_CREATE(pScreen, NullBox, 1);
- REGION_COPY(pScreen, pOldClip, &pWin->clipList);
+ pOldClip = RegionCreate(NullBox, 1);
+ RegionCopy(pOldClip, &pWin->clipList);
}
anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pWin,
@@ -1083,10 +1073,10 @@ miSetShape(pWin)
*/
if (WasViewable && pOldClip)
- REGION_DESTROY(pScreen, pOldClip);
+ RegionDestroy(pOldClip);
#else
if (WasViewable)
- REGION_DESTROY(pScreen, pOldClip);
+ RegionDestroy(pOldClip);
#endif
if (bsExposed)
{
@@ -1096,8 +1086,8 @@ miSetShape(pWin)
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)
@@ -1158,8 +1148,8 @@ miChangeBorderWidth(pWin, width)
if (pWin->valdata && HadBorder)
{
RegionPtr borderVisible;
- borderVisible = REGION_CREATE(pScreen, NULL, 1);
- REGION_SUBTRACT(pScreen, borderVisible,
+ borderVisible = RegionCreate(NULL, 1);
+ RegionSubtract(borderVisible,
&pWin->borderClip, &pWin->winSize);
pWin->valdata->before.borderVisible = borderVisible;
}
@@ -1196,25 +1186,22 @@ miMarkUnrealizedWindow(pChild, pWin, fromConfigure)
{
if ((pChild != pWin) || fromConfigure)
{
- REGION_EMPTY(pChild->drawable.pScreen, &pChild->clipList);
+ RegionEmpty(&pChild->clipList);
if (pChild->drawable.pScreen->ClipNotify)
(* pChild->drawable.pScreen->ClipNotify)(pChild, 0, 0);
- REGION_EMPTY(pChild->drawable.pScreen, &pChild->borderClip);
+ RegionEmpty(&pChild->borderClip);
}
}
void
miSegregateChildren(WindowPtr pWin, RegionPtr pReg, int depth)
{
- ScreenPtr pScreen;
WindowPtr pChild;
- pScreen = pWin->drawable.pScreen;
-
for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib)
{
if (pChild->drawable.depth == depth)
- REGION_UNION(pScreen, pReg, pReg, &pChild->borderClip);
+ RegionUnion(pReg, pReg, &pChild->borderClip);
if (pChild->firstChild)
miSegregateChildren(pChild, pReg, depth);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
index 9c438394a..67cd5d6ed 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
@@ -1537,7 +1537,7 @@ SetPictureClipRects (PicturePtr pPicture,
RegionPtr clientClip;
int result;
- clientClip = RECTS_TO_REGION(pScreen,
+ clientClip = RegionFromRects(
nRect, rects, CT_UNSORTED);
if (!clientClip)
return BadAlloc;
@@ -1568,14 +1568,14 @@ SetPictureClipRegion (PicturePtr pPicture,
if (pRegion)
{
type = CT_REGION;
- clientClip = REGION_CREATE (pScreen,
- REGION_EXTENTS(pScreen, pRegion),
- REGION_NUM_RECTS(pRegion));
+ clientClip = RegionCreate(
+ RegionExtents(pRegion),
+ RegionNumRects(pRegion));
if (!clientClip)
return BadAlloc;
- if (!REGION_COPY (pSCreen, clientClip, pRegion))
+ if (!RegionCopy(clientClip, pRegion))
{
- REGION_DESTROY (pScreen, clientClip);
+ RegionDestroy(clientClip);
return BadAlloc;
}
}
@@ -1685,9 +1685,9 @@ CopyPicture (PicturePtr pSrc,
RegionPtr clientClip;
RegionPtr srcClientClip = (RegionPtr)pSrc->clientClip;
- clientClip = REGION_CREATE(pSrc->pDrawable->pScreen,
- REGION_EXTENTS(pSrc->pDrawable->pScreen, srcClientClip),
- REGION_NUM_RECTS(srcClientClip));
+ clientClip = RegionCreate(
+ RegionExtents(srcClientClip),
+ RegionNumRects(srcClientClip));
(*ps->ChangePictureClip)(pDst, CT_REGION, clientClip, 0);
}
break;
@@ -2144,12 +2144,6 @@ Bool nxagentReconnectAllPictFormat(void *p)
void nxagentReconnectPictFormat(void *p0, XID x1, void *p2)
{
- PictFormatPtr pFormat;
- Bool *pBool;
-
- pFormat = (PictFormatPtr)p0;
- pBool = (Bool*)p2;
-
#if defined(NXAGENT_RECONNECT_DEBUG) || defined(NXAGENT_RECONNECT_PICTFORMAT_DEBUG)
fprintf(stderr, "nxagentReconnectPictFormat.\n");
#endif
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
index dc1d2387e..1999c33b0 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
@@ -3033,13 +3033,11 @@ static void swapStops(void *stuff, int num)
{
int i, n;
CARD32 *stops;
- CARD16 *colors;
stops = (CARD32 *)(stuff);
for (i = 0; i < num; ++i) {
swapl(stops, n);
++stops;
}
- colors = (CARD16 *)(stops);
for (i = 0; i < 4*num; ++i) {
swaps(stops, n);
++stops;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
index 4552ad563..b2da4e97c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
@@ -226,7 +226,7 @@ PrintChildren(WindowPtr p1, int indent)
p2 = p1->firstChild;
for (i=0; i<indent; i++) ErrorF( " ");
ErrorF( "%x\n", p1->drawable.id);
- miPrintRegion(&p1->clipList);
+ RegionPrint(&p1->clipList);
PrintChildren(p2, indent+4);
p1 = p1->nextSib;
}
@@ -241,7 +241,7 @@ PrintWindowTree()
{
ErrorF( "WINDOW %d\n", i);
pWin = WindowTable[i];
- miPrintRegion(&pWin->clipList);
+ RegionPrint(&pWin->clipList);
p1 = pWin->firstChild;
PrintChildren(p1, 4);
}
@@ -339,12 +339,8 @@ SetWindowToDefaults(register WindowPtr pWin)
void nxagentClearSplash(WindowPtr pW)
{
- int w, h;
ScreenPtr pScreen;
- w = pW->drawable.width;
- h = pW->drawable.height;
-
pScreen = pW->drawable.pScreen;
if (pW->backgroundState == BackgroundPixmap)
@@ -513,10 +509,10 @@ CreateRootWindow(ScreenPtr pScreen)
box.y1 = 0;
box.x2 = pScreen->width;
box.y2 = pScreen->height;
- REGION_INIT(pScreen, &pWin->clipList, &box, 1);
- REGION_INIT(pScreen, &pWin->winSize, &box, 1);
- REGION_INIT(pScreen, &pWin->borderSize, &box, 1);
- REGION_INIT(pScreen, &pWin->borderClip, &box, 1);
+ RegionInit(&pWin->clipList, &box, 1);
+ RegionInit(&pWin->winSize, &box, 1);
+ RegionInit(&pWin->borderSize, &box, 1);
+ RegionInit(&pWin->borderClip, &box, 1);
pWin->drawable.class = InputOutput;
pWin->optional->visual = pScreen->rootVisual;
@@ -701,7 +697,7 @@ ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
#endif /* NXAGENT_SERVER */
BoxRec box;
- box = *(REGION_EXTENTS(pScreen, &pWin->winSize));
+ box = *(RegionExtents(&pWin->winSize));
/* we do these calculations to avoid overflows */
if (x > box.x1)
box.x1 = x;
@@ -717,8 +713,8 @@ ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
box.x2 = box.x1;
if (box.y1 > box.y2)
box.y2 = box.y1;
- REGION_RESET(pScreen, Rgn, &box);
- REGION_INTERSECT(pScreen, Rgn, Rgn, &pWin->winSize);
+ RegionReset(Rgn, &box);
+ RegionIntersect(Rgn, Rgn, &pWin->winSize);
}
WindowPtr
@@ -899,10 +895,10 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
pWin->drawable.y = pParent->drawable.y + y + (int)bw;
/* set up clip list correctly for unobscured WindowPtr */
- REGION_NULL(pScreen, &pWin->clipList);
- REGION_NULL(pScreen, &pWin->borderClip);
- REGION_NULL(pScreen, &pWin->winSize);
- REGION_NULL(pScreen, &pWin->borderSize);
+ RegionNull(&pWin->clipList);
+ RegionNull(&pWin->borderClip);
+ RegionNull(&pWin->winSize);
+ RegionNull(&pWin->borderSize);
pHead = RealChildHead(pParent);
if (pHead)
@@ -983,17 +979,17 @@ FreeWindowResources(register WindowPtr pWin)
DeleteWindowFromAnySaveSet(pWin);
DeleteWindowFromAnySelections(pWin);
DeleteWindowFromAnyEvents(pWin, TRUE);
- REGION_UNINIT(pScreen, &pWin->clipList);
- REGION_UNINIT(pScreen, &pWin->winSize);
- REGION_UNINIT(pScreen, &pWin->borderClip);
- REGION_UNINIT(pScreen, &pWin->borderSize);
+ RegionUninit(&pWin->clipList);
+ RegionUninit(&pWin->winSize);
+ RegionUninit(&pWin->borderClip);
+ RegionUninit(&pWin->borderSize);
#ifdef SHAPE
if (wBoundingShape (pWin))
- REGION_DESTROY(pScreen, wBoundingShape (pWin));
+ RegionDestroy(wBoundingShape (pWin));
if (wClipShape (pWin))
- REGION_DESTROY(pScreen, wClipShape (pWin));
+ RegionDestroy(wClipShape (pWin));
if (wInputShape (pWin))
- REGION_DESTROY(pScreen, wInputShape (pWin));
+ RegionDestroy(wInputShape (pWin));
#endif
if (pWin->borderIsPixel == FALSE)
(*pScreen->DestroyPixmap)(pWin->border.pixmap);
@@ -1683,10 +1679,10 @@ PatchUp:
{
RegionRec exposed;
- REGION_NULL(pScreen, &exposed);
- REGION_SUBTRACT(pScreen, &exposed, &pWin->borderClip, &pWin->winSize);
+ RegionNull(&exposed);
+ RegionSubtract(&exposed, &pWin->borderClip, &pWin->winSize);
(*pWin->drawable.pScreen->PaintWindowBorder)(pWin, &exposed, PW_BORDER);
- REGION_UNINIT(pScreen, &exposed);
+ RegionUninit(&exposed);
}
return error;
}
@@ -1827,19 +1823,19 @@ CreateUnclippedWinSize (register WindowPtr pWin)
box.y1 = pWin->drawable.y;
box.x2 = pWin->drawable.x + (int) pWin->drawable.width;
box.y2 = pWin->drawable.y + (int) pWin->drawable.height;
- pRgn = REGION_CREATE(pWin->drawable.pScreen, &box, 1);
+ pRgn = RegionCreate(&box, 1);
#ifdef SHAPE
if (wBoundingShape (pWin) || wClipShape (pWin)) {
#ifndef NXAGENT_SERVER
ScreenPtr pScreen = pWin->drawable.pScreen;
#endif /* NXAGENT_SERVER */
- REGION_TRANSLATE(pScreen, pRgn, - pWin->drawable.x,
+ RegionTranslate(pRgn, - pWin->drawable.x,
- pWin->drawable.y);
if (wBoundingShape (pWin))
- REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
+ RegionIntersect(pRgn, pRgn, wBoundingShape (pWin));
if (wClipShape (pWin))
- REGION_INTERSECT(pScreen, pRgn, pRgn, wClipShape (pWin));
- REGION_TRANSLATE(pScreen, pRgn, pWin->drawable.x, pWin->drawable.y);
+ RegionIntersect(pRgn, pRgn, wClipShape (pWin));
+ RegionTranslate(pRgn, pWin->drawable.x, pWin->drawable.y);
}
#endif
return pRgn;
@@ -1857,7 +1853,7 @@ SetWinSize (register WindowPtr pWin)
box.y1 = pWin->drawable.y;
box.x2 = pWin->drawable.x + pWin->drawable.width;
box.y2 = pWin->drawable.y + pWin->drawable.height;
- REGION_RESET (pScreen, &pWin->winSize, &box);
+ RegionReset(&pWin->winSize, &box);
}
else
#endif
@@ -1870,15 +1866,15 @@ SetWinSize (register WindowPtr pWin)
#ifndef NXAGENT_SERVER
ScreenPtr pScreen = pWin->drawable.pScreen;
#endif /* NXAGENT_SERVER */
- REGION_TRANSLATE(pScreen, &pWin->winSize, - pWin->drawable.x,
+ RegionTranslate(&pWin->winSize, - pWin->drawable.x,
- pWin->drawable.y);
if (wBoundingShape (pWin))
- REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
+ RegionIntersect(&pWin->winSize, &pWin->winSize,
wBoundingShape (pWin));
if (wClipShape (pWin))
- REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
+ RegionIntersect(&pWin->winSize, &pWin->winSize,
wClipShape (pWin));
- REGION_TRANSLATE(pScreen, &pWin->winSize, pWin->drawable.x,
+ RegionTranslate(&pWin->winSize, pWin->drawable.x,
pWin->drawable.y);
}
#endif
@@ -1900,7 +1896,7 @@ SetBorderSize (register WindowPtr pWin)
box.y1 = pWin->drawable.y - bw;
box.x2 = pWin->drawable.x + pWin->drawable.width + bw;
box.y2 = pWin->drawable.y + pWin->drawable.height + bw;
- REGION_RESET (pScreen, &pWin->borderSize, &box);
+ RegionReset(&pWin->borderSize, &box);
}
else
#endif
@@ -1913,18 +1909,18 @@ SetBorderSize (register WindowPtr pWin)
#ifndef NXAGENT_SERVER
ScreenPtr pScreen = pWin->drawable.pScreen;
#endif /* NXAGENT_SERVER */
- REGION_TRANSLATE(pScreen, &pWin->borderSize, - pWin->drawable.x,
+ RegionTranslate(&pWin->borderSize, - pWin->drawable.x,
- pWin->drawable.y);
- REGION_INTERSECT(pScreen, &pWin->borderSize, &pWin->borderSize,
+ RegionIntersect(&pWin->borderSize, &pWin->borderSize,
wBoundingShape (pWin));
- REGION_TRANSLATE(pScreen, &pWin->borderSize, pWin->drawable.x,
+ RegionTranslate(&pWin->borderSize, pWin->drawable.x,
pWin->drawable.y);
- REGION_UNION(pScreen, &pWin->borderSize, &pWin->borderSize,
+ RegionUnion(&pWin->borderSize, &pWin->borderSize,
&pWin->winSize);
}
#endif
} else {
- REGION_COPY(pWin->drawable.pScreen, &pWin->borderSize,
+ RegionCopy(&pWin->borderSize,
&pWin->winSize);
}
}
@@ -2139,12 +2135,12 @@ MakeBoundingRegion (
#ifndef NXAGENT_SERVER
ScreenPtr pScreen = pWin->drawable.pScreen;
#endif /* NXAGENT_SERVER */
- pRgn = REGION_CREATE(pScreen, pBox, 1);
+ pRgn = RegionCreate(pBox, 1);
if (wBoundingShape (pWin)) {
- REGION_TRANSLATE(pScreen, pRgn, -pWin->origin.x,
+ RegionTranslate(pRgn, -pWin->origin.x,
-pWin->origin.y);
- REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
- REGION_TRANSLATE(pScreen, pRgn, pWin->origin.x,
+ RegionIntersect(pRgn, pRgn, wBoundingShape (pWin));
+ RegionTranslate(pRgn, pWin->origin.x,
pWin->origin.y);
}
return pRgn;
@@ -2158,18 +2154,16 @@ ShapeOverlap (
BoxPtr pSibBox)
{
RegionPtr pWinRgn, pSibRgn;
- register ScreenPtr pScreen;
Bool ret;
if (!IS_SHAPED(pWin) && !IS_SHAPED(pSib))
return TRUE;
- pScreen = pWin->drawable.pScreen;
pWinRgn = MakeBoundingRegion (pWin, pWinBox);
pSibRgn = MakeBoundingRegion (pSib, pSibBox);
- REGION_INTERSECT(pScreen, pWinRgn, pWinRgn, pSibRgn);
- ret = REGION_NOTEMPTY(pScreen, pWinRgn);
- REGION_DESTROY(pScreen, pWinRgn);
- REGION_DESTROY(pScreen, pSibRgn);
+ RegionIntersect(pWinRgn, pWinRgn, pSibRgn);
+ ret = RegionNotEmpty(pWinRgn);
+ RegionDestroy(pWinRgn);
+ RegionDestroy(pSibRgn);
return ret;
}
#endif
@@ -2264,7 +2258,6 @@ WhereDoIGoInTheStack(
int smode)
{
BoxRec box;
- register ScreenPtr pScreen;
WindowPtr pHead, pFirst;
if ((pWin == pWin->parent->firstChild) &&
@@ -2272,7 +2265,6 @@ WhereDoIGoInTheStack(
return((WindowPtr ) NULL);
pHead = RealChildHead(pWin->parent);
pFirst = pHead ? pHead->nextSib : pWin->parent->firstChild;
- pScreen = pWin->drawable.pScreen;
box.x1 = x;
box.y1 = y;
box.x2 = x + (int)w;
@@ -2300,7 +2292,7 @@ WhereDoIGoInTheStack(
else if (pSib)
{
if ((IsSiblingAboveMe(pWin, pSib) == Above) &&
- (RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
+ (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT))
return(pFirst);
else
return(pWin->nextSib);
@@ -2315,7 +2307,7 @@ WhereDoIGoInTheStack(
else if (pSib)
{
if ((IsSiblingAboveMe(pWin, pSib) == Below) &&
- (RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
+ (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT))
return NullWindow;
else
return(pWin->nextSib);
@@ -2329,7 +2321,7 @@ WhereDoIGoInTheStack(
return(pWin->nextSib);
else if (pSib)
{
- if (RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT)
+ if (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT)
{
if (IsSiblingAboveMe(pWin, pSib) == Above)
return(pFirst);
@@ -3073,10 +3065,10 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
(*pScreen->ClipNotify) (pWin, 0, 0);
if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree)(NullWindow, pWin, VTMap);
- REGION_NULL(pScreen, &temp);
- REGION_COPY(pScreen, &temp, &pWin->clipList);
+ RegionNull(&temp);
+ RegionCopy(&temp, &pWin->clipList);
(*pScreen->WindowExposures) (pWin, &temp, NullRegion);
- REGION_UNINIT(pScreen, &temp);
+ RegionUninit(&temp);
}
nxagentFlushConfigureWindow();
@@ -3482,7 +3474,7 @@ VisibleBoundingBoxFromPoint(register WindowPtr pWin, int x, int y, BoxPtr box)
{
if (!pWin->realized)
return (FALSE);
- if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->clipList, x, y, box))
+ if (RegionContainsPoint(&pWin->clipList, x, y, box))
return(TRUE);
return(FALSE);
}
@@ -3498,10 +3490,10 @@ PointInWindowIsVisible(register WindowPtr pWin, int x, int y)
if (!pWin->realized)
return (FALSE);
- if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->borderClip,
+ if (RegionContainsPoint(&pWin->borderClip,
x, y, &box)
&& (!wInputShape(pWin) ||
- POINT_IN_REGION(pWin->drawable.pScreen,
+ RegionContainsPoint(
wInputShape(pWin),
x - pWin->drawable.x,
y - pWin->drawable.y, &box)))
@@ -3513,16 +3505,14 @@ PointInWindowIsVisible(register WindowPtr pWin, int x, int y)
RegionPtr
NotClippedByChildren(register WindowPtr pWin)
{
- register ScreenPtr pScreen;
RegionPtr pReg;
- pScreen = pWin->drawable.pScreen;
- pReg = REGION_CREATE(pScreen, NullBox, 1);
+ pReg = RegionCreate(NullBox, 1);
if (pWin->parent ||
screenIsSaved != SCREEN_SAVER_ON ||
!HasSaverWindow (pWin->drawable.pScreen->myNum))
{
- REGION_INTERSECT(pScreen, pReg, &pWin->borderClip, &pWin->winSize);
+ RegionIntersect(pReg, &pWin->borderClip, &pWin->winSize);
}
return(pReg);
}
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
index 1dbd059ac..67c514714 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
@@ -160,11 +160,11 @@ PixmapPtr nxagentCreatePixmap(ScreenPtr pScreen, int width,
box.x2 = width;
box.y2 = height;
- pPixmapPriv -> corruptedRegion = REGION_CREATE(pPixmap -> drawable.pScreen, &box, 1);
+ pPixmapPriv -> corruptedRegion = RegionCreate(&box, 1);
}
else
{
- pPixmapPriv -> corruptedRegion = REGION_CREATE(pPixmap -> drawable.pScreen, (BoxRec *) NULL, 1);
+ pPixmapPriv -> corruptedRegion = RegionCreate((BoxRec *) NULL, 1);
}
pPixmapPriv -> corruptedBackground = 0;
@@ -269,7 +269,7 @@ PixmapPtr nxagentCreatePixmap(ScreenPtr pScreen, int width,
pVirtualPriv -> isVirtual = True;
pVirtualPriv -> isShared = nxagentShmPixmapTrap;
- pVirtualPriv -> corruptedRegion = REGION_CREATE(pVirtual -> drawable.pScreen, (BoxRec *) NULL, 1);
+ pVirtualPriv -> corruptedRegion = RegionCreate((BoxRec *) NULL, 1);
pVirtualPriv -> corruptedBackground = 0;
@@ -444,7 +444,7 @@ Bool nxagentDestroyPixmap(PixmapPtr pPixmap)
if (pPixmapPriv -> corruptedRegion != NullRegion)
{
- REGION_DESTROY(pPixmap -> drawable.pScreen, pPixmapPriv -> corruptedRegion);
+ RegionDestroy(pPixmapPriv -> corruptedRegion);
pPixmapPriv -> corruptedRegion = NullRegion;
}
@@ -512,7 +512,7 @@ Bool nxagentDestroyVirtualPixmap(PixmapPtr pPixmap)
if (pVirtualPriv -> corruptedRegion != NullRegion)
{
- REGION_DESTROY(pVirtual -> drawable.pScreen, pVirtualPriv -> corruptedRegion);
+ RegionDestroy(pVirtualPriv -> corruptedRegion);
pVirtualPriv -> corruptedRegion = NullRegion;
}
@@ -752,11 +752,11 @@ void nxagentDisconnectPixmap(void *p0, XID x1, void *p2)
{
PixmapPtr pPixmap = (PixmapPtr) p0;
+ #ifdef TEST
Bool *pBool;
pBool = (Bool*) p2;
- #ifdef TEST
fprintf(stderr, "nxagentDisconnectPixmap: Called with bool [%d] and pixmap at [%p].\n",
*pBool, (void *) pPixmap);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Render.c b/nx-X11/programs/Xserver/hw/nxagent/Render.c
index 8bf1ac0bf..de1ad1207 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Render.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Render.c
@@ -1240,7 +1240,7 @@ void nxagentGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
pRegion = nxagentCreateRegion(pDst -> pDrawable, NULL, glyphBox.x1, glyphBox.y1,
glyphBox.x2 - glyphBox.x1, glyphBox.y2 - glyphBox.y1);
- if (REGION_NIL(pRegion) == 1)
+ if (RegionNil(pRegion) == 1)
{
#ifdef TEST
fprintf(stderr, "nxagentGlyphs: WARNING! Glyphs prevented on hidden window at [%p].\n",
@@ -1602,24 +1602,24 @@ void nxagentCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor *color,
(op == PictOpSrc ||
(op == PictOpOver && color -> alpha == 0xffff)))
{
- rectRegion = RECTS_TO_REGION(pDst -> pDrawable -> pScreen, nRect, rects, CT_REGION);
+ rectRegion = RegionFromRects(nRect, rects, CT_REGION);
if (pDst -> clientClipType != CT_NONE)
{
RegionRec tmpRegion;
- REGION_INIT(pDst -> pDrawable -> pScreen, &tmpRegion, NullBox, 1);
+ RegionInit(&tmpRegion, NullBox, 1);
- REGION_COPY(pDst -> pDrawable -> pScreen, &tmpRegion, (RegionPtr) pDst -> clientClip);
+ RegionCopy(&tmpRegion, (RegionPtr) pDst -> clientClip);
if (pDst -> clipOrigin.x != 0 || pDst -> clipOrigin.y != 0)
{
- REGION_TRANSLATE(pDst -> pDrawable -> pScreen, &tmpRegion, pDst -> clipOrigin.x, pDst -> clipOrigin.y);
+ RegionTranslate(&tmpRegion, pDst -> clipOrigin.x, pDst -> clipOrigin.y);
}
- REGION_INTERSECT(pDst -> pDrawable -> pScreen, rectRegion, rectRegion, &tmpRegion);
+ RegionIntersect(rectRegion, rectRegion, &tmpRegion);
- REGION_UNINIT(pDst -> pDrawable -> pScreen, &tmpRegion);
+ RegionUninit(&tmpRegion);
}
#ifdef TEST
@@ -1629,7 +1629,7 @@ void nxagentCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor *color,
nxagentUnmarkCorruptedRegion(pDst -> pDrawable, rectRegion);
- REGION_DESTROY(pDrawable -> pScreen, rectRegion);
+ RegionDestroy(rectRegion);
}
XRenderFillRectangles(nxagentDisplay,
@@ -1716,7 +1716,7 @@ FIXME: Is this useful or just a waste of bandwidth?
*/
if (nxagentDrawableStatus(pDst -> pDrawable) == NotSynchronized &&
- RECT_IN_REGION(pDst -> pDrawable -> pScreen, nxagentCorruptedRegion(pDst -> pDrawable),
+ RegionContainsRect(nxagentCorruptedRegion(pDst -> pDrawable),
nxagentTrapezoidExtents) == rgnIN)
{
#ifdef TEST
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
index 53a3b3fb7..4cf4afcad 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
@@ -772,7 +772,7 @@ int nxagentExportProperty(pWin, property, type, format, mode, nUnits, value)
{
#ifdef WARNING
fprintf(stderr, "nxagentExportProperty: WARNING! "
- "Property [%lu] too long.\n", propertyX);
+ "Property [%lu] too long.\n", (long unsigned int)propertyX);
#endif
goto nxagentExportPropertyError;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Screen.c b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
index a677b7eb4..83bcc01fd 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Screen.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
@@ -171,6 +171,7 @@ WindowPtr nxagentViewportFrameBelow;
Bool nxagentCreateScreenResources(ScreenPtr pScreen);
void nxagentPrintAgentGeometry(char *hdrMessage, char *prefix);
+
/*
* These variables are for shadowing feature.
*/
@@ -390,8 +391,8 @@ Window nxagentCreateIconWindow()
valuemask, &attributes);
#ifdef TEST
- fprintf(stderr, "nxagentCreateIconWindow: Created new icon window with id [%ld].\n",
- nxagentIconWindow);
+ fprintf(stderr, "nxagentCreateIconWindow: Created new icon window with id [%lu].\n",
+ (long unsigned int)nxagentIconWindow);
#endif
/*
@@ -453,7 +454,7 @@ void nxagentSetScreenSaverTime(void)
{
#ifdef TEST
fprintf(stderr, "nxagentSetScreenSaverTime: ScreenSaverTime was [%lu], ScreenSaverInterval was [%lu].\n",
- ScreenSaverTime, ScreenSaverInterval);
+ (long unsigned int)ScreenSaverTime, (long unsigned int)ScreenSaverInterval);
#endif
/*
@@ -473,7 +474,7 @@ void nxagentSetScreenSaverTime(void)
#ifdef TEST
fprintf(stderr, "nxagentSetScreenSaverTime: ScreenSaverTime now is [%lu], ScreenSaverInterval now is [%lu].\n",
- ScreenSaverTime, ScreenSaverInterval);
+ (long unsigned int)ScreenSaverTime, (long unsigned int)ScreenSaverInterval);
#endif
}
@@ -1231,7 +1232,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
#if defined(DEBUG) || defined(DEBUG_COLORMAP)
fprintf(stderr, "Debug: Added visual [%lu].\n" ,
- visuals[numVisuals].vid);
+ (long unsigned int)visuals[numVisuals].vid);
#endif
for (j = 0; j < numDepths; j++)
@@ -1270,7 +1271,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
#if defined(DEBUG) || defined(DEBUG_COLORMAP)
fprintf(stderr, "Debug: Registered visual [%lu] for depth [%d (%d)].\n" ,
- visuals[numVisuals].vid, depthIndex,
+ (long unsigned int)visuals[numVisuals].vid, depthIndex,
depths[depthIndex].depth);
#endif
@@ -1279,7 +1280,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
#if defined(DEBUG) || defined(DEBUG_COLORMAP)
fprintf(stderr, "Debug: Setting default visual [%d (%lu)].\n",
- defaultVisualIndex, visuals[defaultVisualIndex].vid);
+ defaultVisualIndex, (long unsigned int)visuals[defaultVisualIndex].vid);
fprintf(stderr, "Debug: Setting root depth [%d].\n",
visuals[defaultVisualIndex].nplanes);
@@ -1315,8 +1316,8 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
#if defined(DEBUG) || defined(DEBUG_COLORMAP)
fprintf(stderr, "nxagentOpenScreen: Before fbScreenInit numVisuals [%d] numDepths [%d] "
- "rootDepth [%d] defaultVisual [%ld].\n", numVisuals, numDepths,
- rootDepth, defaultVisual);
+ "rootDepth [%d] defaultVisual [%lu].\n", numVisuals, numDepths,
+ rootDepth, (long unsigned int)defaultVisual);
#endif
if (monitorResolution < 1)
@@ -1332,8 +1333,8 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
#if defined(DEBUG) || defined(DEBUG_COLORMAP)
fprintf(stderr, "nxagentOpenScreen: After fbScreenInit numVisuals [%d] numDepths [%d] "
- "rootDepth [%d] defaultVisual [%ld].\n", numVisuals, numDepths,
- rootDepth, defaultVisual);
+ "rootDepth [%d] defaultVisual [%lu].\n", numVisuals, numDepths,
+ rootDepth, (long unsigned int)defaultVisual);
#endif
/*
@@ -1344,8 +1345,8 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
#if defined(DEBUG) || defined(DEBUG_COLORMAP)
fprintf(stderr, "nxagentOpenScreen: Before GLX numVisuals [%d] numDepths [%d] "
- "rootDepth [%d] defaultVisual [%ld].\n", numVisuals, numDepths,
- rootDepth, defaultVisual);
+ "rootDepth [%d] defaultVisual [%lu].\n", numVisuals, numDepths,
+ rootDepth, (long unsigned int)defaultVisual);
#endif
nxagentInitGlxExtension(&visuals, &depths, &numVisuals, &numDepths,
@@ -1353,8 +1354,8 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
#if defined(DEBUG) || defined(DEBUG_COLORMAP)
fprintf(stderr, "nxagentOpenScreen: After GLX numVisuals [%d] numDepths [%d] "
- "rootDepth [%d] defaultVisual [%ld].\n", numVisuals, numDepths,
- rootDepth, defaultVisual);
+ "rootDepth [%d] defaultVisual [%lu].\n", numVisuals, numDepths,
+ rootDepth, (long unsigned int)defaultVisual);
#endif
/*
@@ -1720,7 +1721,7 @@ N/A
#ifdef TEST
fprintf(stderr, "nxagentOpenScreen: Using root window id [%ld].\n",
- nxagentDefaultWindows[pScreen->myNum]);
+ (long int)nxagentDefaultWindows[pScreen->myNum]);
#endif
}
@@ -1760,7 +1761,7 @@ N/A
#ifdef TEST
fprintf(stderr, "nxagentOpenScreen: Created new default window with id [%ld].\n",
- nxagentDefaultWindows[pScreen->myNum]);
+ (long int)nxagentDefaultWindows[pScreen->myNum]);
#endif
/*
@@ -1772,7 +1773,7 @@ N/A
{
#ifdef TEST
fprintf(stderr, "nxagentOpenScreen: Setting WM_CLASS and WM_NAME for window withid [%ld].\n",
- nxagentDefaultWindows[pScreen->myNum]);
+ (long int)nxagentDefaultWindows[pScreen->myNum]);
#endif
XClassHint hint;
hint.res_name=malloc(strlen("X2GoAgent")+1);
@@ -1787,7 +1788,7 @@ N/A
{
#ifdef TEST
fprintf(stderr, "nxagentOpenScreen: Setting WM_CLASS and WM_NAME for window withid [%ld].\n",
- nxagentDefaultWindows[pScreen->myNum]);
+ (long int)nxagentDefaultWindows[pScreen->myNum]);
#endif
XClassHint hint;
@@ -2147,8 +2148,8 @@ static void nxagentSetRootClip (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;
}
@@ -2167,18 +2168,18 @@ static void nxagentSetRootClip (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);
@@ -2187,8 +2188,8 @@ static void nxagentSetRootClip (ScreenPtr pScreen, Bool 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)
@@ -2223,7 +2224,7 @@ static void nxagentSetRootClip (ScreenPtr pScreen, Bool enable)
(pWin, 0, 0, pOldClip,
pWin->drawable.x, pWin->drawable.y);
if (WasViewable)
- REGION_DESTROY(pScreen, pOldClip);
+ RegionDestroy(pOldClip);
if (bsExposed)
{
RegionPtr valExposed = NullRegion;
@@ -2232,8 +2233,8 @@ static void nxagentSetRootClip (ScreenPtr pScreen, Bool 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)
@@ -2418,10 +2419,10 @@ FIXME: We should try to restore the previously
WindowTable[pScreen -> myNum] -> drawable.x = 0;
WindowTable[pScreen -> myNum] -> drawable.y = 0;
- REGION_INIT(pScreen, &WindowTable[pScreen -> myNum] -> borderSize, &box, 1);
- REGION_INIT(pScreen, &WindowTable[pScreen -> myNum] -> winSize, &box, 1);
- REGION_INIT(pScreen, &WindowTable[pScreen -> myNum] -> clipList, &box, 1);
- REGION_INIT(pScreen, &WindowTable[pScreen -> myNum] -> borderClip, &box, 1);
+ RegionInit(&WindowTable[pScreen -> myNum] -> borderSize, &box, 1);
+ RegionInit(&WindowTable[pScreen -> myNum] -> winSize, &box, 1);
+ RegionInit(&WindowTable[pScreen -> myNum] -> clipList, &box, 1);
+ RegionInit(&WindowTable[pScreen -> myNum] -> borderClip, &box, 1);
(*pScreen -> PositionWindow)(WindowTable[pScreen -> myNum], 0, 0);
@@ -2819,7 +2820,7 @@ int nxagentShadowInit(ScreenPtr pScreen, WindowPtr pWin)
XFreeGC(nxagentDisplay, gc);
- REGION_INIT(pScreen, &nxagentShadowUpdateRegion, (BoxRec*)NULL, 1);
+ RegionInit(&nxagentShadowUpdateRegion, (BoxRec*)NULL, 1);
return 0;
}
@@ -2973,14 +2974,14 @@ int nxagentShadowSendUpdates(int *suspended)
{
*suspended = 0;
- if (REGION_NIL(&nxagentShadowUpdateRegion) == 1)
+ if (RegionNil(&nxagentShadowUpdateRegion) == 1)
{
return 0;
}
nxagentMarkCorruptedRegion((DrawablePtr)nxagentShadowPixmapPtr, &nxagentShadowUpdateRegion);
- REGION_EMPTY(nxagentShadowPixmapPtr -> drawable.pScreen, &nxagentShadowUpdateRegion);
+ RegionEmpty(&nxagentShadowUpdateRegion);
return 1;
}
@@ -3002,9 +3003,9 @@ int nxagentShadowPoll(PixmapPtr nxagentShadowPixmapPtr, GCPtr nxagentShadowGCPtr
int overlap;
- REGION_NULL(pScreen, &updateRegion);
+ RegionNull(&updateRegion);
- REGION_NULL(pScreen, &tempRegion);
+ RegionNull(&tempRegion);
#ifdef __CYGWIN32__
@@ -3116,15 +3117,15 @@ int nxagentShadowPoll(PixmapPtr nxagentShadowPixmapPtr, GCPtr nxagentShadowGCPtr
box.y1 = y;
box.y2 = y + height;
- REGION_INIT(pScreen, &tempRegion, &box, 1);
+ RegionInit(&tempRegion, &box, 1);
- REGION_APPEND(pScreen, &updateRegion, &tempRegion);
+ RegionAppend(&updateRegion, &tempRegion);
- REGION_UNINIT(pScreen, &tempRegion);
+ RegionUninit(&tempRegion);
- REGION_VALIDATE(pScreen, &updateRegion, &overlap);
+ RegionValidate(&updateRegion, &overlap);
- REGION_UNION(pScreen, &nxagentShadowUpdateRegion, &nxagentShadowUpdateRegion, &updateRegion);
+ RegionUnion(&nxagentShadowUpdateRegion, &nxagentShadowUpdateRegion, &updateRegion);
}
if (tBuffer)
@@ -3132,7 +3133,7 @@ int nxagentShadowPoll(PixmapPtr nxagentShadowPixmapPtr, GCPtr nxagentShadowGCPtr
xfree(tBuffer);
}
- REGION_UNINIT(pScreen, &updateRegion);
+ RegionUninit(&updateRegion);
}
else if (result == -1)
{
@@ -3185,7 +3186,7 @@ void nxagentShadowAdaptDepth(unsigned int width, unsigned int height,
}
#ifdef TEST
- fprintf(stderr, "nxagentCorrectDepthShadow: Shadow redMask [%x] greenMask[%x] blueMask[%x].\n",
+ fprintf(stderr, "nxagentCorrectDepthShadow: Shadow redMask [%lu] greenMask[%lu] blueMask[%lu].\n",
pVisual -> red_mask, pVisual -> green_mask, pVisual -> blue_mask);
#endif
@@ -3194,7 +3195,7 @@ void nxagentShadowAdaptDepth(unsigned int width, unsigned int height,
blueMask = nxagentShadowDisplay -> screens[0].root_visual[0].blue_mask;
#ifdef TEST
- fprintf(stderr, "nxagentCorrectDepthShadow: Master redMask [%x] greenMask[%x] blueMask[%x].\n",
+ fprintf(stderr, "nxagentCorrectDepthShadow: Master redMask [%lu] greenMask[%lu] blueMask[%lu].\n",
redMask, greenMask, blueMask);
#endif
@@ -3544,11 +3545,8 @@ Bool nxagentReconnectScreen(void *p0)
{
CARD16 w, h;
PixmapPtr pPixmap = (PixmapPtr)nxagentDefaultScreen->devPrivate;
- int flexibility;
Mask mask;
- flexibility = *(int*)p0;
-
#if defined(NXAGENT_RECONNECT_DEBUG) || defined(NXAGENT_RECONNECT_SCREEN_DEBUG)
fprintf(stderr, "nxagentReconnectScreen\n");
#endif
@@ -3595,10 +3593,6 @@ Bool nxagentReconnectScreen(void *p0)
return True;
}
-/* FIXME: there must be such macros somewhere already...*/
-#define MAX(a,b) ((a) > (b)) ? (a) : (b);
-#define MIN(a,b) ((a) < (b)) ? (a) : (b);
-
/* intersect two rectangles */
Bool intersect(int ax1, int ay1, unsigned int aw, unsigned int ah,
int bx1, int by1, unsigned int bw, unsigned int bh,
@@ -3743,7 +3737,7 @@ int nxagentAdjustRandRXinerama(ScreenPtr pScreen)
if (pScrPriv)
{
- int i, j;
+ int i;
int number = 0;
XineramaScreenInfo *screeninfo = NULL;
@@ -4113,7 +4107,6 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
nxagentPrivPixmapPtr pPrivPixmap;
XlibGC gc;
XGCValues values;
- DrawablePtr pDrawable;
int i;
int xSrc, ySrc, xDst, yDst, w, h;
int nRects;
@@ -4131,10 +4124,8 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
pPrivPixmap -> isBackingPixmap = 1;
- fbCopyWindowProc(&pWin -> drawable, &pVirtualPixmap -> drawable, 0, REGION_RECTS(prgnSave),
- REGION_NUM_RECTS(prgnSave), xorg, yorg, FALSE, FALSE, 0, 0);
-
- pDrawable = &pWin -> drawable;
+ fbCopyWindowProc(&pWin -> drawable, &pVirtualPixmap -> drawable, 0, RegionRects(prgnSave),
+ RegionNumRects(prgnSave), xorg, yorg, FALSE, FALSE, 0, 0);
values.subwindow_mode = IncludeInferiors;
@@ -4145,34 +4136,34 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
* Coordinates are relative to the window.
*/
- REGION_INIT(pWin -> pScreen, &cleanRegion, NullBox, 1);
+ RegionInit(&cleanRegion, NullBox, 1);
- REGION_COPY(pWin -> pScreen, &cleanRegion, nxagentCorruptedRegion((DrawablePtr) pWin));
+ RegionCopy(&cleanRegion, nxagentCorruptedRegion((DrawablePtr) pWin));
/*
* Subtract the corrupted region from the saved region.
*/
- REGION_SUBTRACT(pWin -> pScreen, &pBackingStore -> SavedRegion, &pBackingStore -> SavedRegion, &cleanRegion);
+ RegionSubtract(&pBackingStore -> SavedRegion, &pBackingStore -> SavedRegion, &cleanRegion);
/*
* Translate the corrupted region. Coordinates
* are relative to the backing store pixmap.
*/
- REGION_TRANSLATE(pWin -> pScreen, &cleanRegion, -pBackingStore -> x, -pBackingStore -> y);
+ RegionTranslate(&cleanRegion, -pBackingStore -> x, -pBackingStore -> y);
/*
* Compute the clean region to be saved: subtract
* the corrupted region from the region to be saved.
*/
- REGION_SUBTRACT(pWin -> pScreen, &cleanRegion, prgnSave, &cleanRegion);
+ RegionSubtract(&cleanRegion, prgnSave, &cleanRegion);
- nRects = REGION_NUM_RECTS(&cleanRegion);
+ nRects = RegionNumRects(&cleanRegion);
size = nRects * sizeof(*pRects);
pRects = (XRectangle *) xalloc(size);
- pBox = REGION_RECTS(&cleanRegion);
+ pBox = RegionRects(&cleanRegion);
for (i = nRects; i-- > 0;)
{
@@ -4186,9 +4177,9 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
xfree((char *) pRects);
- extents = *REGION_EXTENTS(pWin -> pScreen, &cleanRegion);
+ extents = *RegionExtents(&cleanRegion);
- REGION_UNINIT(pWin -> pScreen, &cleanRegion);
+ RegionUninit(&cleanRegion);
xDst = extents.x1;
yDst = extents.y1;
@@ -4233,7 +4224,6 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
RegionPtr clipRegion;
XlibGC gc;
XGCValues values;
- DrawablePtr pDrawable;
int i;
int xSrc, ySrc, xDst, yDst, w, h;
int nRects;
@@ -4248,17 +4238,15 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
* root window size.
*/
- REGION_INTERSECT(pWin -> pScreen, prgnRestore, prgnRestore,
+ RegionIntersect(prgnRestore, prgnRestore,
&WindowTable[pWin -> drawable.pScreen -> myNum] -> winSize);
pBackingStore = (miBSWindowPtr) pWin -> backStorage;
pVirtualPixmap = nxagentVirtualPixmap(pPixmap);
- fbCopyWindowProc(&pVirtualPixmap -> drawable, &pWin -> drawable, 0, REGION_RECTS(prgnRestore),
- REGION_NUM_RECTS(prgnRestore), -xorg, -yorg, FALSE, FALSE, 0, 0);
-
- pDrawable = &pVirtualPixmap -> drawable;
+ fbCopyWindowProc(&pVirtualPixmap -> drawable, &pWin -> drawable, 0, RegionRects(prgnRestore),
+ RegionNumRects(prgnRestore), -xorg, -yorg, FALSE, FALSE, 0, 0);
values.subwindow_mode = ClipByChildren;
@@ -4268,7 +4256,7 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
* Translate the reference point to the origin of the window.
*/
- REGION_TRANSLATE(pWin -> drawable.pScreen, prgnRestore,
+ RegionTranslate(prgnRestore,
-pWin -> drawable.x - pWin -> borderWidth,
-pWin -> drawable.y - pWin -> borderWidth);
@@ -4276,26 +4264,26 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
if (nxagentDrawableStatus((DrawablePtr) pPixmap) == NotSynchronized)
{
- clipRegion = REGION_CREATE(pPixmap -> drawable -> pScreen, NullBox, 1);
+ clipRegion = RegionCreate(NullBox, 1);
- REGION_COPY(pPixmap -> drawable -> pScreen, clipRegion,
+ RegionCopy(clipRegion,
nxagentCorruptedRegion((DrawablePtr) pPixmap));
/*
* Translate the reference point to the origin of the window.
*/
- REGION_TRANSLATE(pPixmap -> drawable -> pScreen, clipRegion,
+ RegionTranslate(clipRegion,
pBackingStore -> x, pBackingStore -> y);
- REGION_INTERSECT(pPixmap -> drawable -> pScreen, clipRegion, prgnRestore, clipRegion);
+ RegionIntersect(clipRegion, prgnRestore, clipRegion);
/*
* Subtract the corrupted region from the saved areas.
* miBSRestoreAreas will return the exposure region.
*/
- REGION_SUBTRACT(pPixmap -> drawable -> pScreen, &pBackingStore->SavedRegion,
+ RegionSubtract(&pBackingStore->SavedRegion,
&pBackingStore->SavedRegion, clipRegion);
/*
@@ -4304,24 +4292,24 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
if (nxagentRemoteExposeRegion != NULL)
{
- REGION_TRANSLATE(pPixmap -> drawable -> pScreen, clipRegion, pWin -> drawable.x, pWin -> drawable.y);
+ RegionTranslate(clipRegion, pWin -> drawable.x, pWin -> drawable.y);
- REGION_UNION(pScreen, nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, clipRegion);
+ RegionUnion(nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, clipRegion);
- REGION_TRANSLATE(pPixmap -> drawable -> pScreen, clipRegion, -pWin -> drawable.x, -pWin -> drawable.y);
+ RegionTranslate(clipRegion, -pWin -> drawable.x, -pWin -> drawable.y);
}
/*
* Compute the region to be restored.
*/
- REGION_SUBTRACT(pPixmap -> drawable -> pScreen, clipRegion, prgnRestore, clipRegion);
+ RegionSubtract(clipRegion, prgnRestore, clipRegion);
}
- nRects = REGION_NUM_RECTS(clipRegion);
+ nRects = RegionNumRects(clipRegion);
size = nRects * sizeof(*pRects);
pRects = (XRectangle *) xalloc(size);
- pBox = REGION_RECTS(clipRegion);
+ pBox = RegionRects(clipRegion);
for (i = nRects; i-- > 0;)
{
@@ -4335,7 +4323,7 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
xfree(pRects);
- extents = *REGION_EXTENTS(pWin -> pScreen, clipRegion);
+ extents = *RegionExtents(clipRegion);
xDst = extents.x1;
yDst = extents.y1;
@@ -4355,14 +4343,14 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
if (clipRegion != NULL && clipRegion != prgnRestore)
{
- REGION_DESTROY(pPixmap -> drawable -> pScreen, clipRegion);
+ RegionDestroy(clipRegion);
}
/*
* Restore the reference point to the origin of the screen.
*/
- REGION_TRANSLATE(pWin -> drawable.pScreen, prgnRestore,
+ RegionTranslate(prgnRestore,
pWin -> drawable.x - pWin -> borderWidth,
pWin -> drawable.y + pWin -> borderWidth);
@@ -4437,11 +4425,11 @@ void nxagentShadowAdaptToRatio(void)
box.x2 = nxagentShadowPixmapPtr -> drawable.width;
box.y2 = nxagentShadowPixmapPtr -> drawable.height;
- REGION_INIT(pScreen, &region, &box, 1);
+ RegionInit(&region, &box, 1);
nxagentMarkCorruptedRegion((DrawablePtr)nxagentShadowPixmapPtr, &region);
- REGION_UNINIT(pScreen, &region);
+ RegionUninit(&region);
}
void nxagentPrintGeometry()
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Screen.h b/nx-X11/programs/Xserver/hw/nxagent/Screen.h
index aab3ba19c..305d5648f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Screen.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Screen.h
@@ -102,6 +102,8 @@ Bool nxagentResizeScreen(ScreenPtr pScreen, int width, int height,
int nxagentChangeScreenConfig(int screen, int width, int height, int mmWidth, int mmHeight);
+int nxagentAdjustRandRXinerama(ScreenPtr pScreen);
+
extern Bool nxagentReconnectScreen(void *p0);
void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg, WindowPtr pWin);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Splash.c b/nx-X11/programs/Xserver/hw/nxagent/Splash.c
index abb0872d1..a069b3e23 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Splash.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Splash.c
@@ -165,7 +165,6 @@ int nxagentShowSplashWindow(Window parentWindow)
void nxagentPaintLogo(Window win, GC gc, int scale, int width, int height)
{
XPoint rect[4];
- XPoint m[12];
int w, h, c, w2, h2;
/*
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Split.c b/nx-X11/programs/Xserver/hw/nxagent/Split.c
index 4cc2ea607..1840328e4 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Split.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Split.c
@@ -502,7 +502,7 @@ void nxagentReleaseSplit(DrawablePtr pDrawable)
(void *) pDrawable);
#endif
- REGION_DESTROY(pDrawable -> pScreen, pResource -> region);
+ RegionDestroy(pResource -> region);
pResource -> region = NullRegion;
}
@@ -623,11 +623,11 @@ void nxagentValidateSplit(DrawablePtr pDrawable, RegionPtr pRegion)
* streamed.
*/
- REGION_INIT(pDrawable -> pScreen, &tmpRegion, NullBox, 1);
+ RegionInit(&tmpRegion, NullBox, 1);
- REGION_INTERSECT(pDrawable -> pScreen, &tmpRegion, pResource -> region, pRegion);
+ RegionIntersect(&tmpRegion, pResource -> region, pRegion);
- if (REGION_NIL(&tmpRegion) == 0)
+ if (RegionNil(&tmpRegion) == 0)
{
#ifdef TEST
fprintf(stderr, "nxagentValidateSplit: Marking the overlapping commits as invalid "
@@ -644,7 +644,7 @@ void nxagentValidateSplit(DrawablePtr pDrawable, RegionPtr pRegion)
}
#endif
- REGION_UNINIT(pDrawable -> pScreen, &tmpRegion);
+ RegionUninit(&tmpRegion);
}
}
@@ -1097,9 +1097,9 @@ void nxagentHandleEndSplitEvent(int resource)
if (pResource -> drawable != NULL &&
pResource -> region != NullRegion)
{
- if (REGION_NIL(pResource -> region) == 0)
+ if (RegionNil(pResource -> region) == 0)
{
- REGION_SUBTRACT(pResource -> drawable -> pScreen,
+ RegionSubtract(
nxagentCorruptedRegion(pResource -> drawable),
nxagentCorruptedRegion(pResource -> drawable),
pResource -> region);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Utils.h b/nx-X11/programs/Xserver/hw/nxagent/Utils.h
index f5bd55d8b..ef8c4c714 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Utils.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Utils.h
@@ -36,4 +36,8 @@
#define MIN(A, B) ( (A) < (B) ? (A) : (B) )
#endif
+#ifndef MAX
+#define MAX(A, B) ( (A) > (B) ? (A) : (B) );
+#endif
+
#endif /* __Utils_H__ */
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Window.c b/nx-X11/programs/Xserver/hw/nxagent/Window.c
index 782ab9c9c..fb26b8242 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Window.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Window.c
@@ -388,7 +388,7 @@ FIXME: We need to set save under on the real display?
nxagentWindowPriv(pWin) -> visibilityState = VisibilityUnobscured;
- nxagentWindowPriv(pWin) -> corruptedRegion = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1);
+ nxagentWindowPriv(pWin) -> corruptedRegion = RegionCreate(NULL, 1);
nxagentWindowPriv(pWin) -> hasTransparentChildren = 0;
@@ -486,8 +486,8 @@ FIXME: Do all the windows for which nxagentWindowTopLevel(pWin)
#endif /* SHAPE */
#else
#ifdef SHAPE
- nxagentWindowPriv(pWin)->boundingShape = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
- nxagentWindowPriv(pWin)->clipShape = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
+ nxagentWindowPriv(pWin)->boundingShape = RegionCreate(NULL, 1);
+ nxagentWindowPriv(pWin)->clipShape = RegionCreate(NULL, 1);
#endif /* SHAPE */
#endif
@@ -546,14 +546,14 @@ Bool nxagentDestroyWindow(WindowPtr pWin)
{
if (nxagentExposeQueue.exposures[i].localRegion != NullRegion)
{
- REGION_DESTROY(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[i].localRegion);
+ RegionDestroy(nxagentExposeQueue.exposures[i].localRegion);
}
nxagentExposeQueue.exposures[i].localRegion = NullRegion;
if (nxagentExposeQueue.exposures[i].remoteRegion != NullRegion)
{
- REGION_DESTROY(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[i].remoteRegion);
+ RegionDestroy(nxagentExposeQueue.exposures[i].remoteRegion);
}
nxagentExposeQueue.exposures[i].remoteRegion = NullRegion;
@@ -576,13 +576,13 @@ Bool nxagentDestroyWindow(WindowPtr pWin)
if (pWindowPriv->boundingShape)
{
- REGION_DESTROY(pWin->drawable.pScreen,
+ RegionDestroy(
pWindowPriv->boundingShape);
}
if (pWindowPriv->clipShape)
{
- REGION_DESTROY(pWin->drawable.pScreen,
+ RegionDestroy(
pWindowPriv->clipShape);
}
@@ -590,17 +590,17 @@ Bool nxagentDestroyWindow(WindowPtr pWin)
#else
- REGION_DESTROY(pWin->drawable.pScreen,
+ RegionDestroy(
pWindowPriv->boundingShape);
- REGION_DESTROY(pWin->drawable.pScreen,
+ RegionDestroy(
pWindowPriv->clipShape);
#endif
if (pWindowPriv -> corruptedRegion)
{
- REGION_DESTROY(pWin -> drawable.pScreen,
+ RegionDestroy(
pWindowPriv -> corruptedRegion);
pWindowPriv -> corruptedRegion = NULL;
@@ -1342,7 +1342,7 @@ void nxagentConfigureWindow(WindowPtr pWin, unsigned int mask)
if (nxagentExposeQueue.exposures[i].pWindow == pWin &&
nxagentExposeQueue.exposures[i].remoteRegion != NullRegion)
{
- REGION_TRANSLATE(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[i].remoteRegion, offX, offY);
+ RegionTranslate(nxagentExposeQueue.exposures[i].remoteRegion, offX, offY);
}
}
}
@@ -1989,9 +1989,9 @@ void nxagentPaintWindowBackground(pWin, pRegion, what)
{
BoxPtr pBox;
- pBox = REGION_RECTS(pRegion);
+ pBox = RegionRects(pRegion);
- for (i = 0; i < REGION_NUM_RECTS(pRegion); i++)
+ for (i = 0; i < RegionNumRects(pRegion); i++)
{
XClearArea(nxagentDisplay, nxagentWindow(pWin),
pBox[i].x1 - pWin->drawable.x,
@@ -2015,13 +2015,13 @@ void nxagentPaintWindowBackground(pWin, pRegion, what)
* so we need to clip ourselves.
*/
- REGION_INIT(pWin -> drawable.pScreen, &temp, NullBox, 1);
+ RegionInit(&temp, NullBox, 1);
- REGION_INTERSECT(pWin -> drawable.pScreen, &temp, pRegion, &pWin -> clipList);
+ RegionIntersect(&temp, pRegion, &pWin -> clipList);
nxagentFrameBufferPaintWindow(pWin, &temp, what);
- REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+ RegionUninit(&temp);
}
void nxagentPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion, int what)
@@ -2034,13 +2034,13 @@ void nxagentPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion, int what)
* so we need to clip ourselves.
*/
- REGION_INIT(pWin -> drawable.pScreen, &temp, NullBox, 1);
+ RegionInit(&temp, NullBox, 1);
- REGION_INTERSECT(pWin -> drawable.pScreen, &temp, pRegion, &pWin -> borderClip);
+ RegionIntersect(&temp, pRegion, &pWin -> borderClip);
nxagentFrameBufferPaintWindow(pWin, &temp, what);
- REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+ RegionUninit(&temp);
}
void nxagentCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion)
@@ -2149,49 +2149,48 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
nxagentExposeArrayIsInitialized = 1;
}
- REGION_INIT(pWin -> drawable.pScreen, &temp, (BoxRec *) NULL, 1);
+ RegionInit(&temp, (BoxRec *) NULL, 1);
if (pRgn != NULL)
{
- if (REGION_NUM_RECTS(pRgn) > RECTLIMIT)
+ if (RegionNumRects(pRgn) > RECTLIMIT)
{
- box = *REGION_EXTENTS(pWin -> drawable.pScreen, pRgn);
+ box = *RegionExtents(pRgn);
- REGION_EMPTY(pWin -> drawable.pScreen, pRgn);
- REGION_INIT(pWin -> drawable.pScreen, pRgn, &box, 1);
+ RegionEmpty(pRgn);
+ RegionInit(pRgn, &box, 1);
}
- REGION_UNION(pWin -> drawable.pScreen, &temp, &temp, pRgn);
+ RegionUnion(&temp, &temp, pRgn);
}
if (other_exposed != NULL)
{
- REGION_UNION(pWin -> drawable.pScreen, &temp, &temp, other_exposed);
+ RegionUnion(&temp, &temp, other_exposed);
}
- if (REGION_NIL(&temp) == 0)
+ if (RegionNil(&temp) == 0)
{
- REGION_TRANSLATE(pWin -> drawable.pScreen, &temp,
+ RegionTranslate(&temp,
-(pWin -> drawable.x), -(pWin -> drawable.y));
if (nxagentExposeQueue.length < EXPOSED_SIZE)
{
- XWindowChanges changes;
int index;
index = (nxagentExposeQueue.start + nxagentExposeQueue.length) % EXPOSED_SIZE;
nxagentExposeQueue.exposures[index].pWindow = pWin;
- nxagentExposeQueue.exposures[index].localRegion = REGION_CREATE(pwin -> drawable.pScreen, NULL, 1);
+ nxagentExposeQueue.exposures[index].localRegion = RegionCreate(NULL, 1);
if (nxagentOption(Rootless) && nxagentWindowPriv(pWin) &&
(nxagentWindowPriv(pWin) -> isMapped == 0 ||
nxagentWindowPriv(pWin) -> visibilityState != VisibilityUnobscured))
{
- nxagentExposeQueue.exposures[index].remoteRegion = REGION_CREATE(pwin -> drawable.pScreen, NULL, 1);
+ nxagentExposeQueue.exposures[index].remoteRegion = RegionCreate(NULL, 1);
- REGION_UNION(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[index].remoteRegion,
+ RegionUnion(nxagentExposeQueue.exposures[index].remoteRegion,
nxagentExposeQueue.exposures[index].remoteRegion, &temp);
#ifdef TEST
@@ -2201,7 +2200,7 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
}
else
{
- REGION_UNION(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[index].localRegion,
+ RegionUnion(nxagentExposeQueue.exposures[index].localRegion,
nxagentExposeQueue.exposures[index].localRegion, &temp);
#ifdef TEST
@@ -2212,9 +2211,6 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
nxagentExposeSerial = (nxagentExposeSerial - 1) % EXPOSED_SIZE;
- changes.x = nxagentExposeSerial;
- changes.y = -2;
-
nxagentExposeQueue.exposures[index].serial = nxagentExposeSerial;
#ifdef TEST
@@ -2234,21 +2230,21 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
(nxagentWindowPriv(pWin) -> isMapped == 0 ||
nxagentWindowPriv(pWin) -> visibilityState != VisibilityUnobscured))
{
- REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+ RegionUninit(&temp);
return;
}
}
else
{
- REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+ RegionUninit(&temp);
#ifdef TEST
fprintf(stderr, "nxagentWindowExposures: WARNING! Reached maximum size of collect exposures vector.\n");
#endif
- if ((pRgn != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, pRgn) != 0) ||
- (other_exposed != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, other_exposed) != 0))
+ if ((pRgn != NULL && RegionNotEmpty(pRgn) != 0) ||
+ (other_exposed != NULL && RegionNotEmpty(other_exposed) != 0))
{
nxagentUnmarkExposedRegion(pWin, pRgn, other_exposed);
@@ -2259,11 +2255,11 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
}
}
- REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+ RegionUninit(&temp);
}
- if ((pRgn != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, pRgn) != 0) ||
- (other_exposed != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, other_exposed) != 0))
+ if ((pRgn != NULL && RegionNotEmpty(pRgn) != 0) ||
+ (other_exposed != NULL && RegionNotEmpty(other_exposed) != 0))
{
nxagentUnmarkExposedRegion(pWin, pRgn, other_exposed);
@@ -2283,11 +2279,11 @@ static Bool nxagentRegionEqual(RegionPtr pReg1, RegionPtr pReg2)
if (pReg1 == NullRegion || pReg2 == NullRegion) return False;
- pBox1 = REGION_RECTS(pReg1);
- n1 = REGION_NUM_RECTS(pReg1);
+ pBox1 = RegionRects(pReg1);
+ n1 = RegionNumRects(pReg1);
- pBox2 = REGION_RECTS(pReg2);
- n2 = REGION_NUM_RECTS(pReg2);
+ pBox2 = RegionRects(pReg2);
+ n2 = RegionNumRects(pReg2);
if (n1 != n2) return False;
@@ -2326,23 +2322,23 @@ void nxagentShapeWindow(WindowPtr pWin)
{
#ifdef DEBUG
fprintf(stderr, "nxagentShapeWindow: wBounding shape has [%ld] rects.\n",
- REGION_NUM_RECTS(wBoundingShape(pWin)));
+ RegionNumRects(wBoundingShape(pWin)));
#endif
#ifdef NXAGENT_SHAPE2
if (!nxagentWindowPriv(pWin)->boundingShape)
{
- nxagentWindowPriv(pWin)->boundingShape = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
+ nxagentWindowPriv(pWin)->boundingShape = RegionCreate(NULL, 1);
}
#endif
- REGION_COPY(pWin->drawable.pScreen,
+ RegionCopy(
nxagentWindowPriv(pWin)->boundingShape, wBoundingShape(pWin));
reg = XCreateRegion();
- pBox = REGION_RECTS(nxagentWindowPriv(pWin)->boundingShape);
+ pBox = RegionRects(nxagentWindowPriv(pWin)->boundingShape);
for (i = 0;
- i < REGION_NUM_RECTS(nxagentWindowPriv(pWin)->boundingShape);
+ i < RegionNumRects(nxagentWindowPriv(pWin)->boundingShape);
i++)
{
rect.x = pBox[i].x1;
@@ -2365,7 +2361,7 @@ void nxagentShapeWindow(WindowPtr pWin)
fprintf(stderr, "nxagentShapeWindow: wBounding shape does not exist. Removing the shape.\n");
#endif
- REGION_EMPTY(pWin->drawable.pScreen,
+ RegionEmpty(
nxagentWindowPriv(pWin)->boundingShape);
#ifndef NXAGENT_SHAPE
@@ -2386,23 +2382,23 @@ void nxagentShapeWindow(WindowPtr pWin)
{
#ifdef DEBUG
fprintf(stderr, "nxagentShapeWindow: wClip shape has [%ld] rects.\n",
- REGION_NUM_RECTS(wClipShape(pWin)));
+ RegionNumRects(wClipShape(pWin)));
#endif
#ifdef NXAGENT_SHAPE2
if (!nxagentWindowPriv(pWin)->clipShape)
{
- nxagentWindowPriv(pWin)->clipShape = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
+ nxagentWindowPriv(pWin)->clipShape = RegionCreate(NULL, 1);
}
#endif
- REGION_COPY(pWin->drawable.pScreen,
+ RegionCopy(
nxagentWindowPriv(pWin)->clipShape, wClipShape(pWin));
reg = XCreateRegion();
- pBox = REGION_RECTS(nxagentWindowPriv(pWin)->clipShape);
+ pBox = RegionRects(nxagentWindowPriv(pWin)->clipShape);
for (i = 0;
- i < REGION_NUM_RECTS(nxagentWindowPriv(pWin)->clipShape);
+ i < RegionNumRects(nxagentWindowPriv(pWin)->clipShape);
i++)
{
rect.x = pBox[i].x1;
@@ -2425,7 +2421,7 @@ void nxagentShapeWindow(WindowPtr pWin)
fprintf(stderr, "nxagentShapeWindow: wClip shape does not exist. Removing the shape.\n");
#endif
- REGION_EMPTY(pWin->drawable.pScreen,
+ RegionEmpty(
nxagentWindowPriv(pWin)->clipShape);
#ifndef NXAGENT_SHAPE
@@ -2450,15 +2446,15 @@ static int nxagentForceExposure(WindowPtr pWin, void * ptr)
Box.x2 = Box.x1 + pWin->drawable.width;
Box.y2 = Box.y1 + pWin->drawable.height;
- exposedRgn = REGION_CREATE(pWin->drawable.pScreen, &Box, 1);
- REGION_INTERSECT(pWin->drawable.pScreen, exposedRgn, exposedRgn, &pRoot->winSize);
+ exposedRgn = RegionCreate(&Box, 1);
+ RegionIntersect(exposedRgn, exposedRgn, &pRoot->winSize);
- if (exposedRgn != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, exposedRgn) != 0)
+ if (exposedRgn != NULL && RegionNotEmpty(exposedRgn) != 0)
{
miWindowExposures(pWin, exposedRgn, NullRegion);
}
- REGION_DESTROY(pWin->drawable.pScreen, exposedRgn);
+ RegionDestroy(exposedRgn);
}
return WT_WALKCHILDREN;
@@ -3186,14 +3182,14 @@ static void nxagentReconfigureWindow(void * param0, XID param1, void * data_buff
#ifdef SHAPE
if (nxagentWindowPriv(pWin) -> boundingShape)
{
- REGION_DESTROY(pWin -> drawable.pScreen,
+ RegionDestroy(
nxagentWindowPriv(pWin) -> boundingShape);
nxagentWindowPriv(pWin) -> boundingShape = NULL;
}
if (nxagentWindowPriv(pWin) -> clipShape)
{
- REGION_DESTROY(pWin -> drawable.pScreen,
+ RegionDestroy(
nxagentWindowPriv(pWin) -> clipShape);
nxagentWindowPriv(pWin) -> clipShape = NULL;
}
@@ -3389,7 +3385,7 @@ void nxagentSetTopLevelEventMask(pWin)
if (nxagentOption(Rootless) && nxagentWindowTopLevel(pWin))
{
/* Assume that the mask fits in int... broken on Big Endian 64bit systems. */
- Mask tmp_mask = attributes.event_mask;
+ Mask tmp_mask = attributes.event_mask = NoEventMask;
nxagentGetEventMask(pWin, &tmp_mask);
attributes.event_mask = (int)tmp_mask;
@@ -3740,7 +3736,7 @@ void nxagentEmptyBackingStoreRegion(void * param0, XID param1, void * data_buffe
if (pBackingStore != NULL)
{
- REGION_EMPTY(pWin -> pScreen, &pBackingStore->SavedRegion);
+ RegionEmpty(&pBackingStore->SavedRegion);
#ifdef TEST
fprintf(stderr, "nxagentEmptyBackingStoreRegion: Emptying saved region for window at [%p].\n", (void*) pWin);