![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to text.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libsun|
Return to text.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libsun |
1.1 ! root 1: /* ! 2: * text.c ! 3: * ! 4: * Copyright (c) 1985 Massachusetts Institue of Technology ! 5: * Copyright (c) 1986 Sun Microsystems, Inc. ! 6: * Copyright (c) 1986 David C. Martin, UC Berkeley ! 7: * ! 8: * David C. Martin ! 9: * ARPA: [email protected] ! 10: * UUCP: ..!ucbvax!dcmartin ! 11: * ! 12: * $Log: text.c,v $ ! 13: * Revision 10.5 86/11/29 13:48:49 jg ! 14: * fixes from Berkeley ! 15: * ! 16: * Revision 1.10 86/07/27 13:49:58 dcmartin ! 17: * removed debugging statements ! 18: * ! 19: * Revision 1.9 86/07/25 14:45:48 dcmartin ! 20: * modified PrintTextMask() to handle variable width fonts ! 21: * ! 22: * Revision 1.8 86/07/17 10:37:29 dcmartin ! 23: * release version w/ support for variable width text ! 24: * ! 25: * Revision 1.7 86/07/17 10:32:19 dcmartin ! 26: * ! 27: */ ! 28: ! 29: #ifndef lint ! 30: static char rcs_id[] = "$Header: text.c,v 10.5 86/11/29 13:48:49 jg Rel $"; ! 31: #endif lint ! 32: ! 33: #include <X/mit-copyright.h> ! 34: ! 35: /* ! 36: * The Sun X drivers are a product of Sun Microsystems, Inc. and are provided ! 37: * for unrestricted use provided that this legend is included on all tape ! 38: * media and as a part of the software program in whole or part. Users ! 39: * may copy or modify these drivers without charge, but are not authorized ! 40: * to license or distribute them to anyone else except as part of a product or ! 41: * program developed by the user. ! 42: * ! 43: * THE SUN X DRIVERS ARE PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND ! 44: * INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A ! 45: * PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE ! 46: * PRACTICE. ! 47: * ! 48: * The Sun X Drivers are provided with no support and without any obligation ! 49: * on the part of Sun Microsystems, Inc. to assist in their use, correction, ! 50: * modification or enhancement. ! 51: * ! 52: * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE ! 53: * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THE SUN X ! 54: * DRIVERS OR ANY PART THEREOF. ! 55: * ! 56: * In no event will Sun Microsystems, Inc. be liable for any lost revenue ! 57: * or profits or other special, indirect and consequential damages, even if ! 58: * Sun has been advised of the possibility of such damages. ! 59: * ! 60: * Sun Microsystems, Inc. ! 61: * 2550 Garcia Avenue ! 62: * Mountain View, California 94043 ! 63: */ ! 64: ! 65: #ifdef sun ! 66: ! 67: /* ! 68: * ToDo: ! 69: * Color ! 70: */ ! 71: ! 72: #include "Xsun.h" ! 73: #ifndef stdin ! 74: #include <stdio.h> ! 75: #endif ! 76: #include <pixrect/memreg.h> ! 77: #include <pixrect/cg2reg.h> ! 78: ! 79: /* I've put in some rather ugly hacks, in the name of performance. The ! 80: global variables private_* are really extra parameters to the batchrop ! 81: routines. I did this, rather than adding parameters, because I wanted to ! 82: do the least violence to the "official" specs of batchrop -- this way X ! 83: will vaguely work on displays that don't use one of the tuned batchrops. ! 84: JAG */ ! 85: ! 86: int private_fgcolor, private_bgcolor, private_czmask; ! 87: ! 88: extern struct pixrect *PixRect; ! 89: ! 90: #define MAXCHARS 400 ! 91: ! 92: extern int ! 93: PrintText(text, textlen, font, fore, back, charpad, spacepad, dstx, dsty, ! 94: clips, clipcount, func, zmask) ! 95: register unsigned char *text; ! 96: FONT *font; ! 97: int textlen, fore, back, charpad, spacepad, dstx, dsty; ! 98: CLIP *clips; ! 99: int clipcount, zmask; ! 100: int func; ! 101: { ! 102: extern CURSOR *CurrentCursor; ! 103: extern CursorDisplayed; ! 104: int cleft, ctop, cwidth, cheight; ! 105: int op; ! 106: extern char FBMap[]; ! 107: unsigned char *limit = text + ! 108: (textlen < MAXCHARS ? textlen : MAXCHARS); ! 109: register int w = 0; ! 110: int bsize = 0; ! 111: int lheight; ! 112: int sbot, sright; ! 113: static struct pr_prpos bat[MAXCHARS]; ! 114: ! 115: private_czmask = zmask; ! 116: private_fgcolor = fore; ! 117: private_bgcolor = back; ! 118: if (fore & 1) ! 119: func += 0x20; ! 120: if (back & 1) ! 121: func += 0x10; ! 122: func = FBMap[func]; ! 123: op = SUN_FROM_X_OP(func) | PIX_COLOR(fore); ! 124: /* this is a gross abuse of C, but ... */ ! 125: { ! 126: register struct pixfont *pf; ! 127: register struct pr_prpos *p; ! 128: register struct pixchar *pc; ! 129: register int pwidth = 0; ! 130: ! 131: pf = (struct pixfont *) font->data; ! 132: p = bat; ! 133: lheight = pf->pf_defaultsize.y; ! 134: if (charpad == 0 && spacepad == 0) { ! 135: /* for each character in the text */ ! 136: while (text < limit) { ! 137: pc = &(pf->pf_char[*text++]); ! 138: if (pc == 0 || pc->pc_pr == NULL) ! 139: continue; ! 140: p->pr = pc->pc_pr; ! 141: /* ! 142: * pr_batchrop() is confusing... ! 143: * you must give the offset for the previous ! 144: * pixrect ! 145: */ ! 146: p->pos.x = pwidth; ! 147: /* store the character width */ ! 148: pwidth = pc->pc_adv.x; ! 149: /* increment the total width */ ! 150: w += pwidth; ! 151: p++; ! 152: bsize++; ! 153: } ! 154: } else { ! 155: /* for efficiency ... */ ! 156: struct pixchar *space = &(pf->pf_char[font->space]); ! 157: ! 158: while (text < limit) { ! 159: pc = &(pf->pf_char[*text++]); ! 160: if (pc == (struct pixchar *) NULL || ! 161: pc->pc_pr == (struct pixrect *) NULL) ! 162: continue; ! 163: p->pr = pc->pc_pr; ! 164: /* ! 165: * pr_batchrop() is confusing... ! 166: * you must give the offset for the previous ! 167: * pixrect ! 168: */ ! 169: p->pos.x = pwidth; ! 170: /* store the character width */ ! 171: pwidth = pc->pc_adv.x + charpad; ! 172: /* add space? */ ! 173: if (pc == space) ! 174: pwidth += spacepad; ! 175: /* increment the total width */ ! 176: w += pwidth; ! 177: p++; ! 178: bsize++; ! 179: } ! 180: } ! 181: } /* end gross abuse */ ! 182: /* determine the right and bottom of the region */ ! 183: sbot = dsty + lheight; ! 184: sright = dstx + w; ! 185: /* if the cursor is where we want to put text get rid of it */ ! 186: if (CursorDisplayed) { ! 187: extern DEVICE *CurrentDevice; ! 188: register vsCursor *ms = CurrentDevice->mouse; ! 189: register CURSOR *cs = CurrentCursor; ! 190: ! 191: if (ms->y < sbot && ! 192: ms->x < sright && ! 193: ms->y + cs->height > dsty && ! 194: ms->x + cs->width > dstx) ! 195: DisplayCursor(NULL); ! 196: } ! 197: do { ! 198: GetNextClip(clips, cleft, ctop, cwidth, cheight); ! 199: if (dsty >= ctop && ! 200: sbot <= ctop + cheight && ! 201: dstx >= cleft && ! 202: sright <= cleft + cwidth) { ! 203: pr_batchrop(PixRect, dstx - bat[0].pos.x, dsty, ! 204: op | PIX_DONTCLIP, bat, bsize); ! 205: } else { ! 206: struct pixrect *region; ! 207: ! 208: if (dsty > ctop + cheight) ! 209: continue; ! 210: if (dsty + lheight <= ctop) ! 211: continue; ! 212: region = pr_region(PixRect, cleft, ctop, cwidth, ! 213: cheight); ! 214: pr_batchrop(region, dstx - cleft - bat[0].pos.x, ! 215: dsty - ctop, op, bat, bsize); ! 216: pr_destroy(region); ! 217: } ! 218: } while (--clipcount > 0); ! 219: /* redisplay the cursor if we zapped it */ ! 220: if (!CursorDisplayed) ! 221: DisplayCursor(CurrentCursor); ! 222: } /* end PrintText() */ ! 223: ! 224: extern int ! 225: PrintTextMask(text, textlen, font, srcpix, charpad, spacepad, dstx, dsty, ! 226: clips, clipcount, func, zmask) ! 227: unsigned char *text; ! 228: FONT *font; ! 229: int textlen, srcpix, charpad, spacepad, dstx, dsty; ! 230: CLIP *clips; ! 231: int clipcount, zmask; ! 232: register int func; ! 233: { ! 234: extern CURSOR *CurrentCursor; ! 235: extern CursorDisplayed; ! 236: int cleft, ctop, cwidth, cheight; ! 237: int op; ! 238: extern char SSMap[]; ! 239: unsigned char *limit = text + ! 240: (textlen < MAXCHARS ? textlen : MAXCHARS); ! 241: register int w = 0; ! 242: static struct pr_prpos bat[MAXCHARS]; ! 243: int bsize = 0, lheight, sbot, sright; ! 244: ! 245: SetZmask(PixRect, &zmask); ! 246: private_bgcolor = -1; ! 247: private_fgcolor = srcpix; ! 248: if (PixRect->pr_depth == 1) { ! 249: if ((srcpix & 1) == 0) ! 250: func += 0x10; ! 251: op = SUN_FROM_X_OP(SSMap[func]) & ! 252: PIX_SRC | PIX_NOT(PIX_SRC) & PIX_DST; ! 253: } else ! 254: op = SUN_FROM_X_OP(func); ! 255: if (PixRect->pr_depth > 1) ! 256: op |= PIX_COLOR(srcpix); ! 257: /* this is a gross abuse of C, but ... */ ! 258: { ! 259: register struct pixfont *pf; ! 260: register struct pr_prpos *p; ! 261: register struct pixchar *pc; ! 262: register int pwidth = 0; ! 263: ! 264: pf = (struct pixfont *) font->data; ! 265: p = bat; ! 266: lheight = pf->pf_defaultsize.y; ! 267: if (charpad == 0 && spacepad == 0) { ! 268: /* for each character in the text */ ! 269: while (text < limit) { ! 270: pc = &(pf->pf_char[*text++]); ! 271: if (pc == 0 || pc->pc_pr == NULL) ! 272: continue; ! 273: p->pr = pc->pc_pr; ! 274: /* ! 275: * pr_batchrop() is confusing... ! 276: * you must give the offset for the previous ! 277: * pixrect ! 278: */ ! 279: p->pos.x = pwidth; ! 280: /* store the character width */ ! 281: pwidth = pc->pc_adv.x; ! 282: /* increment the total width */ ! 283: w += pwidth; ! 284: p++; ! 285: bsize++; ! 286: } ! 287: } else { ! 288: /* for efficiency ... */ ! 289: struct pixchar *space = &(pf->pf_char[font->space]); ! 290: ! 291: while (text < limit) { ! 292: pc = &(pf->pf_char[*text++]); ! 293: if (pc == 0 || pc->pc_pr == NULL) ! 294: continue; ! 295: p->pr = pc->pc_pr; ! 296: /* ! 297: * pr_batchrop() is confusing... ! 298: * you must give the offset for the previous ! 299: * pixrect ! 300: */ ! 301: p->pos.x = pwidth; ! 302: /* store the character width */ ! 303: pwidth = pc->pc_adv.x + charpad; ! 304: /* add space? */ ! 305: if (pc == space) ! 306: pwidth += spacepad; ! 307: /* increment the total width */ ! 308: w += pwidth; ! 309: p++; ! 310: bsize++; ! 311: } ! 312: } ! 313: } /* end gross abuse */ ! 314: /* determine right/bottom corner */ ! 315: sbot = dsty + lheight; ! 316: sright = dstx + w; ! 317: /* if the cursor is display where we wish to output -- zap it */ ! 318: if (CursorDisplayed) { ! 319: extern DEVICE *CurrentDevice; ! 320: register vsCursor *ms = CurrentDevice->mouse; ! 321: register CURSOR *cs = CurrentCursor; ! 322: ! 323: if (ms->y < sbot && ! 324: ms->x < sright && ! 325: ms->y + cs->height > dsty && ! 326: ms->x + cs->width > dstx) ! 327: DisplayCursor(NULL); ! 328: } ! 329: do { ! 330: GetNextClip(clips, cleft, ctop, cwidth, cheight); ! 331: if (dsty >= ctop && ! 332: sbot <= ctop + cheight && ! 333: dstx >= cleft && ! 334: sright <= cleft + cwidth) ! 335: pr_batchrop(PixRect, dstx - bat[0].pos.x, dsty, ! 336: op | PIX_DONTCLIP, bat, bsize); ! 337: else { ! 338: struct pixrect *region; ! 339: if (dsty > ctop + cheight) ! 340: continue; ! 341: if (dsty + lheight <= ctop) ! 342: continue; ! 343: region = pr_region(PixRect, cleft, ctop, cwidth, ! 344: cheight); ! 345: pr_batchrop(region, dstx - cleft - bat[0].pos.x, ! 346: dsty - ctop, op, bat, bsize); ! 347: pr_destroy(region); ! 348: } ! 349: } while (--clipcount > 0); ! 350: /* restore cursor if we zapped it */ ! 351: if (!CursorDisplayed) ! 352: DisplayCursor(CurrentCursor); ! 353: /* another gross abuse of C... */ ! 354: { ! 355: static allmask = -1; ! 356: ! 357: SetZmask(PixRect, &allmask); ! 358: } ! 359: } /* end PrintTextMask() */ ! 360: ! 361: ! 362: /* ! 363: * Copyright (c) 1983 by Sun Microsystems, Inc. ! 364: */ ! 365: ! 366: /* ! 367: * Memory batchrop ! 368: */ ! 369: ! 370: ! 371: extern char pr_reversedst[]; ! 372: extern struct pixrectops mem_ops; ! 373: ! 374: ! 375: ! 376: #define MEMBATCH(IfClip, IfMask, op, IfReverse) \ ! 377: for (; --count >= 0; src++) { \ ! 378: dst.pos.x += src->pos.x; \ ! 379: dp = dp0 + (((dskew = xoff0 + dst.pos.x) >> 3) & ~1); \ ! 380: dskew &= 0xF; \ ! 381: spr = src->pr; \ ! 382: sizex = spr->pr_size.x; \ ! 383: sizey = spr->pr_size.y; \ ! 384: sprd = mpr_d(spr); \ ! 385: if (sprd->md_linebytes != 2) \ ! 386: goto hard; \ ! 387: sp = (u_short *) sprd->md_image; \ ! 388: IfClip( if (dst.pos.x + sizex > limx) \ ! 389: goto hard; \ ! 390: if (dst.pos.y + sizey > limy) \ ! 391: sizey = limy - dst.pos.y; \ ! 392: if (dst.pos.x < 0) \ ! 393: goto hard; \ ! 394: if (dst.pos.y < 0) { \ ! 395: sizey += dst.pos.y; \ ! 396: sp -= dst.pos.y; \ ! 397: dp -= pr_product(dst.pos.y, vert); \ ! 398: } \ ! 399: if (sizex <= 0) \ ! 400: continue; \ ! 401: ,) \ ! 402: if (--sizey>=0) \ ! 403: if (dskew + sizex <= 16) { \ ! 404: IfMask( register short mask; \ ! 405: mask = 0x8000; \ ! 406: sizex -= 1; \ ! 407: mask >>= sizex; \ ! 408: ((unsigned short) mask) >>= dskew; \ ! 409: IfReverse(mask = ~mask;,),) \ ! 410: do { \ ! 411: IfMask(*(u_short *) dp IfReverse(&,|)= mask;,) \ ! 412: *(u_short *) dp op (*sp++ >> dskew); \ ! 413: dp += vert; \ ! 414: } while (--sizey != -1); \ ! 415: } \ ! 416: else { \ ! 417: IfMask( register long mask; \ ! 418: mask = 0x80000000; \ ! 419: sizex -= 1; \ ! 420: mask >>= sizex; \ ! 421: ((unsigned long) mask) >>= dskew; \ ! 422: IfReverse(mask = ~mask;,),) \ ! 423: dskew = 16 - dskew; \ ! 424: do { \ ! 425: IfMask(*(u_int *) dp IfReverse(&,|)= mask;,) \ ! 426: *(u_int *) dp op (*sp++ << dskew); \ ! 427: dp += vert; \ ! 428: } while (--sizey != -1); \ ! 429: } \ ! 430: } ! 431: ! 432: #define MTRUE(a,b) a ! 433: #define MFALSE(a,b) b ! 434: ! 435: #define ClippedOp(mask,op,revmask) \ ! 436: if(clip) MEMBATCH(MTRUE,mask,op,revmask) \ ! 437: else MEMBATCH(MFALSE,mask,op,revmask) ! 438: ! 439: mem_batchrop(dst, op, src, count) ! 440: struct pr_prpos dst; ! 441: int op; ! 442: struct pr_prpos *src; ! 443: short count; ! 444: { ! 445: register u_short *sp; ! 446: register char *dp; ! 447: char *dp0; ! 448: register char *handy; ! 449: register short sizex, sizey; ! 450: register vert, dskew; ! 451: int dskew0, xoff0; ! 452: int errors = 0; ! 453: int clip, limx, limy; ! 454: int oppassed = op; ! 455: ! 456: /* ! 457: * Preliminaries: get pixrect data and image pointers; decide whether ! 458: * clipping. If not clipping, normalize op, else compute limits for ! 459: * cursors for later comparisons. ! 460: */ ! 461: ! 462: clip = 0; ! 463: if (!(op & PIX_DONTCLIP)) { ! 464: clip = 1; ! 465: limx = dst.pr->pr_size.x; ! 466: limy = dst.pr->pr_size.y; ! 467: } ! 468: op = (op >> 1) & 0xf; /* Kill dontclip, just keep useful */ ! 469: /* ! 470: * If destination is reverse video, invert function. FIXME: we dont ! 471: * deal with a reverse video source. Admittedly its unlikely that ! 472: * anyone will call batchrop with a device pixrect as source (since we ! 473: * copy the whole pixrect), but this is a bug. ! 474: */ ! 475: if (mpr_d(dst.pr)->md_flags & MP_REVERSEVIDEO) ! 476: op = pr_reversedst[op]; ! 477: ! 478: vert = mpr_d(dst.pr)->md_linebytes; ! 479: #define dprd ((struct mpr_data *)handy) ! 480: dprd = mpr_d(dst.pr); ! 481: xoff0 = dprd->md_offset.x; ! 482: dp0 = (char *) ((int) dprd->md_image ! 483: + pr_product(dprd->md_linebytes, ! 484: dst.pos.y + dprd->md_offset.y)); ! 485: #undef dprd ! 486: restart: ! 487: #define spr ((struct pixrect *)handy) ! 488: #define sprd ((struct mpr_data *)handy) ! 489: switch (op) { ! 490: case (PIX_SRC ^ PIX_DST) >> 1: ! 491: ClippedOp(MFALSE, ^=, MTRUE); ! 492: break; ! 493: case PIX_SRC >> 1: ! 494: ClippedOp(MTRUE, |=, MTRUE); ! 495: break; ! 496: case PIX_NOT(PIX_SRC) >> 1: ! 497: ClippedOp(MTRUE, ^=, MFALSE); ! 498: break; ! 499: case (PIX_SRC | PIX_DST) >> 1: ! 500: ClippedOp(MFALSE, |=, MTRUE); ! 501: break; ! 502: case (PIX_NOT(PIX_SRC) & PIX_DST) >> 1: ! 503: ClippedOp(MFALSE, &=~, MTRUE); ! 504: break; ! 505: default: ! 506: for (; --count >= 0; src++) { ! 507: dst.pos.x += src->pos.x; ! 508: errors |= mem_rop(dst.pr, dst.pos, src->pr->pr_size, ! 509: oppassed, src->pr, 0, 0); ! 510: } ! 511: } ! 512: return errors; ! 513: hard: ! 514: if (dst.pos.x + sizex <= 0) ! 515: /* ! 516: * Completely clipped on left... ! 517: */ ! 518: ; ! 519: else { ! 520: errors |= mem_rop(dst.pr, dst.pos, src->pr->pr_size, ! 521: oppassed, src->pr, 0, 0); ! 522: } ! 523: src++; ! 524: goto restart; ! 525: } ! 526: ! 527: /* ! 528: * cg2batch.c: Sun2 Color batchrop ! 529: */ ! 530: ! 531: extern struct pixrectops mem_ops; ! 532: ! 533: ! 534: extern short mrc_lmasktable[]; ! 535: extern short mrc_rmasktable[]; ! 536: ! 537: #define resolution unused, 0 ! 538: ! 539: cg2_batchrop(dst, op, src, count) ! 540: struct pr_prpos dst; ! 541: int op; ! 542: struct pr_prpos *src; ! 543: register int count; ! 544: { ! 545: register short sizey; ! 546: register int tem, w, prime, linebytes; ! 547: register short *bx, *leftx, *ma; ! 548: register struct memropc *ropregs; ! 549: short sizex; ! 550: int clip; ! 551: struct pixrect *pr; ! 552: short *ma_homey; ! 553: short homex, homey, limx, limy, dstx, dsty, by; ! 554: ! 555: struct cg2fb *fb; ! 556: struct mpr_data *md; ! 557: int oppassed = op; ! 558: int errors = 0; ! 559: short color; ! 560: ! 561: if (count <= 0) ! 562: return (0); ! 563: ! 564: /* ! 565: * Preliminaries: get pixrect data and frame buffer pointers; decide ! 566: * whether clipping. If not clipping, normalize op, else compute ! 567: * limits for cursors for later comparisons. ! 568: */ ! 569: #define dbd ((struct cg2pr *)leftx) ! 570: dbd = cg2_d(dst.pr); ! 571: homex = dbd->cgpr_offset.x; ! 572: homey = dbd->cgpr_offset.y; ! 573: #define FB ((struct cg2fb *)leftx) ! 574: FB = dbd->cgpr_va; ! 575: fb = FB; ! 576: #undef dbd ! 577: ropregs = &FB->ropcontrol[CG2_ALLROP].ropregs; ! 578: if (op & PIX_DONTCLIP) { ! 579: op &= ~PIX_DONTCLIP; ! 580: clip = 0; ! 581: } ! 582: else { ! 583: clip = 1; ! 584: limx = homex + dst.pr->pr_size.x; ! 585: limy = homey + dst.pr->pr_size.y; ! 586: } ! 587: dstx = homex + dst.pos.x; ! 588: dsty = homey + dst.pos.y; ! 589: if (private_bgcolor < 0) { ! 590: FB->ppmask.reg = private_fgcolor; /* set colored text */ ! 591: ropregs->mrc_pattern = -1; ! 592: FB->ppmask.reg = ~private_fgcolor; ! 593: ropregs->mrc_pattern = 0; ! 594: FB->ppmask.reg = private_czmask; ! 595: switch (op & 0x1E) { ! 596: case PIX_SRC ^ PIX_DST: ! 597: ropregs->mrc_op = CG_SRC & (CG_MASK ^ CG_DEST) | ~CG_SRC & CG_DEST; ! 598: break; ! 599: case PIX_NOT(PIX_DST): ! 600: ropregs->mrc_op = CG_SRC & (~CG_DEST) | ~CG_SRC & CG_DEST; ! 601: break; ! 602: default: ! 603: ropregs->mrc_op = CG_SRC & CG_MASK | ~CG_SRC & CG_DEST; ! 604: break; ! 605: } ! 606: } ! 607: else { ! 608: FB->ppmask.reg = private_fgcolor & private_bgcolor; ! 609: ropregs->mrc_op = ~0; ! 610: FB->ppmask.reg = ~(private_fgcolor | private_bgcolor); ! 611: ropregs->mrc_op = 0; ! 612: FB->ppmask.reg = private_fgcolor & ~private_bgcolor; ! 613: ropregs->mrc_op = CG_SRC; ! 614: FB->ppmask.reg = ~private_fgcolor & private_bgcolor; ! 615: ropregs->mrc_op = ~CG_SRC; ! 616: FB->ppmask.reg = private_czmask; ! 617: } ! 618: FB->status.reg.ropmode = PWWWRD; ! 619: linebytes = cg2_linebytes(FB, PWWWRD); ! 620: #undef FB ! 621: ! 622: for (; --count >= 0; src++) { ! 623: /* ! 624: * Update destination x and y by pre-advance amount. If no pixrect ! 625: * for this, then skip to next. ! 626: */ ! 627: dstx += src->pos.x; ! 628: pr = src->pr; ! 629: if (pr == 0) ! 630: continue; ! 631: sizex = pr->pr_size.x; ! 632: sizey = pr->pr_size.y; ! 633: md = mpr_d(pr); ! 634: ma = md->md_image; ! 635: ! 636: /* ! 637: * Grab sizes and address of image. If clipping (rare case ! 638: * hopefully) compare cursors against limits. ! 639: */ ! 640: by = dsty; ! 641: tem = 0; ! 642: if (clip) { ! 643: if (dstx + sizex > limx) ! 644: sizex = limx - dstx; ! 645: if (dsty + sizey > limy) ! 646: sizey = limy - dsty; ! 647: if (dsty < homey) { /* works if pr_depth = 1! */ ! 648: tem = homey - dsty; ! 649: by += tem; ! 650: ma += pr_product(tem, (md->md_linebytes >> 1)); ! 651: sizey -= tem; ! 652: tem = 0; ! 653: } ! 654: if (dstx < homex) { ! 655: tem = homex - dstx; ! 656: ma += tem >> 4; ! 657: sizex -= tem; ! 658: } ! 659: if (sizex <= 0) ! 660: continue; ! 661: } ! 662: ! 663: /* ! 664: * Hard case: characters greater than 16 wide. ! 665: */ ! 666: ma_homey = ma; ! 667: ! 668: /* set the ROP chip word width and opcount */ ! 669: ! 670: w = cg2_prskew(dstx); /* source skew is 0 */ ! 671: ropregs->mrc_shift = (w & 0xF) | (1 << 8); ! 672: prime = !w; ! 673: w = (sizex + w + (tem & 0xF) - 1) >> 4; ! 674: ropregs->mrc_width = w; ! 675: ropregs->mrc_opcount = w; ! 676: ! 677: /* set the ROP chip end masks */ ! 678: ! 679: ropregs->mrc_mask1 = ! 680: mrc_lmasktable[(tem += dstx) & 0xf]; ! 681: ropregs->mrc_mask2 = ! 682: mrc_rmasktable[(sizex + tem - 1) & 0xf]; ! 683: ! 684: leftx = cg2_ropwordaddr(fb, 0, tem, by); ! 685: tem = md->md_linebytes; ! 686: if (--sizey >= 0) ! 687: if (w) { ! 688: w++; ! 689: do { ! 690: register short i = w; ! 691: ma = ma_homey; ! 692: bx = leftx; ! 693: if (prime) ! 694: ropregs->mrc_source1 = *ma++; ! 695: while (i--) ! 696: *bx++ = *ma++; ! 697: (char *) ma_homey += tem; ! 698: (char *) leftx += linebytes; ! 699: } while (--sizey != -1); ! 700: } ! 701: else { ! 702: bx = leftx; ! 703: ma = ma_homey; ! 704: if (prime) { ! 705: ma++; ! 706: do { ! 707: ma--; ! 708: ropregs->mrc_source1 = *ma++; ! 709: *bx = *ma; ! 710: (char *) ma += tem; ! 711: (char *) bx += linebytes; ! 712: } while (--sizey != -1); ! 713: } ! 714: else ! 715: do { ! 716: *bx = *ma; ! 717: (char *) ma += tem; ! 718: (char *) bx += linebytes; ! 719: } while (--sizey != -1); ! 720: } ! 721: } ! 722: ! 723: return (errors); ! 724: } ! 725: ! 726: #endif sun
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.