diff options
Diffstat (limited to 'nx-X11/programs/Xserver/hw/nxagent/Drawable.c')
| -rw-r--r-- | nx-X11/programs/Xserver/hw/nxagent/Drawable.c | 777 |
1 files changed, 290 insertions, 487 deletions
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c index 7574ec7b0..7c69c99d9 100644 --- a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c +++ b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c @@ -55,26 +55,23 @@ #undef DUMP /* - * The list of rectangles composing a region - * s returned by nxagentGetOptimizedRegion- - * Boxes() instead of RegionRects(). + * The list of rectangles composing a region s returned by + * nxagentGetOptimizedRegion- Boxes() instead of RegionRects(). */ #define USE_OPTIMIZED_BOXES /* - * The rectangles composing a region are de- - * fragmented to reduce the number of synch- - * ronizing PutImage's. + * The rectangles composing a region are de- fragmented to reduce the + * number of synch- ronizing PutImage's. */ #define ADVANCED_BOXES_DEFRAG /* - * If defined, send the XClearArea at the end - * of the loop synchronizing the shadow pixmap. - * In this way, large images can be split but - * the user will see more updates together. + * If defined, send the XClearArea at the end of the loop + * synchronizing the shadow pixmap. In this way, large images can be + * split but the user will see more updates together. */ #undef COLLECTED_UPDATES @@ -104,9 +101,8 @@ _nxagentSynchronizationRec nxagentSynchronization = { (DrawablePtr) NULL, 0, 0, RegionPtr nxagentDeferredBackgroundExposures = NullRegion; /* - * Predicate functions used to synchronize the - * content of the remote drawable with the data - * stored in the virtual frame-buffer. + * Predicate functions used to synchronize the content of the remote + * drawable with the data stored in the virtual frame-buffer. */ void nxagentSynchronizeDrawablePredicate(void *p0, XID x1, void *p2); @@ -126,12 +122,8 @@ int nxagentSkipImage = 0; static int nxagentTooManyImageData(void) { - unsigned int r; - unsigned int limit; - - limit = nxagentOption(ImageRateLimit); - - r = nxagentGetDataRate() / 1000; + unsigned int limit = nxagentOption(ImageRateLimit); + unsigned int r = nxagentGetDataRate() / 1000; #ifdef TEST if (r > limit) @@ -145,8 +137,6 @@ static int nxagentTooManyImageData(void) int nxagentSynchronizeDrawable(DrawablePtr pDrawable, int wait, unsigned int breakMask, WindowPtr owner) { - int result; - pDrawable = nxagentSplitDrawable(pDrawable); if (nxagentLosslessTrap == 0) @@ -164,19 +154,17 @@ int nxagentSynchronizeDrawable(DrawablePtr pDrawable, int wait, unsigned int bre } /* - * What we want here is to avoid drawing on the - * framebuffer and just perform the operation - * on the real X server. This is the purpose of - * the FB trap. At the same time we also want - * to avoid a split, so that the image will be - * transferred in a single operation. + * What we want here is to avoid drawing on the framebuffer and just + * perform the operation on the real X server. This is the purpose + * of the FB trap. At the same time we also want to avoid a split, + * so that the image will be transferred in a single operation. */ nxagentFBTrap = 1; nxagentSplitTrap = 1; - result = nxagentSynchronizeDrawableData(pDrawable, breakMask, owner); + int result = nxagentSynchronizeDrawableData(pDrawable, breakMask, owner); nxagentSplitTrap = 0; @@ -188,7 +176,6 @@ int nxagentSynchronizeDrawable(DrawablePtr pDrawable, int wait, unsigned int bre } #ifdef TEST - if (nxagentDrawableStatus(pDrawable) == Synchronized) { fprintf(stderr, "nxagentSynchronizeDrawable: Drawable %s [%p] with id [%ld] now synchronized.\n", @@ -199,7 +186,6 @@ int nxagentSynchronizeDrawable(DrawablePtr pDrawable, int wait, unsigned int bre fprintf(stderr, "nxagentSynchronizeDrawable: Drawable %s [%p] with id [%ld] not fully synchronized.\n", nxagentDrawableType(pDrawable), (void *) pDrawable, pDrawable -> id); } - #endif return result; @@ -207,31 +193,27 @@ int nxagentSynchronizeDrawable(DrawablePtr pDrawable, int wait, unsigned int bre int nxagentSynchronizeDrawableData(DrawablePtr pDrawable, unsigned int breakMask, WindowPtr owner) { - int width, height, depth, length; - unsigned int leftPad, format; - char *data = NULL; - DrawablePtr pSrcDrawable; - GCPtr pGC; - int success; if (pDrawable -> type == DRAWABLE_PIXMAP) { - leftPad = 0; + GCPtr pGC; + + unsigned int leftPad = 0; - width = pDrawable -> width; - height = pDrawable -> height; - depth = pDrawable -> depth; + int width = pDrawable -> width; + int height = pDrawable -> height; + int depth = pDrawable -> depth; #ifdef TEST fprintf(stderr, "nxagentSynchronizeDrawableData: Synchronizing drawable (%s) with geometry [%d][%d][%d].\n", nxagentDrawableType(pDrawable), width, height, depth); #endif - format = (depth == 1) ? XYPixmap : ZPixmap; + unsigned int format = (depth == 1) ? XYPixmap : ZPixmap; - length = nxagentImageLength(width, height, format, leftPad, depth); + int length = nxagentImageLength(width, height, format, leftPad, depth); if ((data = malloc(length)) == NULL) { @@ -244,14 +226,13 @@ int nxagentSynchronizeDrawableData(DrawablePtr pDrawable, unsigned int breakMask goto nxagentSynchronizeDrawableDataEnd; } - pSrcDrawable = (pDrawable -> type == DRAWABLE_PIXMAP ? - ((DrawablePtr) nxagentVirtualPixmap((PixmapPtr) pDrawable)) : - pDrawable); + DrawablePtr pSrcDrawable = (pDrawable -> type == DRAWABLE_PIXMAP ? + ((DrawablePtr) nxagentVirtualPixmap((PixmapPtr) pDrawable)) : + pDrawable); /* - * Synchronize the whole pixmap if we need - * to download a fresh copy with lossless - * compression turned off. + * Synchronize the whole pixmap if we need to download a fresh + * copy with lossless compression turned off. */ if (nxagentLosslessTrap == 1) @@ -289,10 +270,9 @@ int nxagentSynchronizeDrawableData(DrawablePtr pDrawable, unsigned int breakMask else if (nxagentReconnectTrap == 1) { /* - * The pixmap data is not synchronized unless - * we need it. We noticed we have to reconnect - * the pixmaps used by the GC's clip mask. - * The other data will be synchronized on demand. + * The pixmap data is not synchronized unless we need it. We + * noticed we have to reconnect the pixmaps used by the GC's + * clip mask. The other data will be synchronized on demand. */ if (pDrawable -> depth == 1) @@ -357,9 +337,8 @@ int nxagentSynchronizeDrawableData(DrawablePtr pDrawable, unsigned int breakMask } /* - * By calling this function with the NullRegion - * as parameter we are requesting to synchro- - * nize the full visible corrupted region of + * By calling this function with the NullRegion as parameter we are + * requesting to synchronize the full visible corrupted region of * the drawable. */ @@ -372,53 +351,26 @@ nxagentSynchronizeDrawableDataEnd: } /* - * If pRegion is NullRegion, all the viewable - * corrupted region will be synchronized. + * If pRegion is NullRegion, all the viewable corrupted region will be + * synchronized. */ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned int breakMask, WindowPtr owner) { - GCPtr pGC; DrawablePtr pSrcDrawable; - BoxPtr pBox; - RegionPtr clipRegion; - RegionRec tileRegion; - RegionRec exposeRegion; - BoxRec box; - BoxRec tileBox; + int leftPad = 0; + int success = 0; + char *data = NULL; + GCPtr pGC = NULL; + RegionPtr clipRegion = NullRegion; #ifdef COLLECTED_UPDATES RegionRec collectedUpdates; - #endif - - char *data; - - int nBox; - int x, y; - int w, h; - int extentWidth, extentHeight; - int tileWidth, tileHeight; - int length, format, leftPad; - int i; - int saveTrap; - int success; - int useStoredBitmap; - - unsigned long now; - unsigned long elapsedTime; - - - leftPad = 0; - success = 0; - data = NULL; - pGC = NULL; - clipRegion = NullRegion; - - #ifdef COLLECTED_UPDATES RegionInit(&collectedUpdates, NullBox, 1); #endif + RegionRec exposeRegion; RegionInit(&exposeRegion, NullBox, 1); if (nxagentDrawableBitmap(pDrawable) != NullPixmap && @@ -434,12 +386,11 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned } /* - * The stored bitmap may be used if we - * are going to synchronize the full - * drawable. + * The stored bitmap may be used if we are going to synchronize the + * full drawable. */ - useStoredBitmap = (nxagentDrawableBitmap(pDrawable) != NullPixmap && pRegion == NullRegion); + int useStoredBitmap = (nxagentDrawableBitmap(pDrawable) != NullPixmap && pRegion == NullRegion); if (useStoredBitmap != 0) { @@ -454,24 +405,21 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned RegionNumRects(nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable)))); #endif - clipRegion = nxagentCreateRegion(pDrawable, NULL, 0, 0, pDrawable -> width, pDrawable -> height); + RegionPtr clipRegion = nxagentCreateRegion(pDrawable, NULL, 0, 0, pDrawable -> width, pDrawable -> height); /* - * Intersecting the viewable region of the - * drawable with the region remaining from - * a previous loop. + * Intersecting the viewable region of the drawable with the + * region remaining from a previous loop. */ RegionIntersect(clipRegion, clipRegion, nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable))); /* - * The bitmap regions used in the synchro- - * nizations are only those corrupted also - * on the drawable. In this way, if we put - * a tile in a bad position (e.g. if the - * corrupted region moves), the next synch- - * ronization will fix the error. + * The bitmap regions used in the synchronizations are only those + * corrupted also on the drawable. In this way, if we put a tile + * in a bad position (e.g. if the corrupted region moves), the + * next synchronization will fix the error. */ RegionIntersect(clipRegion, clipRegion, @@ -495,8 +443,8 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned } /* - * Using the saved bitmap as source, instead - * of the drawable itself. + * Using the saved bitmap as source, instead of the drawable + * itself. */ pSrcDrawable = ((DrawablePtr) nxagentVirtualPixmap(nxagentDrawableBitmap(pDrawable))); @@ -524,15 +472,14 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned } /* - * Creating a region containing the viewable - * area of drawable. + * Creating a region containing the viewable area of drawable. */ clipRegion = nxagentCreateRegion(pDrawable, NULL, 0, 0, pDrawable -> width, pDrawable -> height); /* - * If the corrupted region is not viewable, we - * can skip the synchronization. + * If the corrupted region is not viewable, we can skip the + * synchronization. */ RegionIntersect(clipRegion, clipRegion, nxagentCorruptedRegion(pDrawable)); @@ -550,10 +497,9 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned } /* - * We can skip the synchronization if the re- - * quested region is not corrupted. Specifying - * a NullRegion as parameter, all the viewable - * corrupted region will be synchronized. + * We can skip the synchronization if the requested region is not + * corrupted. Specifying a NullRegion as parameter, all the + * viewable corrupted region will be synchronized. */ if (pRegion != NullRegion) @@ -585,7 +531,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned nxagentDrawableType(pDrawable), (void *) pDrawable); #endif - saveTrap = nxagentGCTrap; + int saveTrap = nxagentGCTrap; nxagentGCTrap = 0; @@ -618,14 +564,13 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned #endif /* - * We are going to synchronize the corrupted - * area, so we use the corrupted extents as - * maximum size of the image data. It's im- - * portant to avoid using the drawable size, - * because in case of a huge window it had to - * result in a failed data memory allocation. + * We are going to synchronize the corrupted area, so we use the + * corrupted extents as maximum size of the image data. It's + * important to avoid using the drawable size, because in case of a + * huge window it had to result in a failed data memory allocation. */ + int w, h, extentWidth, extentHeight, tileWidth, tileHeight; extentWidth = clipRegion -> extents.x2 - clipRegion -> extents.x1; extentHeight = clipRegion -> extents.y2 - clipRegion -> extents.y1; @@ -636,6 +581,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned fprintf(stderr, "nxagentSynchronizeRegion: Using tiles of size [%dx%d].\n", tileWidth, tileHeight); #endif + int length, format; data = nxagentAllocateImageData(w, h, pDrawable -> depth, &length, &format); if (data == NULL) @@ -645,8 +591,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned fprintf(stderr, "nxagentSynchronizeRegion: WARNING! Failed to allocate memory for synchronization.\n"); /* - * Print detailed information if the - * image length is zero. + * Print detailed information if the image length is zero. */ if (length == 0) @@ -664,17 +609,17 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned #ifndef USE_OPTIMIZED_BOXES - pBox = RegionRects(clipRegion); + BoxPtr pBox = RegionRects(clipRegion); #else - pBox = nxagentGetOptimizedRegionBoxes(clipRegion); + BoxPtr pBox = nxagentGetOptimizedRegionBoxes(clipRegion); #endif /* USE_OPTIMIZED_BOXES */ - nBox = RegionNumRects(clipRegion); + int nBox = RegionNumRects(clipRegion); - now = GetTimeInMillis(); + unsigned long now = GetTimeInMillis(); nxagentSynchronization.abort = 0; @@ -682,7 +627,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned * Going to split the updated region into small blocks. */ - for (i = 0; i < nBox; i++) + for (int i = 0; i < nBox; i++) { #ifdef USE_OPTIMIZED_BOXES @@ -694,13 +639,13 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned #endif - box = pBox[i]; + BoxRec box = pBox[i]; - for (y = box.y1; y < box.y2; y += h) + for (int y = box.y1; y < box.y2; y += h) { h = min(box.y2 - y, tileHeight); - for (x = box.x1; x < box.x2; x += w) + for (int x = box.x1; x < box.x2; x += w) { w = min(box.x2 - x, tileWidth); @@ -727,12 +672,11 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned if (canBreakOnTimeout(breakMask)) { /* - * Abort the synchronization loop if it - * lasts for more than DeferTimeout - * milliseconds. + * Abort the synchronization loop if it lasts for more than + * DeferTimeout milliseconds. */ - elapsedTime = GetTimeInMillis() - now; + unsigned long elapsedTime = GetTimeInMillis() - now; if (elapsedTime > nxagentOption(DeferTimeout)) { @@ -781,10 +725,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned goto nxagentSynchronizeRegionStop; } - tileBox.x1 = x; - tileBox.y1 = y; - tileBox.x2 = x + w; - tileBox.y2 = y + h; + BoxRec tileBox = {.x1 = x, .y1 = y, .x2 = x + w, .y2 = y + h}; #ifdef DEBUG fprintf(stderr, "nxagentSynchronizeRegion: Going to synchronize tile [%d,%d,%d,%d].\n", @@ -794,10 +735,10 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned nxagentGetImage(pSrcDrawable, x, y, w, h, format, AllPlanes, data); /* - * Going to unmark the synchronized - * region. + * Going to unmark the synchronized region. */ + RegionRec tileRegion; RegionInit(&tileRegion, &tileBox, 1); RegionUnion(&exposeRegion, &exposeRegion, &tileRegion); @@ -809,30 +750,26 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned if (useStoredBitmap != 0) { /* - * When a bitmap's tile is synchronized, - * we can clear the corresponding region. - * We can't use the nxagentUnmarkCorrupted- - * Region because we have not a resource - * associated to this pixmap. + * When a bitmap's tile is synchronized, we can clear the + * corresponding region. We can't use the + * nxagentUnmarkCorruptedRegion because we have not a + * resource associated to this pixmap. */ RegionSubtract(nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)), nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)), &tileRegion); /* - * The drawable's corrupted region can - * be cleared if the bitmap's tile data - * matches the drawable's content at the + * The drawable's corrupted region can be cleared if the + * bitmap's tile data matches the drawable's content at the * same position. */ if (nxagentDrawableStatus(pDrawable) == NotSynchronized) { - char *cmpData; - int cmpLength, cmpFormat; - cmpData = nxagentAllocateImageData(w, h, pDrawable -> depth, &cmpLength, &cmpFormat); + char *cmpData = nxagentAllocateImageData(w, h, pDrawable -> depth, &cmpLength, &cmpFormat); if (cmpData != NULL) { @@ -882,8 +819,8 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned } /* - * Realize the image after comparing the - * source data with the bitmap data. + * Realize the image after comparing the source data with the + * bitmap data. */ nxagentRealizeImage(pDrawable, pGC, pDrawable -> depth, @@ -899,16 +836,11 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned (nxagentOption(XRatio) != DONT_SCALE || nxagentOption(YRatio) != DONT_SCALE)) { - int scaledx; - int scaledy; - int scaledw; - int scaledh; - - scaledx = nxagentScale(x, nxagentOption(XRatio)); - scaledy = nxagentScale(y, nxagentOption(YRatio)); + int scaledx = nxagentScale(x, nxagentOption(XRatio)); + int scaledy = nxagentScale(y, nxagentOption(YRatio)); - scaledw = nxagentScale(x + w, nxagentOption(XRatio)) - scaledx; - scaledh = nxagentScale(y + h, nxagentOption(YRatio)) - scaledy; + int scaledw = nxagentScale(x + w, nxagentOption(XRatio)) - scaledx; + int scaledh = nxagentScale(y + h, nxagentOption(YRatio)) - scaledy; XClearArea(nxagentDisplay, nxagentWindow(owner), scaledx, scaledy, scaledw, scaledh, 0); } @@ -921,9 +853,8 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned #endif /* #if !defined(COLLECTED_UPDATES) */ /* - * Abort the loop on the user's input. - * This is done here to check for events - * read after the flush caused by the + * Abort the loop on the user's input. This is done here to + * check for events read after the flush caused by the * PutImage. */ @@ -959,10 +890,9 @@ nxagentSynchronizeRegionStop: if (nxagentSynchronization.abort == 1) { /* - * Storing the pointer to the drawable we - * were synchronizing when the loop aborted. - * It is used in nxagentSynchronizeDrawable- - * Predicate. + * Storing the pointer to the drawable we were synchronizing + * when the loop aborted. It is used in + * nxagentSynchronizeDrawablePredicate. */ nxagentSynchronization.pDrawable = pDrawable; @@ -993,14 +923,12 @@ nxagentSynchronizeRegionStop: nxagentIsCorruptedBackground((PixmapPtr) pDrawable) == 1 && RegionNil(&exposeRegion) == 0) { - struct nxagentExposeBackground eb; + struct nxagentExposeBackground eb = { + .pBackground = (PixmapPtr) pDrawable, + .pExpose = &exposeRegion, + }; - int i; - - eb.pBackground = (PixmapPtr) pDrawable; - eb.pExpose = &exposeRegion; - - for (i = 0; i < MAXCLIENTS; i++) + for (int i = 0; i < MAXCLIENTS; i++) { if (clients[i] != NULL) { @@ -1019,27 +947,22 @@ nxagentSynchronizeRegionStop: RegionValidate(&collectedUpdates, &overlap); - for (i = 0; i < RegionNumRects(&collectedUpdates); i++) + for (int i = 0; i < RegionNumRects(&collectedUpdates); i++) { - 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; + int x = RegionRects(&collectedUpdates)[i].x1; + int y = RegionRects(&collectedUpdates)[i].y1; + int w = RegionRects(&collectedUpdates)[i].x2 - RegionRects(&collectedUpdates)[i].x1; + int h = RegionRects(&collectedUpdates)[i].y2 - RegionRects(&collectedUpdates)[i].y1; if (nxagentOption(Shadow) == 1 && (nxagentOption(XRatio) != DONT_SCALE || nxagentOption(YRatio) != DONT_SCALE)) { - int scaledx; - int scaledy; - int scaledw; - int scaledh; - - scaledx = nxagentScale(x, nxagentOption(XRatio)); - scaledy = nxagentScale(y, nxagentOption(YRatio)); + int scaledx = nxagentScale(x, nxagentOption(XRatio)); + int scaledy = nxagentScale(y, nxagentOption(YRatio)); - scaledw = nxagentScale(x + w, nxagentOption(XRatio)) - scaledx; - scaledh = nxagentScale(y + h, nxagentOption(YRatio)) - scaledy; + int scaledw = nxagentScale(x + w, nxagentOption(XRatio)) - scaledx; + int scaledh = nxagentScale(y + h, nxagentOption(YRatio)) - scaledy; XClearArea(nxagentDisplay, nxagentWindow(owner), scaledx, scaledy, scaledw, scaledh, 0); } @@ -1074,8 +997,6 @@ nxagentSynchronizeRegionFree: void nxagentSynchronizeBox(DrawablePtr pDrawable, BoxPtr pBox, unsigned int breakMask) { - RegionPtr pRegion; - if (nxagentDrawableStatus(pDrawable) == Synchronized) { #ifdef TEST @@ -1102,7 +1023,7 @@ void nxagentSynchronizeBox(DrawablePtr pDrawable, BoxPtr pBox, unsigned int brea pBox -> x1, pBox -> y1, pBox -> x2, pBox -> y2); #endif - pRegion = nxagentCreateRegion(pDrawable, NULL, pBox -> x1, pBox -> y1, + RegionPtr pRegion = nxagentCreateRegion(pDrawable, NULL, pBox -> x1, pBox -> y1, pBox -> x2 - pBox -> x1, pBox -> y2 - pBox -> y1); @@ -1138,10 +1059,9 @@ void nxagentSynchronizeDrawablePredicate(void *p0, XID x1, void *p2) int shouldClearHiddenRegion = 1; /* - * The nxagentSynchronization.abort propa- - * gates a break condition across the resour- - * ces loop, in order to block also the sub- - * sequent synchronizations. + * The nxagentSynchronization.abort propagates a break condition + * across the resources loop, in order to block also the subsequent + * synchronizations. */ if (nxagentSynchronization.abort == 1 || @@ -1151,10 +1071,9 @@ void nxagentSynchronizeDrawablePredicate(void *p0, XID x1, void *p2) } /* - * In order to implement a kind of round-robin - * synchronization, the previous incomplete - * drawable synchronization is saved to jump - * to the next resource available of same type. + * In order to implement a kind of round-robin synchronization, the + * previous incomplete drawable synchronization is saved to jump to + * the next resource available of same type. */ if (nxagentSynchronization.pDrawable != NULL && @@ -1186,10 +1105,8 @@ void nxagentSynchronizeDrawablePredicate(void *p0, XID x1, void *p2) if (pDrawable -> type == DRAWABLE_PIXMAP) { /* - * The pixmaps to be synchronized are those - * used as background or used as source of - * any deferred operations for at least 2 - * times. + * The pixmaps to be synchronized are those used as background or + * used as source of any deferred operations for at least 2 times. */ if (NXAGENT_SHOULD_SYNCHRONIZE_PIXMAP(pDrawable) == 0) @@ -1234,17 +1151,15 @@ void nxagentSynchronizeDrawablePredicate(void *p0, XID x1, void *p2) } /* - * Postpone the synchronization if we went - * out of bandwidth or if the display blocks. - * The pixmap synchronization is more careful + * Postpone the synchronization if we went out of bandwidth or if + * the display blocks. The pixmap synchronization is more careful * with bandwidth usage. */ /* -FIXME: This condition sounds only as a - complication, as the break parameters - are already checked while synchroni- - zing the drawable. +FIXME: This condition sounds only as a complication, as the break + parameters are already checked while synchronizing the + drawable. if (breakOnCongestion(*breakMask) == 1 || (pDrawable -> type == DRAWABLE_PIXMAP && @@ -1275,10 +1190,9 @@ FIXME: This condition sounds only as a #endif /* - * The stored bitmap is destroyed inside - * the synchronization loop, so we have - * to check here its presence to know if - * we can clear the dirty windows. + * The stored bitmap is destroyed inside the synchronization loop, + * so we have to check here its presence to know if we can clear the + * dirty windows. */ shouldClearHiddenRegion = (nxagentDrawableBitmap(pDrawable) == NullPixmap); @@ -1293,10 +1207,9 @@ FIXME: This condition sounds only as a #endif /* - * If the remaining corrupted region is on - * an hidden section (not viewable or outside - * of the pixmap's area) of a drawable, - * we can clear it. + * If the remaining corrupted region is on an hidden section (not + * viewable or outside of the pixmap's area) of a drawable, we can + * clear it. */ if (nxagentSynchronization.abort == 0 && @@ -1314,14 +1227,9 @@ FIXME: This condition sounds only as a void nxagentSynchronizationLoop(unsigned int mask) { - unsigned int breakMask; - - int doRoundRobin; - /* -FIXME: All drawables should be set as synchronized and - never marked as corrupted while the display is - down. +FIXME: All drawables should be set as synchronized and never marked as + corrupted while the display is down. */ nxagentSkipImage = nxagentTooManyImageData(); @@ -1358,17 +1266,15 @@ FIXME: All drawables should be set as synchronized and "blocking [%d].\n", nxagentCongestion, nxagentBlocking); #endif - breakMask = mask; + unsigned int breakMask = mask; /* - * The resource counter can be reset if we - * have not aborted the synchronization loop, - * if we are not skipping resources to do - * round-robin and if the bitmaps are all - * synchronized. + * The resource counter can be reset if we have not aborted the + * synchronization loop, if we are not skipping resources to do + * round-robin and if the bitmaps are all synchronized. */ - doRoundRobin = (nxagentSynchronization.pDrawable != NULL); + int doRoundRobin = (nxagentSynchronization.pDrawable != NULL); nxagentSynchronization.abort = 0; @@ -1436,11 +1342,10 @@ FIXME: All drawables should be set as synchronized and } /* - * If there is bandwidth remaining, synchronize - * the pixmaps. Synchronizing a pixmap doesn't - * produce any visible results. Better is to - * synchronize them on demand, before using the - * pixmap in a copy or in a composite operation. + * If there is bandwidth remaining, synchronize the + * pixmaps. Synchronizing a pixmap doesn't produce any visible + * results. Better is to synchronize them on demand, before using + * the pixmap in a copy or in a composite operation. */ if (nxagentSynchronization.abort == 0 && @@ -1474,9 +1379,8 @@ FIXME: All drawables should be set as synchronized and } /* - * If the last synchronized drawable has been - * removed, we have to reset the variable sto- - * ring its pointer. + * If the last synchronized drawable has been removed, we have to + * reset the variable sto- ring its pointer. */ if (nxagentSynchronization.pDrawable != NULL && @@ -1508,15 +1412,8 @@ FIXME: All drawables should be set as synchronized and RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int width, int height) { - RegionPtr pRegion; - BoxRec box; - - box.x1 = x; - box.y1 = y; - box.x2 = x + width; - box.y2 = y + height; - - pRegion = RegionCreate(&box, 1); + BoxRec box = {.x1 = x, .y1 = y, .x2 = x + width, .y2 = y + height}; + RegionPtr pRegion = RegionCreate(&box, 1); /* * Clipping the region. @@ -1524,22 +1421,17 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y, if (pDrawable -> type == DRAWABLE_PIXMAP) { - BoxRec tmpBox; - RegionRec tmpRegion; - /* - * The region created doesn't need to be clipped - * if it has the pixmap dimensions. + * The region created doesn't need to be clipped if it has the + * pixmap dimensions. */ if (x != 0 || y != 0 || width != pDrawable -> width || height != pDrawable -> height) { - tmpBox.x1 = 0; - tmpBox.y1 = 0; - tmpBox.x2 = pDrawable -> width; - tmpBox.y2 = pDrawable -> height; + BoxRec tmpBox = {.x1 = 0, .y1 = 0, .x2 = pDrawable -> width, .y2 = pDrawable -> height}; + RegionRec tmpRegion; RegionInit(&tmpRegion, &tmpBox, 1); @@ -1551,9 +1443,8 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y, else { /* - * We use the clipList because the borderClip - * contains also parts of the window covered - * by its children. + * We use the clipList because the borderClip contains also parts + * of the window covered by its children. */ RegionTranslate(pRegion, @@ -1579,8 +1470,8 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y, #endif /* - * If the pRegion is NIL we don't need - * to intersect it with the GC's clipmask. + * If the pRegion is NIL we don't need to intersect it with the GC's + * clipmask. */ if (RegionNil(pRegion) == 0 && @@ -1594,9 +1485,9 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y, RegionCopy(&clipRegion, (RegionPtr) pGC -> clientClip); /* - * The clip origin is relative to the origin of - * the destination drawable. The clip mask coor- - * dinates are relative to the clip origin. + * The clip origin is relative to the origin of the destination + * drawable. The clip mask coor- dinates are relative to the clip + * origin. */ if (pGC -> clipOrg.x != 0 || pGC -> clipOrg.y != 0) @@ -1620,11 +1511,6 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y, void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion) { - int x; - int y; - int width; - int height; - if (pRegion != NullRegion && RegionNil(pRegion) == 1) { #ifdef TEST @@ -1636,10 +1522,9 @@ void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion) } /* - * If the drawable was synchronized, the counter - * reporting the number of corrupted drawables - * must be increased. Moreover the corrupted ti- - * mestamp must be set. + * If the drawable was synchronized, the counter reporting the + * number of corrupted drawables must be increased. Moreover the + * corrupted ti- mestamp must be set. */ if (nxagentDrawableStatus(pDrawable) == Synchronized) @@ -1654,11 +1539,11 @@ void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion) if (pRegion == NullRegion) { - x = 0; - y = 0; + int x = 0; + int y = 0; - width = pDrawable -> width; - height = pDrawable -> height; + int width = pDrawable -> width; + int height = pDrawable -> height; #ifdef TEST fprintf(stderr, "nxagentMarkCorruptedRegion: Fully invalidating %s [%p] with " @@ -1700,8 +1585,6 @@ void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion) void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion) { - int oldStatus; - if (pRegion != NullRegion && RegionNil(pRegion) == 1) { #ifdef TEST @@ -1712,7 +1595,7 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion) return; } - oldStatus = nxagentDrawableStatus(pDrawable); + int oldStatus = nxagentDrawableStatus(pDrawable); if (oldStatus == Synchronized) { @@ -1752,9 +1635,8 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion) } /* - * If the drawable becomes synchronized, the - * counter reporting the number of corrupted - * drawables must be decreased. Moreover the + * If the drawable becomes synchronized, the counter reporting the + * number of corrupted drawables must be decreased. Moreover the * corrupted timestamp must be reset. */ @@ -1777,8 +1659,8 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion) nxagentResetCorruptedTimestamp(pDrawable); /* - * If the resource is no longer dirty, - * the associated bitmap is destroyed. + * If the resource is no longer dirty, the associated bitmap is + * destroyed. */ if (nxagentDrawableBitmap(pDrawable) != NullPixmap) @@ -1791,9 +1673,8 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion) void nxagentMoveCorruptedRegion(WindowPtr pWin, unsigned int mask) { /* - * If a window is resized, its corrupted - * region is moved according to the bit - * gravity. + * If a window is resized, its corrupted region is moved according + * to the bit gravity. */ if (nxagentDrawableStatus((DrawablePtr) pWin) == NotSynchronized) @@ -1819,18 +1700,17 @@ void nxagentMoveCorruptedRegion(WindowPtr pWin, unsigned int mask) nx, ny); /* - * Having moved the corrupted region, we - * need to invalidate the pending commits - * or otherwise the image will fall in - * the wrong area. + * Having moved the corrupted region, we need to invalidate the + * pending commits or otherwise the image will fall in the wrong + * area. */ nxagentValidateSplit((DrawablePtr) pWin, NULL); /* - * The window reconfiguration invalidates - * the synchronization bitmap. + * The window reconfiguration invalidates the synchronization + * bitmap. */ nxagentDestroyDrawableBitmap((DrawablePtr) pWin); @@ -1839,13 +1719,12 @@ void nxagentMoveCorruptedRegion(WindowPtr pWin, unsigned int mask) } /* - * The DDX layer uses an 'Y-X banding' representation of - * regions: it sorts all rectangles composing a region - * using first the y-dimension, than the x-dimension; mo- - * reover it organizes the rectangles in 'bands' sharing - * the same y-dimension. This representation does not mi- - * nimize the number of rectangles. For example, the fol- - * lowing region has 4 rectangles: + * The DDX layer uses an 'Y-X banding' representation of regions: it + * sorts all rectangles composing a region using first the + * y-dimension, than the x-dimension; moreover it organizes the + * rectangles in 'bands' sharing the same y-dimension. This + * representation does not minimize the number of rectangles. For + * example, the following region has 4 rectangles: * * +-----------+ * | | +---+ @@ -1853,40 +1732,30 @@ void nxagentMoveCorruptedRegion(WindowPtr pWin, unsigned int mask) * | | +---+ * +-----------+ * - * The rectangle 'B' creates a band which splits the rec- - * tangle A in 3 parts, for a total of 3 bands. The num- - * ber of rectangles composing the region is 4. + * The rectangle 'B' creates a band which splits the rectangle A in 3 + * parts, for a total of 3 bands. The number of rectangles composing + * the region is 4. * - * This kind of representation is not advisable for the - * lazy synchronization because, in the example above, - * the nxagent had to send 4 put images instead of 2. + * This kind of representation is not advisable for the lazy + * synchronization because, in the example above, the nxagent had to + * send 4 put images instead of 2. * - * To minimize the problem we use the following function: - * by traversing the list of rectangles we merge all bo- - * xes with same x coordinates and coincident y, in order - * to create an X-Y banding. + * To minimize the problem we use the following function: by + * traversing the list of rectangles we merge all boxes with same x + * coordinates and coincident y, in order to create an X-Y banding. * - * Be careful: all the coordinates of boxes merged are - * set to 0, so take care of this when looping through - * the box list returned by this function. + * Be careful: all the coordinates of boxes merged are set to 0, so + * take care of this when looping through the box list returned by + * this function. */ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion) { - BoxPtr pBox; - BoxRec boxExtents; - int nBox; - int i, j; - - #ifdef DEBUG - int nBoxOptim; - #endif - - pBox = RegionRects(pRegion); + BoxPtr pBox = RegionRects(pRegion); - nBox = RegionNumRects(pRegion); + int nBox = RegionNumRects(pRegion); #ifdef TEST fprintf(stderr, "nxagentGetOptimizedRegionBoxes: Going to optimize region at [%p] with [%d] rects.\n", @@ -1899,21 +1768,19 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion) } #ifdef DEBUG - nBoxOptim = nBox; + int nBoxOptim = nBox; #endif /* - * The boxes are now grouped to grown as much - * as possible, using their overlapping vertex - * as rule. + * The boxes are now grouped to grown as much as possible, using + * their overlapping vertex as rule. */ - for (i = 0; i < nBox; i++) + for (int i = 0; i < nBox; i++) { /* - * If the coordinates are (0,0) the box - * has been already merged, so we can skip - * it. + * If the coordinates are (0,0) the box has been already merged, + * so we can skip it. */ if (pBox[i].x1 == 0 && pBox[i].y1 == 0 && @@ -1937,7 +1804,7 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion) boxExtents.y2 = pBox[i].y2; - for (j = i+1; j < nBox; j++) + for (int j = i+1; j < nBox; j++) { if (pBox[j].x1 == 0 && pBox[j].y1 == 0 && pBox[j].x2 == 0 && pBox[j].y2 == 0) @@ -1951,12 +1818,10 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion) #endif /* - * Each consequent box is merged if its - * higher side overlaps the lower side - * of current box. - * In case of ADVANCED_BOXES_DEFRAG the higher - * side must be included within a range - * defined by INCLUDE_MARGIN. + * Each consequent box is merged if its higher side overlaps the + * lower side of current box. In case of ADVANCED_BOXES_DEFRAG + * the higher side must be included within a range defined by + * INCLUDE_MARGIN. */ #ifndef ADVANCED_BOXES_DEFRAG @@ -2006,11 +1871,9 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion) } /* - * By appending a box to another, we have - * to remove it from the box list. We do - * this by setting its coordinates to (0,0) - * and by checking their value in the main - * loop. + * By appending a box to another, we have to remove it from + * the box list. We do this by setting its coordinates to + * (0,0) and by checking their value in the main loop. */ pBox[j].x1 = pBox[j].y1 = pBox[j].x2 = pBox[j].y2 = 0; @@ -2039,13 +1902,12 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion) #ifdef ADVANCED_BOXES_DEFRAG /* - * The new list need to be validated to - * avoid boxes overlapping. This code may - * be improved to remove also the partial- - * ly overlapping boxes. + * The new list need to be validated to avoid boxes + * overlapping. This code may be improved to remove also the + * partial- ly overlapping boxes. */ - for (i = 0; i < nBox; i++) + for (int i = 0; i < nBox; i++) { if (pBox[i].x1 == 0 && pBox[i].y1 == 0 && pBox[i].x2 == 0 && pBox[i].y2 == 0) @@ -2063,7 +1925,7 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion) boxExtents.x2 = pBox[i].x2; boxExtents.y2 = pBox[i].y2; - for (j = i+1; j < nBox; j++) + for (int j = i+1; j < nBox; j++) { if (pBox[j].x1 == 0 && pBox[j].y1 == 0 && pBox[j].x2 == 0 && pBox[j].y2 == 0) @@ -2082,9 +1944,8 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion) boxExtents.y2 >= pBox[j].y2)) { /* - * If a box is completely inside - * another, we set its coordinates - * to 0 to consider it as merged. + * If a box is completely inside another, we set its + * coordinates to 0 to consider it as merged. */ #ifdef DEBUG @@ -2115,19 +1976,14 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion) unsigned long nxagentGetColor(DrawablePtr pDrawable, int xPixel, int yPixel) { - XImage *ximage; - Visual *pVisual; - char *data; - - int depth, format, length; int leftPad = 0; - unsigned long pixel; - depth = pDrawable -> depth; - format = (depth == 1) ? XYPixmap : ZPixmap; - length = nxagentImageLength(1, 1, format, leftPad, depth); + int depth = pDrawable -> depth; + int format = (depth == 1) ? XYPixmap : ZPixmap; + int length = nxagentImageLength(1, 1, format, leftPad, depth); - if ((data = malloc(length)) == NULL) + char * data = malloc(length); + if (data == NULL) { #ifdef WARNING fprintf(stderr, "nxagentGetColor: WARNING! Failed to allocate memory for the operation.\n"); @@ -2136,7 +1992,7 @@ unsigned long nxagentGetColor(DrawablePtr pDrawable, int xPixel, int yPixel) return -1; } - pVisual = nxagentImageVisual(pDrawable, depth); + Visual *pVisual = nxagentImageVisual(pDrawable, depth); if (pVisual == NULL) { @@ -2149,9 +2005,9 @@ unsigned long nxagentGetColor(DrawablePtr pDrawable, int xPixel, int yPixel) fbGetImage(pDrawable, xPixel, yPixel, 1, 1, format, AllPlanes, data); - ximage = XCreateImage(nxagentDisplay, pVisual, depth, format, leftPad, (char *) data, - 1, 1, BitmapPad(nxagentDisplay), - nxagentImagePad(1, format, leftPad, 1)); + XImage *ximage = XCreateImage(nxagentDisplay, pVisual, depth, format, leftPad, (char *) data, + 1, 1, BitmapPad(nxagentDisplay), + nxagentImagePad(1, format, leftPad, 1)); if (ximage == NULL) { @@ -2164,7 +2020,7 @@ unsigned long nxagentGetColor(DrawablePtr pDrawable, int xPixel, int yPixel) return -1; } - pixel = XGetPixel(ximage, 0, 0); + unsigned long pixel = XGetPixel(ximage, 0, 0); XDestroyImage(ximage); @@ -2172,34 +2028,30 @@ unsigned long nxagentGetColor(DrawablePtr pDrawable, int xPixel, int yPixel) } /* - * This function could be used to determine - * the ClearArea color of corrupted regions - * on screen. + * This function could be used to determine the ClearArea color of + * corrupted regions on screen. */ unsigned long nxagentGetRegionColor(DrawablePtr pDrawable, RegionPtr pRegion) { - int xPicker, yPicker; - if (RegionNil(pRegion) == 1) { return nxagentGetDrawableColor(pDrawable); } /* - * The pixel used as reference is the first - * outer pixel at the bottom right corner - * of corrupted region extents. + * The pixel used as reference is the first outer pixel at the + * bottom right corner of corrupted region extents. */ - xPicker = pRegion -> extents.x2 + 1; + int xPicker = pRegion -> extents.x2 + 1; if (xPicker > pDrawable -> width) { xPicker = pDrawable -> width; } - yPicker = pRegion -> extents.y2 + 1; + int yPicker = pRegion -> extents.y2 + 1; if (yPicker > pDrawable -> height) { @@ -2211,30 +2063,17 @@ unsigned long nxagentGetRegionColor(DrawablePtr pDrawable, RegionPtr pRegion) unsigned long nxagentGetDrawableColor(DrawablePtr pDrawable) { - int xPicker, yPicker; - /* - * The pixel used to determine the co- - * lor of a drawable is at coordinates - * (x + width - 4, y + 4). + * The pixel used to determine the color of a drawable is at + * coordinates (x + width - 4, y + 4). */ - xPicker = pDrawable -> width - 4; - - yPicker = 4; - - return nxagentGetColor(pDrawable, xPicker, yPicker); + return nxagentGetColor(pDrawable, pDrawable -> width - 4, 4); } void nxagentClearRegion(DrawablePtr pDrawable, RegionPtr pRegion) { - WindowPtr pWin; - BoxPtr pBox; - - unsigned long color; unsigned long backupPixel = 0; - int nBox, i; - int restore; #ifdef DEBUG static int nBoxCleared; @@ -2258,13 +2097,13 @@ void nxagentClearRegion(DrawablePtr pDrawable, RegionPtr pRegion) return; } - pWin = (WindowPtr) pDrawable; + WindowPtr pWin = (WindowPtr) pDrawable; - restore = 0; + int restore = 0; /* - * If the window has already a background, we - * can hope it will be nice. + * If the window has already a background, we can hope it will be + * nice. */ if (pWin -> backgroundState != None) @@ -2282,7 +2121,7 @@ void nxagentClearRegion(DrawablePtr pDrawable, RegionPtr pRegion) backupPixel = pWin -> background.pixel; - color = nxagentGetDrawableColor((DrawablePtr) pWin); + unsigned long color = nxagentGetDrawableColor((DrawablePtr) pWin); if (color == -1) { @@ -2302,11 +2141,11 @@ void nxagentClearRegion(DrawablePtr pDrawable, RegionPtr pRegion) restore = 1; } - pBox = nxagentGetOptimizedRegionBoxes(pRegion); + BoxPtr pBox = nxagentGetOptimizedRegionBoxes(pRegion); - nBox = RegionNumRects(pRegion); + int nBox = RegionNumRects(pRegion); - for (i = 0; i < nBox; i++) + for (int i = 0; i < nBox; i++) { if (pBox[i].x1 == 0 && pBox[i].y1 == 0 && pBox[i].x2 == 0 && pBox[i].y2 == 0) @@ -2339,21 +2178,14 @@ void nxagentClearRegion(DrawablePtr pDrawable, RegionPtr pRegion) void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion) { - GCPtr pGC; - BoxPtr pBox; - XRectangle *pRects; - - int nrects; - int i; - if (RegionNil(pRegion) == 1) { return; } - pGC = nxagentGetGraphicContext(pDrawable); + GCPtr pGC = nxagentGetGraphicContext(pDrawable); - nrects = RegionNumRects(pRegion); + int nrects = RegionNumRects(pRegion); #ifdef TEST fprintf(stderr, "nxagentFillRemoteRegion: Going to fill remote region [%d,%d,%d,%d] rects [%d] with color [%lu].\n", @@ -2370,11 +2202,10 @@ void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion) } else { - pBox = RegionRects(pRegion); + BoxPtr pBox = RegionRects(pRegion); + XRectangle *pRects = malloc(nrects * sizeof(XRectangle)); - pRects = malloc(nrects * sizeof(XRectangle)); - - for (i = 0; i < nrects; i++) + for (int i = 0; i < nrects; i++) { pRects[i].x = pBox[i].x1; pRects[i].y = pBox[i].y1; @@ -2428,20 +2259,14 @@ int nxagentDestroyCorruptedBackgroundResource(void * p, XID id) void nxagentPointsToDirtyRegion(DrawablePtr pDrawable, int mode, int nPoints, xPoint *pPoints) { - RegionPtr pRegion; - RegionRec tmpRegion; - BoxRec box, extents; - - xPoint *xp; - int np; - - np = nPoints; - xp = pPoints; - - pRegion = RegionCreate(NullBox, 1); + RegionPtr pRegion = RegionCreate(NullBox, 1); + int np = nPoints; while (np--) { + BoxRec box; + xPoint *xp = pPoints; + if (CoordModePrevious) { box.x1 = box.x2 = (xp-1) -> x + xp -> x; @@ -2463,6 +2288,7 @@ void nxagentPointsToDirtyRegion(DrawablePtr pDrawable, int mode, * this loop could become less expensive. */ + RegionRec tmpRegion; RegionInit(&tmpRegion, &box, 1); RegionUnion(pRegion, pRegion, &tmpRegion); @@ -2472,7 +2298,7 @@ void nxagentPointsToDirtyRegion(DrawablePtr pDrawable, int mode, xp++; } - extents = *RegionExtents(pRegion); + BoxRec extents = *RegionExtents(pRegion); RegionReset(pRegion, &extents); @@ -2604,35 +2430,27 @@ void nxagentRegionsOnScreen(void) #endif /* - * If the synchronization loop breaks and the - * drawable synchronization cannot be completed, - * the remaining data is stored in a bitmap. - * The synchronization loop is then restarted - * using the bitmap as source instead of the - * drawable. + * If the synchronization loop breaks and the drawable synchronization + * cannot be completed, the remaining data is stored in a bitmap. The + * synchronization loop is then restarted using the bitmap as source + * instead of the drawable. */ void nxagentCreateDrawableBitmap(DrawablePtr pDrawable) { - PixmapPtr pBitmap; GCPtr pGC = NULL; RegionPtr pClipRegion = NullRegion; - int x, y; - int w, h; - int saveTrap; - #ifdef TEST fprintf(stderr, "nxagentCreateDrawableBitmap: Creating synchronization bitmap for [%s] at [%p].\n", nxagentDrawableType(pDrawable), (void *) pDrawable); #endif /* - * The bitmap is created only in the - * nxagent. + * The bitmap is created only in the nxagent. */ - saveTrap = nxagentGCTrap; + int saveTrap = nxagentGCTrap; nxagentGCTrap = 1; @@ -2646,9 +2464,8 @@ void nxagentCreateDrawableBitmap(DrawablePtr pDrawable) } /* - * Should create a function to append - * a bitmap to another, instead of - * destroying the old one. + * Should create a function to append a bitmap to another, instead + * of destroying the old one. */ if (nxagentDrawableBitmap(pDrawable) != NullPixmap) @@ -2683,15 +2500,14 @@ void nxagentCreateDrawableBitmap(DrawablePtr pDrawable) } /* - * FIXME: A better way it would be create the bitmap - * with the same extents of the clipRegion. This - * requires to save the offset with respect to the - * drawable origin like in the backing store. This - * becomes particularly important when the drawable - * is a huge window, because the pixmap creation - * would fail. + * FIXME: A better way it would be create the bitmap with the same + * extents of the clipRegion. This requires to save the offset with + * respect to the drawable origin like in the backing store. This + * becomes particularly important when the drawable is a huge + * window, because the pixmap creation would fail. */ + PixmapPtr pBitmap; pBitmap = nxagentCreatePixmap(pDrawable -> pScreen, pDrawable -> width, pDrawable -> height, pDrawable -> depth, 0); if (pBitmap == NULL) @@ -2707,10 +2523,10 @@ void nxagentCreateDrawableBitmap(DrawablePtr pDrawable) ValidateGC((DrawablePtr) pBitmap, pGC); - x = pClipRegion -> extents.x1; - y = pClipRegion -> extents.y1; - w = pClipRegion -> extents.x2 - pClipRegion -> extents.x1; - h = pClipRegion -> extents.y2 - pClipRegion -> extents.y1; + int x = pClipRegion -> extents.x1; + int y = pClipRegion -> extents.y1; + int w = pClipRegion -> extents.x2 - pClipRegion -> extents.x1; + int h = pClipRegion -> extents.y2 - pClipRegion -> extents.y1; nxagentCopyArea(pDrawable, (DrawablePtr) pBitmap, pGC, x, y, w, h, x, y); @@ -2850,9 +2666,8 @@ void nxagentAllocateCorruptedResource(DrawablePtr pDrawable, RESTYPE type) if (nxagentPixmapPriv(pRealPixmap) -> corruptedBackgroundId == 0) { /* - * When a pixmap is added to the background - * corrupted resources, it must be removed - * from the pixmap corrupted resources. + * When a pixmap is added to the background corrupted resources, + * it must be removed from the pixmap corrupted resources. */ nxagentDestroyCorruptedResource(pDrawable, RT_NX_CORR_PIXMAP); @@ -2873,8 +2688,8 @@ void nxagentAllocateCorruptedResource(DrawablePtr pDrawable, RESTYPE type) else if (type == RT_NX_CORR_PIXMAP) { /* - * The shared memory pixmaps are always dirty - * and shouldn't be synchronized. + * The shared memory pixmaps are always dirty and shouldn't be + * synchronized. */ if (nxagentPixmapUsageCounter((PixmapPtr) pDrawable) >= MINIMUM_PIXMAP_USAGE_COUNTER && @@ -3044,11 +2859,9 @@ int nxagentSynchronizationPredicate(void) } /* - * If there are resources to synchronize - * but the conditions to start the loop - * are not satisfied, a little delay is - * requested to check for a new loop as - * soon as possible. + * If there are resources to synchronize but the conditions to start + * the loop are not satisfied, a little delay is requested to check + * for a new loop as soon as possible. */ return Delayed; @@ -3150,7 +2963,6 @@ nxagentSendBackgroundExposeEnd: void nxagentExposeBackgroundPredicate(void *p0, XID x1, void *p2) { WindowPtr pWin = (WindowPtr) p0; - WindowPtr pParent; struct nxagentExposeBackground *pPair = p2; @@ -3176,7 +2988,7 @@ void nxagentExposeBackgroundPredicate(void *p0, XID x1, void *p2) (void *) pWin); #endif - pParent = pWin -> parent; + WindowPtr pParent = pWin -> parent; while (pParent != NULL) { @@ -3204,21 +3016,14 @@ void nxagentExposeBackgroundPredicate(void *p0, XID x1, void *p2) int nxagentClipAndSendClearExpose(WindowPtr pWin, void * ptr) { - RegionPtr exposeRgn; - RegionPtr remoteExposeRgn; - - #ifdef DEBUG - BoxRec box; - #endif - - remoteExposeRgn = (RegionRec *) ptr; + RegionPtr remoteExposeRgn = (RegionRec *) ptr; if (nxagentWindowPriv(pWin) -> deferredBackgroundExpose == 1) { - exposeRgn = RegionCreate(NULL, 1); + RegionPtr exposeRgn = RegionCreate(NULL, 1); #ifdef DEBUG - box = *RegionExtents(remoteExposeRgn); + BoxRec box = *RegionExtents(remoteExposeRgn); fprintf(stderr, "nxagentClipAndSendClearExpose: Background expose extents: [%d,%d,%d,%d].\n", box.x1, box.y1, box.x2, box.y2); @@ -3232,9 +3037,8 @@ int nxagentClipAndSendClearExpose(WindowPtr pWin, void * ptr) RegionIntersect(exposeRgn, remoteExposeRgn, &pWin -> clipList); /* - * If the region will be synchronized, - * the expose on corrupted regions can - * be ignored. + * If the region will be synchronized, the expose on corrupted + * regions can be ignored. */ RegionSubtract(exposeRgn, exposeRgn, nxagentCorruptedRegion((DrawablePtr) pWin)); @@ -3295,4 +3099,3 @@ void nxagentSendDeferredBackgroundExposures(void) RegionEmpty(nxagentDeferredBackgroundExposures); } } - |