uLab
/
xrdp-proprietary
mirror of https://mirror.git.trinitydesktop.org/gitea/uLab/xrdp-proprietary
0
0
Fork 0
Code Issues Releases Wiki Activity

xorg: work on xorg driver

Browse Source
ulab-next
Jay Sorg 11 years ago
parent 022c1e31f9
commit 6beb2364f3
23 changed files with 195 additions and 884 deletions
Show Stats Download Patch File Download Diff File

42
xorg/server/module/rdpClientCon.c
Unescape View File

@ -2076,3 +2076,45 @@ rdpClientConSendArea(rdpPtr dev, rdpClientCon *clientCon,
} }
} }
} }
/******************************************************************************/
int
rdpClientConAddAllReg(rdpPtr dev, RegionPtr reg, DrawablePtr pDrawable)
{
rdpClientCon *clientCon;
Bool drw_is_vis;
drw_is_vis = XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable);
if (!drw_is_vis)
{
return 0;
}
clientCon = dev->clientConHead;
while (clientCon != NULL)
{
rdpClientConAddDirtyScreenReg(dev, clientCon, reg);
clientCon = clientCon->next;
}
return 0;
}
/******************************************************************************/
int
rdpClientConAddAllBox(rdpPtr dev, BoxPtr box, DrawablePtr pDrawable)
{
rdpClientCon *clientCon;
Bool drw_is_vis;
drw_is_vis = XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable);
if (!drw_is_vis)
{
return 0;
}
clientCon = dev->clientConHead;
while (clientCon != NULL)
{
rdpClientConAddDirtyScreenBox(dev, clientCon, box);
clientCon = clientCon->next;
}
return 0;
}

5
xorg/server/module/rdpClientCon.h
Unescape View File

@ -143,6 +143,9 @@ rdpClientConAddDirtyScreenBox(rdpPtr dev, rdpClientCon *clientCon,
int int
rdpClientConAddDirtyScreen(rdpPtr dev, rdpClientCon *clientCon, rdpClientConAddDirtyScreen(rdpPtr dev, rdpClientCon *clientCon,
int x, int y, int cx, int cy); int x, int y, int cx, int cy);
int
rdpClientConAddAllReg(rdpPtr dev, RegionPtr reg, DrawablePtr pDrawable);
int
rdpClientConAddAllBox(rdpPtr dev, BoxPtr box, DrawablePtr pDrawable);
#endif #endif

58
xorg/server/module/rdpComposite.c
Unescape View File

@ -46,17 +46,6 @@ composite(alpha blending) calls
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpCompositePre(rdpPtr dev, rdpClientCon *clientCon,
PictureScreenPtr ps, CARD8 op, PicturePtr pSrc,
PicturePtr pMask, PicturePtr pDst,
INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask,
INT16 xDst, INT16 yDst, CARD16 width, CARD16 height,
BoxPtr box)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpCompositeOrg(PictureScreenPtr ps, rdpPtr dev, rdpCompositeOrg(PictureScreenPtr ps, rdpPtr dev,
@ -70,30 +59,6 @@ rdpCompositeOrg(PictureScreenPtr ps, rdpPtr dev,
ps->Composite = rdpComposite; ps->Composite = rdpComposite;
} }
/******************************************************************************/
static void
rdpCompositePost(rdpPtr dev, rdpClientCon *clientCon,
PictureScreenPtr ps, CARD8 op, PicturePtr pSrc,
PicturePtr pMask, PicturePtr pDst,
INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask,
INT16 xDst, INT16 yDst, CARD16 width, CARD16 height,
BoxPtr box)
{
RegionRec reg;
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDst->pDrawable))
{
return;
}
rdpRegionInit(&reg, box, 0);
if (pDst->pCompositeClip != 0)
{
rdpRegionIntersect(&reg, pDst->pCompositeClip, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, rdpComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
@ -102,9 +67,9 @@ rdpComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
{ {
ScreenPtr pScreen; ScreenPtr pScreen;
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
PictureScreenPtr ps; PictureScreenPtr ps;
BoxRec box; BoxRec box;
RegionRec reg;
LLOGLN(10, ("rdpComposite:")); LLOGLN(10, ("rdpComposite:"));
pScreen = pDst->pDrawable->pScreen; pScreen = pDst->pDrawable->pScreen;
@ -114,24 +79,15 @@ rdpComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
box.y1 = yDst + pDst->pDrawable->y; box.y1 = yDst + pDst->pDrawable->y;
box.x2 = box.x1 + width; box.x2 = box.x1 + width;
box.y2 = box.y1 + height; box.y2 = box.y1 + height;
ps = GetPictureScreen(pScreen); rdpRegionInit(&reg, &box, 0);
clientCon = dev->clientConHead; if (pDst->pCompositeClip != NULL)
while (clientCon != NULL)
{ {
rdpCompositePre(dev, clientCon, ps, op, pSrc, pMask, pDst, rdpRegionIntersect(&reg, pDst->pCompositeClip, &reg);
xSrc, ySrc, xMask, yMask, xDst, yDst,
width, height, &box);
clientCon = clientCon->next;
} }
ps = GetPictureScreen(pScreen);
/* do original call */ /* do original call */
rdpCompositeOrg(ps, dev, op, pSrc, pMask, pDst, xSrc, ySrc, rdpCompositeOrg(ps, dev, op, pSrc, pMask, pDst, xSrc, ySrc,
xMask, yMask, xDst, yDst, width, height); xMask, yMask, xDst, yDst, width, height);
clientCon = dev->clientConHead; rdpClientConAddAllReg(dev, &reg, pDst->pDrawable);
while (clientCon != NULL) rdpRegionUninit(&reg);
{
rdpCompositePost(dev, clientCon, ps, op, pSrc, pMask, pDst,
xSrc, ySrc, xMask, yMask, xDst, yDst,
width, height, &box);
clientCon = clientCon->next;
}
} }

53
xorg/server/module/rdpCopyArea.c
Unescape View File

@ -39,16 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpCopyAreaPre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
int srcx, int srcy, int w, int h, int dstx, int dsty,
RegionPtr reg)
{
}
/******************************************************************************/ /******************************************************************************/
static RegionPtr static RegionPtr
rdpCopyAreaOrg(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, rdpCopyAreaOrg(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
@ -63,69 +53,38 @@ rdpCopyAreaOrg(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
return rv; return rv;
} }
/******************************************************************************/
static void
rdpCopyAreaPost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
int srcx, int srcy, int w, int h, int dstx, int dsty,
RegionPtr reg)
{
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDst))
{
return;
}
rdpClientConAddDirtyScreenReg(dev, clientCon, reg);
}
/******************************************************************************/ /******************************************************************************/
RegionPtr RegionPtr
rdpCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, rdpCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
int srcx, int srcy, int w, int h, int dstx, int dsty) int srcx, int srcy, int w, int h, int dstx, int dsty)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionPtr rv; RegionPtr rv;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg;
int cd; int cd;
BoxRec box; BoxRec box;
RegionRec reg;
LLOGLN(10, ("rdpCopyArea:")); LLOGLN(10, ("rdpCopyArea:"));
dev = rdpGetDevFromScreen(pGC->pScreen); dev = rdpGetDevFromScreen(pGC->pScreen);
dev->counts.rdpCopyAreaCallCount++; dev->counts.rdpCopyAreaCallCount++;
rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDst, pGC);
LLOGLN(10, ("rdpCopyArea: cd %d", cd));
box.x1 = dstx + pDst->x; box.x1 = dstx + pDst->x;
box.y1 = dsty + pDst->y; box.y1 = dsty + pDst->y;
box.x2 = box.x1 + w; box.x2 = box.x1 + w;
box.y2 = box.y1 + h; box.y2 = box.y1 + h;
rdpRegionInit(&reg, &box, 0); rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDst, pGC);
LLOGLN(10, ("rdpCopyArea: cd %d", cd));
if (cd == XRDP_CD_CLIP) if (cd == XRDP_CD_CLIP)
{ {
rdpRegionIntersect(&reg, &clip_reg, &reg); rdpRegionIntersect(&reg, &clip_reg, &reg);
} }
clientCon = dev->clientConHead;
while (clientCon != NULL)
{
rdpCopyAreaPre(dev, clientCon, cd, &clip_reg, pSrc, pDst, pGC,
srcx, srcy, w, h, dstx, dsty, &reg);
clientCon = clientCon->next;
}
/* do original call */ /* do original call */
rv = rdpCopyAreaOrg(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty); rv = rdpCopyAreaOrg(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpCopyAreaPost(dev, clientCon, cd, &clip_reg, pSrc, pDst, pGC, rdpClientConAddAllReg(dev, &reg, pDst);
srcx, srcy, w, h, dstx, dsty, &reg);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg); rdpRegionUninit(&reg);

57
xorg/server/module/rdpCopyPlane.c
Unescape View File

@ -39,16 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpCopyPlanePre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pSrc, DrawablePtr pDst,
GCPtr pGC, int srcx, int srcy, int w, int h,
int dstx, int dsty, unsigned long bitPlane, BoxPtr box)
{
}
/******************************************************************************/ /******************************************************************************/
static RegionPtr static RegionPtr
rdpCopyPlaneOrg(DrawablePtr pSrc, DrawablePtr pDst, rdpCopyPlaneOrg(DrawablePtr pSrc, DrawablePtr pDst,
@ -65,33 +55,6 @@ rdpCopyPlaneOrg(DrawablePtr pSrc, DrawablePtr pDst,
return rv; return rv;
} }
/******************************************************************************/
static void
rdpCopyPlanePost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pSrc, DrawablePtr pDst,
GCPtr pGC, int srcx, int srcy, int w, int h,
int dstx, int dsty, unsigned long bitPlane, BoxPtr box)
{
RegionRec reg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDst))
{
return;
}
rdpRegionInit(&reg, box, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&reg, clip_reg, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
RegionPtr RegionPtr
rdpCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, rdpCopyPlane(DrawablePtr pSrc, DrawablePtr pDst,
@ -100,8 +63,8 @@ rdpCopyPlane(DrawablePtr pSrc, DrawablePtr pDst,
{ {
RegionPtr rv; RegionPtr rv;
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg;
int cd; int cd;
BoxRec box; BoxRec box;
@ -112,28 +75,22 @@ rdpCopyPlane(DrawablePtr pSrc, DrawablePtr pDst,
box.y1 = pDst->y + dsty; box.y1 = pDst->y + dsty;
box.x2 = box.x1 + w; box.x2 = box.x1 + w;
box.y2 = box.x1 + h; box.y2 = box.x1 + h;
rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDst, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDst, pGC);
LLOGLN(10, ("rdpCopyPlane: cd %d", cd)); LLOGLN(10, ("rdpCopyPlane: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpCopyPlanePre(dev, clientCon, cd, &clip_reg, pSrc, pDst, rdpRegionIntersect(&reg, &clip_reg, &reg);
pGC, srcx, srcy, w, h,
dstx, dsty, bitPlane, &box);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rv = rdpCopyPlaneOrg(pSrc, pDst, pGC, srcx, srcy, w, h, rv = rdpCopyPlaneOrg(pSrc, pDst, pGC, srcx, srcy, w, h,
dstx, dsty, bitPlane); dstx, dsty, bitPlane);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpCopyPlanePost(dev, clientCon, cd, &clip_reg, pSrc, pDst, rdpClientConAddAllReg(dev, &reg, pDst);
pGC, srcx, srcy, w, h,
dstx, dsty, bitPlane, &box);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
return rv; return rv;
} }

36
xorg/server/module/rdpDraw.c
Unescape View File

@ -289,7 +289,6 @@ rdpCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr pOldRegion)
{ {
ScreenPtr pScreen; ScreenPtr pScreen;
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec reg; RegionRec reg;
RegionRec clip; RegionRec clip;
int dx; int dx;
@ -297,7 +296,9 @@ rdpCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr pOldRegion)
int num_clip_rects; int num_clip_rects;
int num_reg_rects; int num_reg_rects;
BoxPtr box; BoxPtr box;
BoxRec box1;
LLOGLN(10, ("rdpCopyWindow:"));
pScreen = pWin->drawable.pScreen; pScreen = pWin->drawable.pScreen;
dev = rdpGetDevFromScreen(pScreen); dev = rdpGetDevFromScreen(pScreen);
dev->counts.rdpCopyWindowCallCount++; dev->counts.rdpCopyWindowCallCount++;
@ -318,30 +319,25 @@ rdpCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr pOldRegion)
if ((num_clip_rects == 0) || (num_reg_rects == 0)) if ((num_clip_rects == 0) || (num_reg_rects == 0))
{ {
rdpRegionUninit(&reg);
rdpRegionUninit(&clip);
return;
} }
else
if ((num_clip_rects > 16) && (num_reg_rects > 16))
{ {
box = rdpRegionExtents(&reg); if ((num_clip_rects > 16) || (num_reg_rects > 16))
clientCon = dev->clientConHead;
while (clientCon != NULL)
{ {
rdpClientConAddDirtyScreenBox(dev, clientCon, box); LLOGLN(10, ("rdpCopyWindow: big list"));
clientCon = clientCon->next; box = rdpRegionExtents(&reg);
box1 = *box;
box1.x1 += dx;
box1.y1 += dy;
box1.x2 += dx;
box1.y2 += dy;
rdpClientConAddAllBox(dev, &box1, &(pWin->drawable));
} }
} else
else
{
rdpRegionTranslate(&reg, dx, dy);
rdpRegionIntersect(&reg, &reg, &clip);
clientCon = dev->clientConHead;
while (clientCon != NULL)
{ {
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg); rdpRegionTranslate(&reg, dx, dy);
clientCon = clientCon->next; rdpRegionIntersect(&reg, &reg, &clip);
rdpClientConAddAllReg(dev, &reg, &(pWin->drawable));
} }
} }
rdpRegionUninit(&reg); rdpRegionUninit(&reg);

55
xorg/server/module/rdpFillPolygon.c
Unescape View File

@ -39,16 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
void
rdpFillPolygonPre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int shape, int mode, int count,
DDXPointPtr pPts, BoxPtr box)
{
}
/******************************************************************************/ /******************************************************************************/
void void
rdpFillPolygonOrg(DrawablePtr pDrawable, GCPtr pGC, rdpFillPolygonOrg(DrawablePtr pDrawable, GCPtr pGC,
@ -62,33 +52,6 @@ rdpFillPolygonOrg(DrawablePtr pDrawable, GCPtr pGC,
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
void
rdpFillPolygonPost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int shape, int mode, int count,
DDXPointPtr pPts, BoxPtr box)
{
RegionRec reg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpRegionInit(&reg, box, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&reg, clip_reg, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpFillPolygon(DrawablePtr pDrawable, GCPtr pGC, rdpFillPolygon(DrawablePtr pDrawable, GCPtr pGC,
@ -96,8 +59,8 @@ rdpFillPolygon(DrawablePtr pDrawable, GCPtr pGC,
DDXPointPtr pPts) DDXPointPtr pPts)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg;
int cd; int cd;
int maxx; int maxx;
int maxy; int maxy;
@ -135,24 +98,20 @@ rdpFillPolygon(DrawablePtr pDrawable, GCPtr pGC,
box.x2 = pDrawable->x + maxx + 1; box.x2 = pDrawable->x + maxx + 1;
box.y2 = pDrawable->y + maxy + 1; box.y2 = pDrawable->y + maxy + 1;
} }
rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpFillPolygon: cd %d", cd)); LLOGLN(10, ("rdpFillPolygon: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpFillPolygonPre(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpRegionIntersect(&reg, &clip_reg, &reg);
shape, mode, count, pPts, &box);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpFillPolygonOrg(pDrawable, pGC, shape, mode, count, pPts); rdpFillPolygonOrg(pDrawable, pGC, shape, mode, count, pPts);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpFillPolygonPost(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpClientConAddAllReg(dev, &reg, pDrawable);
shape, mode, count, pPts, &box);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
} }

57
xorg/server/module/rdpImageGlyphBlt.c
Unescape View File

@ -39,17 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpImageGlyphBltPre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, unsigned int nglyph,
CharInfoPtr *ppci, pointer pglyphBase,
BoxPtr box)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpImageGlyphBltOrg(DrawablePtr pDrawable, GCPtr pGC, rdpImageGlyphBltOrg(DrawablePtr pDrawable, GCPtr pGC,
@ -63,34 +52,6 @@ rdpImageGlyphBltOrg(DrawablePtr pDrawable, GCPtr pGC,
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
static void
rdpImageGlyphBltPost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, unsigned int nglyph,
CharInfoPtr *ppci, pointer pglyphBase,
BoxPtr box)
{
RegionRec reg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpRegionInit(&reg, box, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&reg, clip_reg, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, rdpImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
@ -98,8 +59,8 @@ rdpImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
CharInfoPtr *ppci, pointer pglyphBase) CharInfoPtr *ppci, pointer pglyphBase)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg;
int cd; int cd;
BoxRec box; BoxRec box;
@ -107,24 +68,20 @@ rdpImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
dev = rdpGetDevFromScreen(pGC->pScreen); dev = rdpGetDevFromScreen(pGC->pScreen);
dev->counts.rdpImageGlyphBltCallCount++; dev->counts.rdpImageGlyphBltCallCount++;
GetTextBoundingBox(pDrawable, pGC->font, x, y, nglyph, &box); GetTextBoundingBox(pDrawable, pGC->font, x, y, nglyph, &box);
rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpImageGlyphBlt: cd %d", cd)); LLOGLN(10, ("rdpImageGlyphBlt: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpImageGlyphBltPre(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpRegionIntersect(&reg, &clip_reg, &reg);
x, y, nglyph, ppci, pglyphBase, &box);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpImageGlyphBltOrg(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase); rdpImageGlyphBltOrg(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpImageGlyphBltPost(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpClientConAddAllReg(dev, &reg, pDrawable);
x, y, nglyph, ppci, pglyphBase, &box);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
} }

55
xorg/server/module/rdpImageText16.c
Unescape View File

@ -39,16 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpImageText16Pre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, unsigned short *chars,
BoxPtr box)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpImageText16Org(DrawablePtr pDrawable, GCPtr pGC, rdpImageText16Org(DrawablePtr pDrawable, GCPtr pGC,
@ -61,41 +51,14 @@ rdpImageText16Org(DrawablePtr pDrawable, GCPtr pGC,
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
static void
rdpImageText16Post(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, unsigned short *chars,
BoxPtr box)
{
RegionRec reg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpRegionInit(&reg, box, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&reg, clip_reg, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpImageText16(DrawablePtr pDrawable, GCPtr pGC, rdpImageText16(DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, unsigned short *chars) int x, int y, int count, unsigned short *chars)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg;
int cd; int cd;
BoxRec box; BoxRec box;
@ -103,24 +66,20 @@ rdpImageText16(DrawablePtr pDrawable, GCPtr pGC,
dev = rdpGetDevFromScreen(pGC->pScreen); dev = rdpGetDevFromScreen(pGC->pScreen);
dev->counts.rdpImageText16CallCount++; dev->counts.rdpImageText16CallCount++;
GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box); GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box);
rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpImageText16: cd %d", cd)); LLOGLN(10, ("rdpImageText16: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpImageText16Pre(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpRegionIntersect(&reg, &clip_reg, &reg);
x, y, count, chars, &box);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpImageText16Org(pDrawable, pGC, x, y, count, chars); rdpImageText16Org(pDrawable, pGC, x, y, count, chars);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpImageText16Post(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpClientConAddAllReg(dev, &reg, pDrawable);
x, y, count, chars, &box);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
} }

55
xorg/server/module/rdpImageText8.c
Unescape View File

@ -39,16 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpImageText8Pre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, char *chars,
BoxPtr box)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpImageText8Org(DrawablePtr pDrawable, GCPtr pGC, rdpImageText8Org(DrawablePtr pDrawable, GCPtr pGC,
@ -61,41 +51,14 @@ rdpImageText8Org(DrawablePtr pDrawable, GCPtr pGC,
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
static void
rdpImageText8Post(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, char *chars,
BoxPtr box)
{
RegionRec reg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpRegionInit(&reg, box, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&reg, clip_reg, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpImageText8(DrawablePtr pDrawable, GCPtr pGC, rdpImageText8(DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, char *chars) int x, int y, int count, char *chars)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg;
int cd; int cd;
BoxRec box; BoxRec box;
@ -103,24 +66,20 @@ rdpImageText8(DrawablePtr pDrawable, GCPtr pGC,
dev = rdpGetDevFromScreen(pGC->pScreen); dev = rdpGetDevFromScreen(pGC->pScreen);
dev->counts.rdpImageText8CallCount++; dev->counts.rdpImageText8CallCount++;
GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box); GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box);
rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpImageText8: cd %d", cd)); LLOGLN(10, ("rdpImageText8: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpImageText8Pre(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpRegionIntersect(&reg, &clip_reg, &reg);
x, y, count, chars, &box);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpImageText8Org(pDrawable, pGC, x, y, count, chars); rdpImageText8Org(pDrawable, pGC, x, y, count, chars);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpImageText8Post(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpClientConAddAllReg(dev, &reg, pDrawable);
x, y, count, chars, &box);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
} }

44
xorg/server/module/rdpPolyArc.c
Unescape View File

@ -39,15 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpPolyArcPre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs,
RegionPtr reg)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpPolyArcOrg(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs) rdpPolyArcOrg(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
@ -59,30 +50,11 @@ rdpPolyArcOrg(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
static void
rdpPolyArcPost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs,
RegionPtr reg)
{
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpClientConAddDirtyScreenReg(dev, clientCon, reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpPolyArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs) rdpPolyArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
BoxRec box; BoxRec box;
int index; int index;
int cd; int cd;
@ -119,22 +91,12 @@ rdpPolyArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
{ {
rdpRegionIntersect(&reg, &clip_reg, &reg); rdpRegionIntersect(&reg, &clip_reg, &reg);
} }
clientCon = dev->clientConHead;
while (clientCon != NULL)
{
rdpPolyArcPre(dev, clientCon, cd, &clip_reg, pDrawable, pGC,
narcs, parcs, &reg);
clientCon = clientCon->next;
}
/* do original call */ /* do original call */
rdpPolyArcOrg(pDrawable, pGC, narcs, parcs); rdpPolyArcOrg(pDrawable, pGC, narcs, parcs);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpPolyArcPost(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpClientConAddAllReg(dev, &reg, pDrawable);
narcs, parcs, &reg);
clientCon = clientCon->next;
} }
rdpRegionUninit(&reg);
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
} }

49
xorg/server/module/rdpPolyFillArc.c
Unescape View File

@ -39,15 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpPolyFillArcPre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs,
RegionPtr reg)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpPolyFillArcOrg(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs) rdpPolyFillArcOrg(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
@ -59,34 +50,11 @@ rdpPolyFillArcOrg(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
static void
rdpPolyFillArcPost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs,
RegionPtr reg)
{
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(reg, clip_reg, reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs) rdpPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
BoxRec box; BoxRec box;
int index; int index;
int cd; int cd;
@ -119,23 +87,16 @@ rdpPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpPolyFillArc: cd %d", cd)); LLOGLN(10, ("rdpPolyFillArc: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpPolyFillArcPre(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpRegionIntersect(&reg, &clip_reg, &reg);
narcs, parcs, &reg);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpPolyFillArcOrg(pDrawable, pGC, narcs, parcs); rdpPolyFillArcOrg(pDrawable, pGC, narcs, parcs);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpPolyFillArcPost(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpClientConAddAllReg(dev, &reg, pDrawable);
narcs, parcs, &reg);
clientCon = clientCon->next;
} }
rdpRegionUninit(&reg);
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
} }

46
xorg/server/module/rdpPolyFillRect.c
Unescape View File

@ -39,16 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpPolyFillRectPre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int nrectFill, xRectangle *prectInit,
RegionPtr reg)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpPolyFillRectOrg(DrawablePtr pDrawable, GCPtr pGC, int nrectFill, rdpPolyFillRectOrg(DrawablePtr pDrawable, GCPtr pGC, int nrectFill,
@ -61,32 +51,12 @@ rdpPolyFillRectOrg(DrawablePtr pDrawable, GCPtr pGC, int nrectFill,
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
static void
rdpPolyFillRectPost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int nrectFill, xRectangle *prectInit,
RegionPtr reg)
{
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpClientConAddDirtyScreenReg(dev, clientCon, reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill, rdpPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill,
xRectangle *prectInit) xRectangle *prectInit)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionPtr reg; RegionPtr reg;
int cd; int cd;
@ -99,26 +69,16 @@ rdpPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill,
rdpRegionTranslate(reg, pDrawable->x, pDrawable->y); rdpRegionTranslate(reg, pDrawable->x, pDrawable->y);
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpPolyFillRect: cd %d", cd));
if (cd == XRDP_CD_CLIP) if (cd == XRDP_CD_CLIP)
{ {
rdpRegionIntersect(reg, &clip_reg, reg); rdpRegionIntersect(reg, &clip_reg, reg);
} }
LLOGLN(10, ("rdpPolyFillRect: cd %d", cd));
clientCon = dev->clientConHead;
while (clientCon != NULL)
{
rdpPolyFillRectPre(dev, clientCon, cd, &clip_reg, pDrawable,
pGC, nrectFill, prectInit, reg);
clientCon = clientCon->next;
}
/* do original call */ /* do original call */
rdpPolyFillRectOrg(pDrawable, pGC, nrectFill, prectInit); rdpPolyFillRectOrg(pDrawable, pGC, nrectFill, prectInit);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpPolyFillRectPost(dev, clientCon, cd, &clip_reg, pDrawable, rdpClientConAddAllReg(dev, reg, pDrawable);
pGC, nrectFill, prectInit, reg);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionDestroy(reg); rdpRegionDestroy(reg);

25
xorg/server/module/rdpPolyGlyphBlt.c
Unescape View File

@ -32,6 +32,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "rdp.h" #include "rdp.h"
#include "rdpDraw.h" #include "rdpDraw.h"
#include "rdpClientCon.h"
#include "rdpReg.h"
#define LOG_LEVEL 1 #define LOG_LEVEL 1
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
@ -56,7 +58,30 @@ rdpPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
int x, int y, unsigned int nglyph, int x, int y, unsigned int nglyph,
CharInfoPtr *ppci, pointer pglyphBase) CharInfoPtr *ppci, pointer pglyphBase)
{ {
rdpPtr dev;
RegionRec clip_reg;
RegionRec reg;
int cd;
BoxRec box;
LLOGLN(0, ("rdpPolyGlyphBlt:")); LLOGLN(0, ("rdpPolyGlyphBlt:"));
dev = rdpGetDevFromScreen(pGC->pScreen);
dev->counts.rdpPolyGlyphBltCallCount++;
GetTextBoundingBox(pDrawable, pGC->font, x, y, nglyph, &box);
rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpPolyGlyphBlt: cd %d", cd));
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&reg, &clip_reg, &reg);
}
/* do original call */ /* do original call */
rdpPolyGlyphBltOrg(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase); rdpPolyGlyphBltOrg(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
if (cd != XRDP_CD_NODRAW)
{
rdpClientConAddAllReg(dev, &reg, pDrawable);
}
rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
} }

52
xorg/server/module/rdpPolyPoint.c
Unescape View File

@ -39,15 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpPolyPointPre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int mode,
int npt, DDXPointPtr in_pts, RegionPtr reg)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpPolyPointOrg(DrawablePtr pDrawable, GCPtr pGC, int mode, rdpPolyPointOrg(DrawablePtr pDrawable, GCPtr pGC, int mode,
@ -60,46 +51,19 @@ rdpPolyPointOrg(DrawablePtr pDrawable, GCPtr pGC, int mode,
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
static void
rdpPolyPointPost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int mode,
int npt, DDXPointPtr in_pts, RegionPtr reg)
{
RegionRec lreg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpRegionInit(&lreg, NullBox, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&lreg, clip_reg, reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &lreg);
rdpRegionUninit(&lreg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, rdpPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode,
int npt, DDXPointPtr in_pts) int npt, DDXPointPtr in_pts)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg; RegionRec reg;
int cd; int cd;
int index; int index;
BoxRec box; BoxRec box;
LLOGLN(0, ("rdpPolyPoint:")); LLOGLN(10, ("rdpPolyPoint:"));
dev = rdpGetDevFromScreen(pGC->pScreen); dev = rdpGetDevFromScreen(pGC->pScreen);
dev->counts.rdpPolyPointCallCount++; dev->counts.rdpPolyPointCallCount++;
rdpRegionInit(&reg, NullBox, 0); rdpRegionInit(&reg, NullBox, 0);
@ -114,21 +78,15 @@ rdpPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode,
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpPolyPoint: cd %d", cd)); LLOGLN(10, ("rdpPolyPoint: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpPolyPointPre(dev, clientCon, cd, &clip_reg, pDrawable, rdpRegionIntersect(&reg, &clip_reg, &reg);
pGC, mode, npt, in_pts, &reg);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpPolyPointOrg(pDrawable, pGC, mode, npt, in_pts); rdpPolyPointOrg(pDrawable, pGC, mode, npt, in_pts);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpPolyPointPost(dev, clientCon, cd, &clip_reg, pDrawable, rdpClientConAddAllReg(dev, &reg, pDrawable);
pGC, mode, npt, in_pts, &reg);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg); rdpRegionUninit(&reg);

56
xorg/server/module/rdpPolyRectangle.c
Unescape View File

@ -39,15 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
void
rdpPolyRectanglePre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int nrects,
xRectangle *rects, RegionPtr reg)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpPolyRectangleOrg(DrawablePtr pDrawable, GCPtr pGC, int nrects, rdpPolyRectangleOrg(DrawablePtr pDrawable, GCPtr pGC, int nrects,
@ -60,35 +51,12 @@ rdpPolyRectangleOrg(DrawablePtr pDrawable, GCPtr pGC, int nrects,
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
void
rdpPolyRectanglePost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int nrects,
xRectangle *rects, RegionPtr reg)
{
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(reg, clip_reg, reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nrects, rdpPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nrects,
xRectangle *rects) xRectangle *rects)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
BoxRec box; BoxRec box;
int index; int index;
int up; int up;
@ -116,63 +84,49 @@ rdpPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nrects,
index = 0; index = 0;
while (index < nrects) while (index < nrects)
{ {
x1 = rects[index].x + pDrawable->x; x1 = rects[index].x + pDrawable->x;
y1 = rects[index].y + pDrawable->y; y1 = rects[index].y + pDrawable->y;
x2 = x1 + rects[index].width; x2 = x1 + rects[index].width;
y2 = y1 + rects[index].height; y2 = y1 + rects[index].height;
/* top */ /* top */
box.x1 = x1 - up; box.x1 = x1 - up;
box.y1 = y1 - up; box.y1 = y1 - up;
box.x2 = x2 + down; box.x2 = x2 + down;
box.y2 = y1 + down; box.y2 = y1 + down;
rdpRegionUnionRect(&reg, &box); rdpRegionUnionRect(&reg, &box);
/* left */ /* left */
box.x1 = x1 - up; box.x1 = x1 - up;
box.y1 = y1 - up; box.y1 = y1 - up;
box.x2 = x1 + down; box.x2 = x1 + down;
box.y2 = y2 + down; box.y2 = y2 + down;
rdpRegionUnionRect(&reg, &box); rdpRegionUnionRect(&reg, &box);
/* right */ /* right */
box.x1 = x2 - up; box.x1 = x2 - up;
box.y1 = y1 - up; box.y1 = y1 - up;
box.x2 = x2 + down; box.x2 = x2 + down;
box.y2 = y2 + down; box.y2 = y2 + down;
rdpRegionUnionRect(&reg, &box); rdpRegionUnionRect(&reg, &box);
/* bottom */ /* bottom */
box.x1 = x1 - up; box.x1 = x1 - up;
box.y1 = y2 - up; box.y1 = y2 - up;
box.x2 = x2 + down; box.x2 = x2 + down;
box.y2 = y2 + down; box.y2 = y2 + down;
rdpRegionUnionRect(&reg, &box); rdpRegionUnionRect(&reg, &box);
index++; index++;
} }
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpPolyRectangle: cd %d", cd)); LLOGLN(10, ("rdpPolyRectangle: cd %d", cd));
if (cd == XRDP_CD_CLIP)
clientCon = dev->clientConHead;
while (clientCon != NULL)
{ {
rdpPolyRectanglePre(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpRegionIntersect(&reg, &clip_reg, &reg);
nrects, rects, &reg);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpPolyRectangleOrg(pDrawable, pGC, nrects, rects); rdpPolyRectangleOrg(pDrawable, pGC, nrects, rects);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpPolyRectanglePost(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpClientConAddAllReg(dev, &reg, pDrawable);
nrects, rects, &reg);
clientCon = clientCon->next;
} }
rdpRegionUninit(&reg);
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
} }

52
xorg/server/module/rdpPolySegment.c
Unescape View File

@ -39,15 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
void
rdpPolySegmentPre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int nseg,
xSegment *pSegs, RegionPtr reg)
{
}
/******************************************************************************/ /******************************************************************************/
void void
rdpPolySegmentOrg(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *pSegs) rdpPolySegmentOrg(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *pSegs)
@ -59,38 +50,11 @@ rdpPolySegmentOrg(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *pSegs)
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
void
rdpPolySegmentPost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int nseg,
xSegment *pSegs, RegionPtr reg)
{
RegionRec lreg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpRegionInit(&lreg, NullBox, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&lreg, clip_reg, reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &lreg);
rdpRegionUninit(&lreg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *pSegs) rdpPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *pSegs)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg; RegionRec reg;
int cd; int cd;
@ -120,24 +84,16 @@ rdpPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *pSegs)
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpPolySegment: cd %d", cd)); LLOGLN(10, ("rdpPolySegment: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpPolySegmentPre(dev, clientCon, cd, &clip_reg, pDrawable, rdpRegionIntersect(&reg, &clip_reg, &reg);
pGC, nseg, pSegs, &reg);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpPolySegmentOrg(pDrawable, pGC, nseg, pSegs); rdpPolySegmentOrg(pDrawable, pGC, nseg, pSegs);
if (cd != XRDP_CD_NODRAW)
clientCon = dev->clientConHead;
while (clientCon != NULL)
{ {
rdpPolySegmentPost(dev, clientCon, cd, &clip_reg, pDrawable, rdpClientConAddAllReg(dev, &reg, pDrawable);
pGC, nseg, pSegs, &reg);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg); rdpRegionUninit(&reg);
} }

55
xorg/server/module/rdpPolyText16.c
Unescape View File

@ -39,16 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpPolyText16Pre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, unsigned short *chars,
BoxPtr box)
{
}
/******************************************************************************/ /******************************************************************************/
static int static int
rdpPolyText16Org(DrawablePtr pDrawable, GCPtr pGC, rdpPolyText16Org(DrawablePtr pDrawable, GCPtr pGC,
@ -63,33 +53,6 @@ rdpPolyText16Org(DrawablePtr pDrawable, GCPtr pGC,
return rv; return rv;
} }
/******************************************************************************/
static void
rdpPolyText16Post(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, unsigned short *chars,
BoxPtr box)
{
RegionRec reg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpRegionInit(&reg, box, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&reg, clip_reg, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
int int
rdpPolyText16(DrawablePtr pDrawable, GCPtr pGC, rdpPolyText16(DrawablePtr pDrawable, GCPtr pGC,
@ -97,8 +60,8 @@ rdpPolyText16(DrawablePtr pDrawable, GCPtr pGC,
{ {
int rv; int rv;
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg;
int cd; int cd;
BoxRec box; BoxRec box;
@ -106,25 +69,21 @@ rdpPolyText16(DrawablePtr pDrawable, GCPtr pGC,
dev = rdpGetDevFromScreen(pGC->pScreen); dev = rdpGetDevFromScreen(pGC->pScreen);
dev->counts.rdpPolyText16CallCount++; dev->counts.rdpPolyText16CallCount++;
GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box); GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box);
rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpPolyText16: cd %d", cd)); LLOGLN(10, ("rdpPolyText16: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpPolyText16Pre(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpRegionIntersect(&reg, &clip_reg, &reg);
x, y, count, chars, &box);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rv = rdpPolyText16Org(pDrawable, pGC, x, y, count, chars); rv = rdpPolyText16Org(pDrawable, pGC, x, y, count, chars);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpPolyText16Post(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpClientConAddAllReg(dev, &reg, pDrawable);
x, y, count, chars, &box);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
return rv; return rv;
} }

55
xorg/server/module/rdpPolyText8.c
Unescape View File

@ -39,16 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpPolyText8Pre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, char *chars,
BoxPtr box)
{
}
/******************************************************************************/ /******************************************************************************/
static int static int
rdpPolyText8Org(DrawablePtr pDrawable, GCPtr pGC, rdpPolyText8Org(DrawablePtr pDrawable, GCPtr pGC,
@ -63,33 +53,6 @@ rdpPolyText8Org(DrawablePtr pDrawable, GCPtr pGC,
return rv; return rv;
} }
/******************************************************************************/
static void
rdpPolyText8Post(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC,
int x, int y, int count, char *chars,
BoxPtr box)
{
RegionRec reg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpRegionInit(&reg, box, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&reg, clip_reg, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
int int
rdpPolyText8(DrawablePtr pDrawable, GCPtr pGC, rdpPolyText8(DrawablePtr pDrawable, GCPtr pGC,
@ -97,8 +60,8 @@ rdpPolyText8(DrawablePtr pDrawable, GCPtr pGC,
{ {
int rv; int rv;
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg;
int cd; int cd;
BoxRec box; BoxRec box;
@ -106,25 +69,21 @@ rdpPolyText8(DrawablePtr pDrawable, GCPtr pGC,
dev = rdpGetDevFromScreen(pGC->pScreen); dev = rdpGetDevFromScreen(pGC->pScreen);
dev->counts.rdpPolyText8CallCount++; dev->counts.rdpPolyText8CallCount++;
GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box); GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box);
rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpPolyText8: cd %d", cd)); LLOGLN(10, ("rdpPolyText8: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpPolyText8Pre(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpRegionIntersect(&reg, &clip_reg, &reg);
x, y, count, chars, &box);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rv = rdpPolyText8Org(pDrawable, pGC, x, y, count, chars); rv = rdpPolyText8Org(pDrawable, pGC, x, y, count, chars);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpPolyText8Post(dev, clientCon, cd, &clip_reg, pDrawable, pGC, rdpClientConAddAllReg(dev, &reg, pDrawable);
x, y, count, chars, &box);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
return rv; return rv;
} }

50
xorg/server/module/rdpPolylines.c
Unescape View File

@ -39,15 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
void
rdpPolylinesPre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int mode,
int npt, DDXPointPtr pptInit, RegionPtr reg)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpPolylinesOrg(DrawablePtr pDrawable, GCPtr pGC, int mode, rdpPolylinesOrg(DrawablePtr pDrawable, GCPtr pGC, int mode,
@ -60,39 +51,12 @@ rdpPolylinesOrg(DrawablePtr pDrawable, GCPtr pGC, int mode,
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
void
rdpPolylinesPost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDrawable, GCPtr pGC, int mode,
int npt, DDXPointPtr pptInit, RegionPtr reg)
{
RegionRec lreg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable))
{
return;
}
rdpRegionInit(&lreg, NullBox, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&lreg, clip_reg, reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &lreg);
rdpRegionUninit(&lreg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, rdpPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode,
int npt, DDXPointPtr pptInit) int npt, DDXPointPtr pptInit)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg; RegionRec reg;
int cd; int cd;
@ -122,21 +86,15 @@ rdpPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode,
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDrawable, pGC);
LLOGLN(10, ("rdpPolylines: cd %d", cd)); LLOGLN(10, ("rdpPolylines: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpPolylinesPre(dev, clientCon, cd, &clip_reg, pDrawable, rdpRegionIntersect(&reg, &clip_reg, &reg);
pGC, mode, npt, pptInit, &reg);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpPolylinesOrg(pDrawable, pGC, mode, npt, pptInit); rdpPolylinesOrg(pDrawable, pGC, mode, npt, pptInit);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpPolylinesPost(dev, clientCon, cd, &clip_reg, pDrawable, rdpClientConAddAllReg(dev, &reg, pDrawable);
pGC, mode, npt, pptInit, &reg);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg); rdpRegionUninit(&reg);

64
xorg/server/module/rdpPutImage.c
Unescape View File

@ -39,15 +39,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
void
rdpPutImagePre(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDst, GCPtr pGC, int depth, int x, int y,
int w, int h, int leftPad, int format, char *pBits)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpPutImageOrg(DrawablePtr pDst, GCPtr pGC, int depth, int x, int y, rdpPutImageOrg(DrawablePtr pDst, GCPtr pGC, int depth, int x, int y,
@ -61,69 +52,38 @@ rdpPutImageOrg(DrawablePtr pDst, GCPtr pGC, int depth, int x, int y,
GC_OP_EPILOGUE(pGC); GC_OP_EPILOGUE(pGC);
} }
/******************************************************************************/
void
rdpPutImagePost(rdpPtr dev, rdpClientCon *clientCon,
int cd, RegionPtr clip_reg,
DrawablePtr pDst, GCPtr pGC, int depth, int x, int y,
int w, int h, int leftPad, int format, char *pBits)
{
BoxRec box;
RegionRec reg;
if (cd == XRDP_CD_NODRAW)
{
return;
}
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDst))
{
return;
}
box.x1 = x + pDst->x;
box.y1 = y + pDst->y;
box.x2 = box.x1 + w;
box.y2 = box.y1 + h;
rdpRegionInit(&reg, &box, 0);
if (cd == XRDP_CD_CLIP)
{
rdpRegionIntersect(&reg, clip_reg, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpPutImage(DrawablePtr pDst, GCPtr pGC, int depth, int x, int y, rdpPutImage(DrawablePtr pDst, GCPtr pGC, int depth, int x, int y,
int w, int h, int leftPad, int format, char *pBits) int w, int h, int leftPad, int format, char *pBits)
{ {
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
RegionRec clip_reg; RegionRec clip_reg;
RegionRec reg;
int cd; int cd;
BoxRec box;
LLOGLN(10, ("rdpPutImage:")); LLOGLN(10, ("rdpPutImage:"));
dev = rdpGetDevFromScreen(pGC->pScreen); dev = rdpGetDevFromScreen(pGC->pScreen);
dev->counts.rdpPutImageCallCount++; dev->counts.rdpPutImageCallCount++;
box.x1 = x + pDst->x;
box.y1 = y + pDst->y;
box.x2 = box.x1 + w;
box.y2 = box.y1 + h;
rdpRegionInit(&reg, &box, 0);
rdpRegionInit(&clip_reg, NullBox, 0); rdpRegionInit(&clip_reg, NullBox, 0);
cd = rdpDrawGetClip(dev, &clip_reg, pDst, pGC); cd = rdpDrawGetClip(dev, &clip_reg, pDst, pGC);
LLOGLN(10, ("rdpPutImage: cd %d", cd)); LLOGLN(10, ("rdpPutImage: cd %d", cd));
clientCon = dev->clientConHead; if (cd == XRDP_CD_CLIP)
while (clientCon != NULL)
{ {
rdpPutImagePre(dev, clientCon, cd, &clip_reg, pDst, pGC, depth, x, y, rdpRegionIntersect(&reg, &clip_reg, &reg);
w, h, leftPad, format, pBits);
clientCon = clientCon->next;
} }
/* do original call */ /* do original call */
rdpPutImageOrg(pDst, pGC, depth, x, y, w, h, leftPad, format, pBits); rdpPutImageOrg(pDst, pGC, depth, x, y, w, h, leftPad, format, pBits);
clientCon = dev->clientConHead; if (cd != XRDP_CD_NODRAW)
while (clientCon != NULL)
{ {
rdpPutImagePost(dev, clientCon, cd, &clip_reg, pDst, pGC, depth, x, y, rdpClientConAddAllReg(dev, &reg, pDst);
w, h, leftPad, format, pBits);
clientCon = clientCon->next;
} }
rdpRegionUninit(&clip_reg); rdpRegionUninit(&clip_reg);
rdpRegionUninit(&reg);
} }

56
xorg/server/module/rdpTrapezoids.c
Unescape View File

@ -44,15 +44,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define LLOGLN(_level, _args) \ #define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0) do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
/******************************************************************************/
static void
rdpTrapezoidsPre(rdpPtr dev, rdpClientCon *clientCon, PictureScreenPtr ps,
CARD8 op, PicturePtr pSrc, PicturePtr pDst,
PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
int ntrap, xTrapezoid *traps, BoxPtr box)
{
}
/******************************************************************************/ /******************************************************************************/
static void static void
rdpTrapezoidsOrg(PictureScreenPtr ps, rdpPtr dev, rdpTrapezoidsOrg(PictureScreenPtr ps, rdpPtr dev,
@ -65,28 +56,6 @@ rdpTrapezoidsOrg(PictureScreenPtr ps, rdpPtr dev,
ps->Trapezoids = rdpTrapezoids; ps->Trapezoids = rdpTrapezoids;
} }
/******************************************************************************/
static void
rdpTrapezoidsPost(rdpPtr dev, rdpClientCon *clientCon, PictureScreenPtr ps,
CARD8 op, PicturePtr pSrc, PicturePtr pDst,
PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
int ntrap, xTrapezoid *traps, BoxPtr box)
{
RegionRec reg;
if (!XRDP_DRAWABLE_IS_VISIBLE(dev, pDst->pDrawable))
{
return;
}
rdpRegionInit(&reg, box, 0);
if (pDst->pCompositeClip != 0)
{
rdpRegionIntersect(&reg, pDst->pCompositeClip, &reg);
}
rdpClientConAddDirtyScreenReg(dev, clientCon, &reg);
rdpRegionUninit(&reg);
}
/******************************************************************************/ /******************************************************************************/
void void
rdpTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst, rdpTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
@ -95,41 +64,24 @@ rdpTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
{ {
ScreenPtr pScreen; ScreenPtr pScreen;
rdpPtr dev; rdpPtr dev;
rdpClientCon *clientCon;
PictureScreenPtr ps; PictureScreenPtr ps;
BoxRec box; BoxRec box;
int dstx; RegionRec reg;
int dsty;
LLOGLN(10, ("rdpTrapezoids:")); LLOGLN(10, ("rdpTrapezoids:"));
pScreen = pDst->pDrawable->pScreen; pScreen = pDst->pDrawable->pScreen;
dev = rdpGetDevFromScreen(pScreen); dev = rdpGetDevFromScreen(pScreen);
dev->counts.rdpTrapezoidsCallCount++; dev->counts.rdpTrapezoidsCallCount++;
dstx = traps[0].left.p1.x >> 16;
dsty = traps[0].left.p1.y >> 16;
miTrapezoidBounds(ntrap, traps, &box); miTrapezoidBounds(ntrap, traps, &box);
box.x1 += pDst->pDrawable->x; box.x1 += pDst->pDrawable->x;
box.y1 += pDst->pDrawable->y; box.y1 += pDst->pDrawable->y;
box.x2 += pDst->pDrawable->x; box.x2 += pDst->pDrawable->x;
box.y2 += pDst->pDrawable->y; box.y2 += pDst->pDrawable->y;
LLOGLN(10, ("%d %d %d %d %d %d", dstx, dsty, box.x1, box.y1, rdpRegionInit(&reg, &box, 0);
box.x2, box.y2));
ps = GetPictureScreen(pScreen); ps = GetPictureScreen(pScreen);
clientCon = dev->clientConHead;
while (clientCon != NULL)
{
rdpTrapezoidsPre(dev, clientCon, ps, op, pSrc, pDst,
maskFormat, xSrc, ySrc, ntrap, traps, &box);
clientCon = clientCon->next;
}
/* do original call */ /* do original call */
rdpTrapezoidsOrg(ps, dev, op, pSrc, pDst, maskFormat, xSrc, ySrc, rdpTrapezoidsOrg(ps, dev, op, pSrc, pDst, maskFormat, xSrc, ySrc,
ntrap, traps); ntrap, traps);
clientCon = dev->clientConHead; rdpClientConAddAllReg(dev, &reg, pDst->pDrawable);
while (clientCon != NULL) rdpRegionUninit(&reg);
{
rdpTrapezoidsPost(dev, clientCon, ps, op, pSrc, pDst,
maskFormat, xSrc, ySrc, ntrap, traps, &box);
clientCon = clientCon->next;
}
} }

2
xorg/server/xrdpdev/xrdpdev.c
Unescape View File

@ -532,7 +532,7 @@ rdpScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
/* glyphs */ /* glyphs */
dev->Glyphs = ps->Glyphs; dev->Glyphs = ps->Glyphs;
ps->Glyphs = rdpGlyphs; ps->Glyphs = rdpGlyphs;
/* trapezoids */
dev->Trapezoids = ps->Trapezoids; dev->Trapezoids = ps->Trapezoids;
ps->Trapezoids = rdpTrapezoids; ps->Trapezoids = rdpTrapezoids;
} }

Write Preview
Loading…
Cancel
Save