void LeoVtChange (ScreenPtr pScreen, int enter)
{
LeoPtr pLeo = LeoGetScreenPrivate (pScreen);
LeoCommand0 *lc0 = pLeo->lc0;
LeoDraw *ld0 = pLeo->ld0;
ld0->wid = 1;
ld0->widclip = 0;
ld0->wmask = 0xffff;
ld0->planemask = 0xffffff;
ld0->rop = LEO_ATTR_WE_ENABLE|LEO_ATTR_RGBE_ENABLE|LEO_ATTR_FORCE_WID;
ld0->fg = 0;
ld0->vclipmin = 0;
ld0->vclipmax = (pLeo->psdp->width - 1) | ((pLeo->psdp->height - 1) << 16);
while (lc0->csr & LEO_CSR_BLT_BUSY);
lc0->extent = (pLeo->psdp->width - 1) | ((pLeo->psdp->height - 1) << 11);
lc0->fill = 0;
while (lc0->csr & LEO_CSR_BLT_BUSY);
lc0->addrspace = LEO_ADDRSPC_OBGR;
ld0->rop = LEO_ATTR_RGBE_ENABLE|LEO_ROP_NEW;
}
void
LeoZeroPolyArcSS8General(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
{
LeoPtr pLeo = LeoGetScreenPrivate (pDrawable->pScreen);
LeoDraw *ld0 = pLeo->ld0;
if (pGC->alu != GXcopy)
ld0->rop = leoRopTable[pGC->alu];
if (pGC->planemask != 0xffffff)
ld0->planemask = pGC->planemask;
cfbZeroPolyArcSS8Copy(pDrawable, pGC, narcs, parcs);
if (pGC->alu != GXcopy)
ld0->rop = LEO_ATTR_RGBE_ENABLE|LEO_ROP_NEW;
if (pGC->planemask != 0xffffff)
ld0->planemask = 0xffffff;
}
void
LeoTile32FSGeneral(DrawablePtr pDrawable, GCPtr pGC, int nInit,
DDXPointPtr pptInit, int *pwidthInit, int fSorted)
{
LeoPtr pLeo = LeoGetScreenPrivate (pDrawable->pScreen);
LeoDraw *ld0 = pLeo->ld0;
if (pGC->alu != GXcopy)
ld0->rop = leoRopTable[pGC->alu];
if (pGC->planemask != 0xffffff)
ld0->planemask = pGC->planemask;
cfbTile32FSCopy(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted);
if (pGC->alu != GXcopy)
ld0->rop = LEO_ATTR_RGBE_ENABLE|LEO_ROP_NEW;
if (pGC->planemask != 0xffffff)
ld0->planemask = 0xffffff;
}
void
LeoFillPoly1RectGeneral(DrawablePtr pDrawable, GCPtr pGC, int shape,
int mode, int count, DDXPointPtr ptsIn)
{
LeoPtr pLeo = LeoGetScreenPrivate (pDrawable->pScreen);
LeoDraw *ld0 = pLeo->ld0;
if (pGC->alu != GXcopy)
ld0->rop = leoRopTable[pGC->alu];
if (pGC->planemask != 0xffffff)
ld0->planemask = pGC->planemask;
cfbFillPoly1RectCopy(pDrawable, pGC, shape, mode, count, ptsIn);
if (pGC->alu != GXcopy)
ld0->rop = LEO_ATTR_RGBE_ENABLE|LEO_ROP_NEW;
if (pGC->planemask != 0xffffff)
ld0->planemask = 0xffffff;
}
static void
LeoCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
LeoPtr pLeo = LeoGetScreenPrivate (pScreen);
DDXPointPtr pptSrc;
DDXPointPtr ppt;
RegionPtr prgnDst;
BoxPtr pbox;
int dx, dy;
int i, nbox;
WindowPtr pwinRoot;
if (pLeo->vtSema)
return;
dx = ptOldOrg.x - pWin->drawable.x;
dy = ptOldOrg.y - pWin->drawable.y;
pwinRoot = WindowTable[pWin->drawable.pScreen->myNum];
prgnDst = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);
REGION_INTERSECT(pWin->drawable.pScreen, prgnDst, &pWin->borderClip, prgnSrc);
pbox = REGION_RECTS(prgnDst);
nbox = REGION_NUM_RECTS(prgnDst);
if(!(pptSrc = (DDXPointPtr )ALLOCATE_LOCAL(nbox * sizeof(DDXPointRec))))
return;
ppt = pptSrc;
for (i = nbox; --i >= 0; ppt++, pbox++) {
ppt->x = pbox->x1 + dx;
ppt->y = pbox->y1 + dy;
}
LeoDoBitblt ((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
GXcopy, prgnDst, pptSrc, ~0L);
DEALLOCATE_LOCAL(pptSrc);
REGION_DESTROY(pWin->drawable.pScreen, prgnDst);
}
void
LeoPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill, xRectangle *prectInit)
{
LeoPtr pLeo = LeoGetScreenPrivate (pDrawable->pScreen);
LeoCommand0 *lc0 = pLeo->lc0;
LeoDraw *ld0 = pLeo->ld0;
xRectangle *prect;
RegionPtr prgnClip;
register BoxPtr pbox;
BoxPtr pextent;
int n;
int xorg, yorg;
/* No garbage please. */
if(nrectFill <= 0)
return;
prgnClip = cfbGetCompositeClip(pGC);
prect = prectInit;
xorg = pDrawable->x;
yorg = pDrawable->y;
if (xorg || yorg) {
prect = prectInit;
n = nrectFill;
while(n--) {
prect->x += xorg;
prect->y += yorg;
prect++;
}
}
prect = prectInit;
if (pGC->alu != GXcopy)
ld0->rop = leoRopTable[pGC->alu];
if (pGC->planemask != 0xffffff)
ld0->planemask = pGC->planemask;
ld0->fg = pGC->fgPixel;
if (REGION_NUM_RECTS(prgnClip) == 1) {
int x1, y1, x2, y2;
int x, y, xx, yy;
pextent = REGION_RECTS(prgnClip);
x1 = pextent->x1;
y1 = pextent->y1;
x2 = pextent->x2;
y2 = pextent->y2;
while (nrectFill--) {
x = prect->x;
y = prect->y;
xx = x + prect->width;
yy = y + prect->height;
if (x < x1)
x = x1;
if (y < y1)
y = y1;
prect++;
if (xx > x2) xx = x2;
if (yy > y2) yy = y2;
if (x >= xx) continue;
if (y >= yy) continue;
lc0->extent = (xx - x - 1) | ((yy - y - 1) << 11);
lc0->fill = x | (y << 11);
while (lc0->csr & LEO_CSR_BLT_BUSY);
}
} else {
int x1, y1, x2, y2, bx1, by1, bx2, by2;
int x, y, w, h;
pextent = REGION_EXTENTS(pGC->pScreen, prgnClip);
x1 = pextent->x1;
y1 = pextent->y1;
x2 = pextent->x2;
y2 = pextent->y2;
while (nrectFill--) {
if ((bx1 = prect->x) < x1)
bx1 = x1;
if ((by1 = prect->y) < y1)
by1 = y1;
bx2 = (int) prect->x + (int) prect->width;
if (bx2 > x2)
bx2 = x2;
by2 = (int) prect->y + (int) prect->height;
if (by2 > y2)
by2 = y2;
prect++;
if (bx1 >= bx2 || by1 >= by2)
continue;
n = REGION_NUM_RECTS (prgnClip);
pbox = REGION_RECTS(prgnClip);
/* clip the rectangle to each box in the clip region
this is logically equivalent to calling Intersect()
*/
while(n--) {
x = max(bx1, pbox->x1);
y = max(by1, pbox->y1);
w = min(bx2, pbox->x2) - x;
h = min(by2, pbox->y2) - y;
pbox++;
/* see if clipping left anything */
if (w > 0 && h > 0) {
lc0->extent = (w - 1) | ((h - 1) << 11);
lc0->fill = x | (y << 11);
while (lc0->csr & LEO_CSR_BLT_BUSY);
}
}
}
}
if (pGC->alu != GXcopy)
ld0->rop = LEO_ATTR_RGBE_ENABLE|LEO_ROP_NEW;
if (pGC->planemask != 0xffffff)
ld0->planemask = 0xffffff;
}
void
LeoPolyFillRect1Rect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill, xRectangle *prectInit)
{
LeoPtr pLeo = LeoGetScreenPrivate (pDrawable->pScreen);
LeoCommand0 *lc0 = pLeo->lc0;
LeoDraw *ld0 = pLeo->ld0;
xRectangle *prect;
RegionPtr prgnClip;
BoxPtr pextent;
int n;
int xorg, yorg;
int x1, y1, x2, y2;
int x, y, xx, yy;
/* No garbage please. */
if(nrectFill <= 0)
return;
prgnClip = cfbGetCompositeClip(pGC);
prect = prectInit;
xorg = pDrawable->x;
yorg = pDrawable->y;
if (xorg || yorg) {
prect = prectInit;
n = nrectFill;
while(n--) {
prect->x += xorg;
prect->y += yorg;
prect++;
}
}
prect = prectInit;
if (pGC->alu != GXcopy)
ld0->rop = leoRopTable[pGC->alu];
if (pGC->planemask != 0xffffff)
ld0->planemask = pGC->planemask;
ld0->fg = pGC->fgPixel;
pextent = REGION_RECTS(prgnClip);
x1 = pextent->x1;
y1 = pextent->y1;
x2 = pextent->x2;
y2 = pextent->y2;
while (nrectFill--) {
x = prect->x;
y = prect->y;
xx = x + prect->width;
yy = y + prect->height;
if (x < x1)
x = x1;
if (y < y1)
y = y1;
prect++;
if (xx > x2) xx = x2;
if (x >= xx) continue;
if (yy > y2) yy = y2;
if (y >= yy) continue;
lc0->extent = (xx - x - 1) | ((yy - y - 1) << 11);
lc0->fill = x | (y << 11);
while (lc0->csr & LEO_CSR_BLT_BUSY);
}
if (pGC->alu != GXcopy)
ld0->rop = LEO_ATTR_RGBE_ENABLE|LEO_ROP_NEW;
if (pGC->planemask != 0xffffff)
ld0->planemask = 0xffffff;
}
void
LeoFillSpansStippled (DrawablePtr pDrawable, GCPtr pGC,
int n, DDXPointPtr ppt,
int *pwidth, int fSorted)
{
LeoPrivGCPtr gcPriv = LeoGetGCPrivate (pGC);
LeoPtr pLeo = LeoGetScreenPrivate (pGC->pScreen);
LeoCommand0 *lc0 = pLeo->lc0;
LeoDraw *ld0 = pLeo->ld0;
int numRects, *pwidthFree;
DDXPointPtr pptFree;
RegionPtr clip;
unsigned char *fb;
unsigned int *bits, msk;
int cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0;
clip = cfbGetCompositeClip(pGC);
numRects = REGION_NUM_RECTS(clip);
if (!numRects)
return;
if (numRects == 1) {
cx1 = clip->extents.x1;
cx2 = clip->extents.x2;
cy1 = clip->extents.y1;
cy2 = clip->extents.y2;
} else {
int nTmp = n * miFindMaxBand(clip);
pwidthFree = (int *)ALLOCATE_LOCAL(nTmp * sizeof(int));
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(nTmp * sizeof(DDXPointRec));
if (!pptFree || !pwidthFree) {
if (pptFree) DEALLOCATE_LOCAL(pptFree);
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
return;
}
n = miClipSpans(clip,
ppt, pwidth, n,
pptFree, pwidthFree, fSorted);
pwidth = pwidthFree;
ppt = pptFree;
}
if (pGC->alu != GXcopy)
ld0->rop = leoRopTable[pGC->alu];
if (pGC->planemask != 0xffffff)
ld0->planemask = pGC->planemask;
ld0->fg = gcPriv->stipple->fg;
fb = (unsigned char *)pLeo->fb;
lc0->addrspace = LEO_ADDRSPC_FONT_OBGR;
if (gcPriv->stipple->alu & 0x80) {
lc0->fontt = 1;
} else {
lc0->fontt = 0;
ld0->bg = gcPriv->stipple->bg;
}
lc0->fontmsk = 0xffffffff;
msk = 0xffffffff;
bits = &gcPriv->stipple->bits[0];
while (n--) {
int x, y, w;
unsigned int *dst, s, i, sw, sm;
w = *pwidth++;
x = ppt->x;
y = ppt->y;
ppt++;
if (numRects == 1) {
if (y < cy1 || y >= cy2) continue;
if (x < cx1) {
w -= (cx1 - x);
if (w <= 0) continue;
x = cx1;
}
if (x + w > cx2) {
if (x >= cx2) continue;
w = cx2 - x;
}
}
s = bits[y & 31];
dst = (unsigned int *)(fb + (y << 13) + ((x & ~31) << 2));
if (x & 31) {
sw = 32 - (x & 31);
sm = 0xffffffff >> (x & 31);
w -= sw;
if (w <= 0) {
if (w) sm &= 0xffffffff << (32 - (w & 31));
if (msk != sm) {
msk = sm;
lc0->fontmsk = sm;
}
*dst = s;
continue;
}
if (msk != sm) {
msk = sm;
lc0->fontmsk = sm;
}
*dst = s;
dst += 32;
} else {
void
LeoPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC, int x, int y,
unsigned int nglyph, CharInfoPtr *ppci, pointer pGlyphBase)
{
LeoPtr pLeo = LeoGetScreenPrivate (pGC->pScreen);
LeoCommand0 *lc0 = pLeo->lc0;
LeoDraw *ld0 = pLeo->ld0;
RegionPtr clip;
CharInfoPtr pci;
int w, h, x0, y0, i;
unsigned int *bits;
BoxRec box;
int curw = -1;
unsigned int *fbf;
unsigned char *fb;
int height, width;
clip = cfbGetCompositeClip(pGC);
/* compute an approximate (but covering) bounding box */
box.x1 = 0;
if (ppci[0]->metrics.leftSideBearing < 0)
box.x1 = ppci[0]->metrics.leftSideBearing;
h = nglyph - 1;
w = ppci[h]->metrics.rightSideBearing;
while (--h >= 0)
w += ppci[h]->metrics.characterWidth;
box.x2 = w;
box.y1 = -FONTMAXBOUNDS(pGC->font,ascent);
box.y2 = FONTMAXBOUNDS(pGC->font,descent);
box.x1 += pDrawable->x + x;
box.x2 += pDrawable->x + x;
box.y1 += pDrawable->y + y;
box.y2 += pDrawable->y + y;
switch (RECT_IN_REGION(pGC->pScreen, clip, &box)) {
case rgnPART:
if (REGION_NUM_RECTS(clip) == 1) {
ld0->vclipmin = (clip->extents.y1 << 16) | clip->extents.x1;
ld0->vclipmax = ((clip->extents.y2 - 1) << 16) | (clip->extents.x2 - 1);
break;
}
cfbPolyGlyphBlt8 (pDrawable, pGC, x, y, nglyph, ppci, pGlyphBase);
case rgnOUT:
return;
default:
clip = NULL;
break;
}
x += pDrawable->x;
y += pDrawable->y;
lc0->fontt = 1;
lc0->addrspace = LEO_ADDRSPC_FONT_OBGR;
ld0->fg = pGC->fgPixel;
if (pGC->alu != GXcopy)
ld0->rop = leoRopTable[pGC->alu];
if (pGC->planemask != 0xffffff)
ld0->planemask = pGC->planemask;
height = pLeo->height;
width = pLeo->width;
fb = (unsigned char *)pLeo->fb;
while (nglyph--) {
pci = *ppci++;
w = GLYPHWIDTHPIXELS (pci);
h = GLYPHHEIGHTPIXELS (pci);
if (!w || !h)
goto next_glyph;
x0 = x + pci->metrics.leftSideBearing;
y0 = y - pci->metrics.ascent;
/* We're off the screen to the left, making our way
* back onto the screen.
*/
if((x0 >> 31) == -1)
goto next_glyph;
/* We walked off the screen (to the right or downwards)
* or we started there, we're never going to work our
* way back so stop now.
*/
if(x0 >= width || y0 >= height)
break;
bits = (unsigned int *) pci->bits;
if (w != curw) {
curw = w;
if (w)
lc0->fontmsk = 0xffffffff << (32 - w);
else
lc0->fontmsk = 0;
}
fbf = (unsigned *)(fb + (y0 << 13) + (x0 << 2));
if (y0 + h <= height)
for (i = 0; i < h; i++) {
*fbf = *bits++;
fbf += 2048;
}
else
for (i = 0; i < h && y0 + i < height; i++) {
*fbf = *bits++;
fbf += 2048;
}
next_glyph:
x += pci->metrics.characterWidth;
}
lc0->addrspace = LEO_ADDRSPC_OBGR;
if (pGC->alu != GXcopy)
ld0->rop = LEO_ATTR_RGBE_ENABLE|LEO_ROP_NEW;
if (pGC->planemask != 0xffffff)
ld0->planemask = 0xffffff;
if (clip) {
ld0->vclipmin = 0;
ld0->vclipmax = pLeo->vclipmax;
}
}
void
LeoTEGlyphBlt (DrawablePtr pDrawable, GCPtr pGC, int x, int y,
unsigned int nglyph, CharInfoPtr *ppci, pointer pGlyphBase)
{
LeoPtr pLeo = LeoGetScreenPrivate (pGC->pScreen);
LeoCommand0 *lc0 = pLeo->lc0;
LeoDraw *ld0 = pLeo->ld0;
RegionPtr clip;
int h, hTmp;
int widthGlyph, widthGlyphs;
BoxRec bbox;
FontPtr pfont = pGC->font;
int curw = -1;
unsigned int *fbf;
unsigned char *fb;
int height, width;
widthGlyph = FONTMAXBOUNDS(pfont,characterWidth);
h = FONTASCENT(pfont) + FONTDESCENT(pfont);
clip = cfbGetCompositeClip(pGC);
bbox.x1 = x + pDrawable->x;
bbox.x2 = bbox.x1 + (widthGlyph * nglyph);
bbox.y1 = y + pDrawable->y - FONTASCENT(pfont);
bbox.y2 = bbox.y1 + h;
/* If fully out of range, and we have no chance of getting back
* in range, no work to do.
*/
y = y + pDrawable->y - FONTASCENT(pfont);
x += pDrawable->x;
height = pLeo->height;
width = pLeo->width;
if (x >= width)
return;
switch (RECT_IN_REGION(pGC->pScreen, clip, &bbox)) {
case rgnPART:
if (REGION_NUM_RECTS(clip) == 1) {
ld0->vclipmin = (clip->extents.y1 << 16) | clip->extents.x1;
ld0->vclipmax = ((clip->extents.y2 - 1) << 16) | (clip->extents.x2 - 1);
break;
}
x -= pDrawable->x;
y = y - pDrawable->y + FONTASCENT(pfont);
if (pGlyphBase)
cfbPolyGlyphBlt8 (pDrawable, pGC, x, y, nglyph, ppci, NULL);
else
miImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pGlyphBase);
case rgnOUT:
return;
default:
clip = NULL;
break;
}
lc0->addrspace = LEO_ADDRSPC_FONT_OBGR;
ld0->fg = pGC->fgPixel;
if (pGC->alu != GXcopy)
ld0->rop = leoRopTable[pGC->alu];
if (pGC->planemask != 0xffffff)
ld0->planemask = pGC->planemask;
fb = (unsigned char *)pLeo->fb;
if(pGlyphBase)
lc0->fontt = 1;
else {
lc0->fontt = 0;
ld0->bg = pGC->bgPixel;
}
#define LoopIt(count, w, loadup, fetch) \
if (w != curw) { \
curw = w; \
lc0->fontmsk = 0xffffffff << (32 - w); \
} \
while (nglyph >= count) { \
loadup \
nglyph -= count; \
fbf = (unsigned *)(fb + (y << 13) + (x << 2)); \
hTmp = h; \
if (y + h <= height) \
while (hTmp--) { \
*fbf = fetch; \
fbf += 2048; \
} \
else \
for (hTmp = 0; hTmp < h && y + hTmp < height; hTmp++) { \
*fbf = fetch; \
fbf += 2048; \
} \
x += w; \
if(x >= width) \
goto out; \
}
if (widthGlyph <= 8) {
widthGlyphs = widthGlyph << 2;
LoopIt(4, widthGlyphs,
unsigned int *char1 = (unsigned int *) (*ppci++)->bits;
unsigned int *char2 = (unsigned int *) (*ppci++)->bits;
unsigned int *char3 = (unsigned int *) (*ppci++)->bits;
unsigned int *char4 = (unsigned int *) (*ppci++)->bits;,
