![[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 / libibm / libsrc|
Return to text.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / libsrc |
1.1 root 1: #ifndef lint
2: static char *rcsid_text_c = "$Header: text.c,v 10.1 86/11/19 10:44:22 jg Exp $";
3: #endif lint
4: /* Copyright 1985 Massachusetts Institute of Technology */
5:
6: /* text.c - X text based functions
7: *
8: * PrintText Prints text with source font
9: * PrintTextMask Prints text with mask font
10: * CopyText Copy text to bitmap
11: * TextWidth Returns width of a piece of text in a font
12: * CharWidth Returns width of a character in a font
13: * OffScreenText Utility rtn to optimize text blts using
14: * an offscreen buffer
15: * CopyScreenBits Utility rtn used to grab a rectangular area
16: * of the screen and place it in an offscreen buffer.
17: *
18: * Authors:
19: * Dan Stone & Scott Bates
20: * Brown University
21: * IRIS, Box 1946
22: * Providence, RI 02912
23: *
24: *
25: * Copyright (c) 1986 Brown University
26: *
27: * Permission to use, copy, modify and distribute this software and its
28: * documentation for any purpose and without fee is hereby granted, provided
29: * that the above copyright notice appear in all copies, and that both
30: * that copyright notice and this permission notice appear in supporting
31: * documentation, and that the name of Brown University not be used in
32: * advertising or publicity pertaining to distribution of the software
33: * without specific, written prior permission. Brown University makes no
34: * representations about the suitability of this software for any purpose.
35: * It is provided "as-is" without express or implied warranty.
36: */
37:
38: #include "private.h"
39: #include "bitblt.h"
40: #include "text.h"
41:
42: /*
43: * Print text with font as source
44: */
45:
46: PrintText (string, strlen, font, fore, back, charpad, spacepad, dstx, dsty,
47: clips, clipcount, func, zmask)
48: register char *string;
49: FONT *font;
50: register strlen, dstx;
51: register charpad, spacepad;
52: int fore, back, dsty;
53: CLIP *clips;
54: int clipcount, zmask;
55: int func;
56: {
57: FontPriv *fpriv = FDATA(font);
58: BITMAP *cbm = fpriv->chrs;
59: register c;
60: register charwidth;
61: register buf_wd, buf_ht;
62: register nchar;
63: register srcOx;
64: int srcCx;
65:
66: #ifdef TRACE_X
67: fprintf(stderr, "In PrintText\n");
68: fflush(stderr);
69: #endif TRACE_X
70:
71: /*
72: * Limit text to one plane
73: */
74: if ((zmask & 1) == 0)
75: return;
76:
77: /*
78: * Change combination rule to reflect specified
79: * foreground and background colors
80: */
81:
82: if (fore & 1)
83: func += 0x20;
84:
85: if (back & 1)
86: func += 0x10;
87:
88: func = FBMap[func];
89:
90: /*
91: * While we have more than CH_THRESHOLD characters then we will put
92: * the text into an offscreen buffer then blow it up onto the screen.
93: * When it drops below this threshold then it is no longer efficient
94: * to go to an offscreen buffer and we will go directly to the screen
95: * with bitblt.
96: */
97:
98: if (fpriv->offscr != NILBITMAP) {
99: while (strlen > CH_THRESHOLD) {
100: /*
101: * Make sure that CopyScreenBits() stays on the screen.
102: * Note: We are assuming the destination bitmap and the
103: * screen bitmap are already zero based and we
104: * are assuming that the txtbm is at least the
105: * width of the screen.
106: */
107:
108: if ((buf_ht = font->height) > (pbm.height - dsty)) {
109: buf_ht = pbm.height - dsty;
110: }
111:
112: if ((buf_wd = ((fpriv->maxwidth + charpad + spacepad) *
113: strlen)) > (pbm.width - dstx)) {
114: if ((buf_wd = pbm.width - dstx) > txtbm.width) {
115: buf_wd = txtbm.width;
116: }
117: }
118:
119: /*
120: * Make sure the sizes are non-zero.
121: */
122:
123: if (buf_ht < 1 || buf_wd < 1) {
124: break;
125: }
126:
127: /*
128: * Bring area on the screen into the offscreen buffer.
129: */
130:
131: CopyScreenBits(dstx, dsty, buf_wd, buf_ht, &txtbm);
132:
133: /*
134: * Blt as much text as one can into the offscreen
135: * buffer. NOTE: Because CopyScreenBits rounds over
136: * to a long word (4 bytes) boundary we must move
137: * the text over in the offscreen area by modulo 32.
138: * Also note that offscreen_text returns the source
139: * corner in srcCx.
140: */
141:
142: srcOx = dstx & 0x1F;
143: if ((nchar = OffScreenText(&txtbm,font,string,strlen,
144: charpad,spacepad,srcOx,
145: &srcCx,func)) < 1) {
146: /*
147: * Check nchar before going on and get out of
148: * the loop if its less than 1.
149: */
150:
151: break;
152: }
153:
154: /*
155: * Move the string up and the char count down.
156: */
157:
158: string += nchar;
159: strlen -= nchar;
160:
161: /*
162: * Put the offscreen buffer back onto the screen using
163: * CopyBits().
164: *
165: * Make source and destination rectangles.
166: */
167:
168: FillInRect(srcOx,0,srcCx - srcOx,buf_ht,&SrcRect);
169: FillInRect(dstx,dsty,(srcCx - srcOx),
170: buf_ht,&DstRect);
171:
172: /*
173: * Put the offscreen text buffer back onto the screen.
174: */
175:
176: CopyBits((u_short *)txtbm.data,txtbm.width,txtbm.height,
177: &SrcRect, (u_short *) pbm.data, pbm.width,
178: pbm.height, &DstRect, NILMASK, NIL, NIL,
179: GXcopy, clipcount, clips);
180:
181: /*
182: * Adjust destination address (dstx)
183: */
184:
185: dstx = DstRect.corner_x + charpad;
186: }
187: }
188:
189: /*
190: * Now loop thru the string until we are finished.....
191: */
192:
193: while (--strlen >= 0) {
194:
195: /*
196: * Character we are working on
197: */
198:
199: c = (int) (*string++);
200:
201: /*
202: * Check for legal character.
203: */
204:
205: if (c < font->first || c > font->last)
206: continue;
207:
208: /*
209: * Get width of current character
210: */
211:
212: if((charwidth = fpriv->widths[c]) > 0) {
213:
214: /*
215: * Make source and destination rectangles
216: */
217:
218: FillInRect(0,font->height * (c - font->first),
219: charwidth, font->height, &SrcRect);
220: FillInRect(dstx, dsty, charwidth, font->height,
221: &DstRect);
222:
223: /*
224: * Blt character to frame buffer
225: */
226:
227: CopyBits((u_short *) cbm->data, cbm->width, cbm->height,
228: &SrcRect, (u_short *) pbm.data, pbm.width,
229: pbm.height, &DstRect, NILMASK, NIL, NIL, func,
230: clipcount, clips);
231:
232: /*
233: * Adjust destination address (dstx)
234: */
235:
236: dstx += charwidth + charpad;
237: }
238:
239: /*
240: * Adjust destination address by size of space character
241: */
242:
243: if (c == font->space)
244: dstx += spacepad;
245: }
246: }
247:
248: /*
249: * Print text with font as mask
250: */
251:
252: PrintTextMask (string, strlen, font, srcpix, charpad, spacepad, dstx, dsty,
253: clips, clipcount, func, zmask)
254: register char *string;
255: FONT *font;
256: register strlen, charpad, spacepad, dstx;
257: int srcpix, dsty;
258: CLIP *clips;
259: int clipcount, zmask;
260: int func;
261: {
262: register FontPriv *fpriv = FDATA(font);
263: int charsize = BitmapSize(fpriv->maxwidth, font->height);
264: u_short *charmask;
265: register charwidth;
266: register c;
267: register srcOx;
268: register nchar;
269: int srcCx;
270:
271: #ifdef TRACE_X
272: fprintf (stderr, "In PrintTextMask\n");
273: fflush (stderr);
274: #endif TRACE_X
275:
276: /*
277: * Limit text to one plane
278: */
279:
280: if ((zmask & 1) == 0)
281: return;
282:
283: /*
284: * While we have more than CH_THRESHOLD characters then we will put
285: * the text into an offscreen buffer then blow it up onto the screen.
286: * When it drops below this threshold then it is no longer efficient
287: * to go to an offscreen buffer and we will go directly to the screen
288: * with bitblt.
289: */
290:
291: if (fpriv->offscr != NILBITMAP) {
292: while (strlen > CH_THRESHOLD) {
293:
294: /*
295: * Clear the offscreen buffer area.
296: */
297:
298: bzero((char *)txtbm.data,
299: (font->height * ((txtbm.width + 15)/16)) << 1);
300:
301: /*
302: * Blt as much text as one can into the offscreen
303: * buffer. Note that offscreen_text returns the source
304: * corner in srcCx.
305: */
306:
307: srcOx = dstx & 0xF;
308: if ((nchar = OffScreenText(&txtbm,font,string,strlen,
309: charpad,spacepad,srcOx,
310: &srcCx,GXcopy)) < 1) {
311: /*
312: * Check nchar before going on and get out of
313: * the loop if its less than 1.
314: */
315:
316: break;
317: }
318:
319: /*
320: * Move the string up and the char count down.
321: */
322:
323: string += nchar;
324: strlen -= nchar;
325:
326: /*
327: * Put the offscreen buffer back onto the screen using
328: * CopyBits().
329: *
330: * Make source and destination rectangles.
331: */
332:
333: FillInRect((dstx - srcOx),dsty,srcCx,
334: font->height,&DstRect);
335:
336: /*
337: * Using the offscreen bitmap as a mask, copy
338: * the text to the screen.
339: */
340:
341: CopyBits((u_short *) ConstantTiles[srcpix & 1],
342: NIL, NIL, NILRECT,
343: (u_short *) pbm.data, pbm.width, pbm.height,
344: &DstRect, (u_short *)txtbm.data, txtbm.width,
345: font->height, MAKE_TILE_RULE(func), clipcount,
346: clips);
347:
348: /*
349: * Adjust destination address (dstx)
350: */
351:
352: dstx = DstRect.corner_x + charwidth + charpad;
353: }
354: }
355:
356: /*
357: * Now loop thru the string until we are finished.....
358: */
359:
360: while (--strlen >= 0) {
361:
362: /*
363: * Character we are working on
364: */
365:
366: c = (int) (*string++);
367:
368: /*
369: * Check for legal character.
370: */
371:
372: if (c < font->first || c > font->last)
373: continue;
374:
375: /*
376: * Get width of current character
377: */
378:
379: if((charwidth = fpriv->widths[c]) > 0) {
380:
381: /*
382: * Use character as clipping mask
383: */
384:
385: charmask = (u_short *) ((long) fpriv->chrs->data +
386: charsize * (c - font->first));
387:
388: /*
389: * Fill in destination rectangle
390: */
391:
392: FillInRect(dstx, dsty, charwidth, font->height,
393: &DstRect);
394:
395: /*
396: * Blt character to frame buffer using font
397: * character as mask
398: */
399:
400: CopyBits((u_short *) ConstantTiles[srcpix & 1], NIL,
401: NIL, NILRECT, (u_short *) pbm.data, pbm.width,
402: pbm.height, &DstRect,
403: charmask, charwidth, font->height,
404: MAKE_TILE_RULE(func), clipcount, clips);
405:
406: /*
407: * Adjust destination address (dstx) by character
408: * pad amount
409: */
410:
411: dstx += charwidth + charpad;
412: }
413:
414: /*
415: * Adjust destination address by size of space character
416: */
417:
418: if (c == font->space)
419: dstx += spacepad;
420: }
421: }
422:
423: /*
424: * Copy text to bitmap
425: */
426:
427: CopyText (string, strlen, font, bm)
428: register char *string;
429: register strlen;
430: FONT *font;
431: BITMAP *bm;
432: {
433: register FontPriv *fpriv = FDATA(font);
434: BITMAP *cbm = fpriv->chrs;
435: register c;
436: register charwidth;
437: register dstx = 0;
438:
439: #ifdef TRACE_X
440: fprintf(stderr, "In CopyText\n");
441: fflush(stderr);
442: #endif TRACE_X
443:
444: /*
445: * loop thru string until we are finished.....
446: */
447:
448: while (--strlen >= 0) {
449:
450: /*
451: * Character we are working on
452: */
453:
454: c = (int) (*string++);
455:
456: /*
457: * Check for legal character.
458: */
459:
460: if (c < font->first || c > font->last)
461: continue;
462:
463: /*
464: * Get width of current character
465: */
466:
467: if((charwidth = fpriv->widths[c]) == 0)
468: continue;
469:
470: /*
471: * Fill in source and destination rectangles
472: */
473:
474: FillInRect(0,font->height * (c - font->first),
475: charwidth, font->height, &SrcRect);
476: FillInRect(dstx, 0, charwidth, font->height, &DstRect);
477:
478: /*
479: * Blt character to bitmap
480: */
481:
482: CopyBits((u_short *)cbm->data,cbm->width, cbm->height, &SrcRect,
483: (u_short *) bm->data, bm->width, bm->height, &DstRect,
484: NILMASK, NIL, NIL, GXcopy, 0, NILCLIP);
485:
486: /*
487: * Adjust destination address (dstx)
488: */
489:
490: dstx += charwidth;
491: }
492: }
493:
494: /*
495: * Compute width of a piece of text in a font
496: */
497:
498: int TextWidth (string, strlen, spacepad, font)
499: register char *string;
500: register int strlen;
501: int spacepad;
502: register FONT *font;
503: {
504: register u_int c;
505: register short *widths;
506: register int width = 0;
507:
508: #ifdef TRACE_X
509: fprintf(stderr, "In TextWidth\n");
510: fflush(stderr);
511: #endif TRACE_X
512:
513: if (font->fixed) {
514: /*
515: * Font is fixed width
516: */
517:
518: /*
519: * Compute total width of text string
520: */
521:
522: width = strlen * font->avg_width;
523:
524: if (spacepad) {
525: /*
526: * Add spacepad amount to the total width for each
527: * space character found in text string
528: */
529:
530: while (--strlen >= 0) {
531: if (*string++ == font->space)
532: width += spacepad;
533: }
534: }
535: } else {
536: /*
537: * Font is variable width
538: */
539:
540:
541: /*
542: * get pointer to width table
543: */
544:
545: widths = FDATA(font)->widths;
546:
547: /*
548: * Loop thru text string
549: */
550:
551: while (--strlen >= 0) {
552: /*
553: * Get current character
554: */
555:
556: c = *string++;
557: if (c >= font->first && c <= font->last) {
558: /*
559: * Valid character
560: */
561:
562: if (c == font->space) {
563: /*
564: * Character is a space so add
565: * spacepad amount to total width
566: */
567:
568: width += spacepad;
569: }
570:
571: /*
572: * Find width of this character in width
573: * table and add it to total
574: */
575:
576: width += widths[c];
577: }
578: }
579: }
580: return (width);
581: }
582:
583: /*
584: * Determine width of a character in a font
585: */
586:
587: int CharWidth(c, font)
588: register u_int c;
589: register FONT *font;
590: {
591: #ifdef TRACE_X
592: fprintf(stderr, "In CharWidth\n");
593: fflush(stderr);
594: #endif TRACE_X
595:
596: if (c < font->first || c > font->last)
597: /*
598: * Character not in font
599: */
600:
601: return (0);
602: else if (font->fixed)
603: /*
604: * Font is a fixed width so return the
605: * average character width for the font
606: */
607:
608: return (font->avg_width);
609: else
610: /*
611: * Font is variable width so determine
612: * width of character from font width table
613: */
614:
615: return (FDATA(font)->widths[c]);
616: }
617:
618: /*
619: * OffScreenText puts text from "font" into "buf_bm". It assumes the font
620: * bitmap * has its characters "left justified". It returns the rightmost
621: * X position in "cornerX".
622: */
623:
624: static
625: OffScreenText(buf_bm,font,string,ch_count,ch_pad,sp_pad,dstX,cornerX,func)
626: BITMAP *buf_bm; /* Offscreen buffer bitmap */
627: FONT *font; /* Font structure */
628: char *string; /* String of characters to be put up. */
629: int ch_count; /* Number of characters in the string */
630: int ch_pad; /* Space between characters */
631: int sp_pad; /* Amount of space a pad character is. */
632: int dstX; /* The spot in the offscreen buffer where
633: the text is to start. */
634: int *cornerX; /* Send the rightmost X position back to the
635: caller for use with the bltter. */
636: int func; /* Function (or combination rule) to be used
637: with text */
638: {
639: register u_char *dst;
640: register u_char *src;
641: register u_long src_nextline, dst_nextline;
642: register int height;
643: register u_short leftmask, rtmask;
644: int c, shift, ndst_shorts, inv_shift, i, start_dst;
645: int dst_nextcol, src_nextcol, nsrc_shorts, ht_plus1;
646: short chrs_nshorts, buf_nshorts;
647: u_long bitptr;
648: long maxbitptr;
649: int shorts_per_char;
650: u_char *chrs_data;
651: FontPriv *fpriv = FDATA(font);
652: short *char_widths = fpriv->widths;
653:
654: #ifdef TRACE_X
655: fprintf (stderr, "In OffScreenText\n");
656: fflush (stderr);
657: #endif TRACE_X
658:
659: /*
660: * Calculate, in shorts, the width of both the chrs and
661: * buffer bitmaps.
662: */
663:
664: chrs_nshorts = BTOW(fpriv->maxwidth);
665:
666: maxbitptr = fpriv->offscr->width;
667: buf_nshorts = BTOW(maxbitptr);
668:
669: /*
670: * Set up to go through the string of characters.
671: */
672:
673: bitptr = dstX;
674:
675: src_nextline = MUL_2(chrs_nshorts);
676: dst_nextline = MUL_2(buf_nshorts);
677:
678: /*
679: * Setup for text blt
680: */
681:
682: ht_plus1 = font->height + 1;
683: shorts_per_char = MUL_2(chrs_nshorts * font->height);
684: chrs_data = (u_char *)fpriv->chrs->data;
685:
686: /*
687: * Blt text string into offscreen buffer
688: */
689:
690: switch (func) {
691: case (GXclear):
692: CopyText_LOOP(GXclear_MASK, GXclear_OP);
693: break;
694:
695: case (GXand):
696: CopyText_LOOP(GXand_MASK, GXand_OP);
697: break;
698:
699: case (GXandReverse):
700: CopyText_LOOP(GXandReverse_MASK, GXandReverse_OP);
701: break;
702:
703: case (GXcopy):
704: CopyText_LOOP(GXcopy_MASK, GXcopy_OP);
705: break;
706:
707: case (GXandInverted):
708: CopyText_LOOP(GXandInverted_MASK, GXandInverted_OP);
709: break;
710:
711: case (GXnoop):
712: break;
713:
714: case (GXxor):
715: CopyText_LOOP(GXxor_MASK, GXxor_OP);
716: break;
717:
718: case (GXor):
719: CopyText_LOOP(GXor_MASK, GXor_OP);
720: break;
721:
722: case (GXnor):
723: CopyText_LOOP(GXnor_MASK, GXnor_OP);
724: break;
725:
726: case (GXequiv):
727: CopyText_LOOP(GXequiv_MASK, GXequiv_OP);
728: break;
729:
730: case (GXinvert):
731: CopyText_LOOP(GXinvert_MASK, GXinvert_OP);
732: break;
733:
734: case (GXorReverse):
735: CopyText_LOOP(GXorReverse_MASK, GXorReverse_OP);
736: break;
737:
738: case (GXcopyInverted):
739: CopyText_LOOP(GXcopyInverted_MASK, GXcopyInverted_OP);
740: break;
741:
742: case (GXorInverted):
743: CopyText_LOOP(GXorInverted_MASK, GXorInverted_OP);
744: break;
745:
746: case (GXnand):
747: CopyText_LOOP(GXnand_MASK, GXnand_OP);
748: break;
749:
750: case (GXset):
751: CopyText_LOOP(GXset_MASK, GXset_OP);
752: break;
753: }
754:
755: /*
756: * Remove the last charcter pad added to the last character.
757: */
758:
759: bitptr -= ch_pad;
760:
761: /*
762: * Return right most X value and character count to caller
763: */
764:
765: if (bitptr > dstX)
766: *cornerX = bitptr;
767: else
768: *cornerX = dstX;
769: return(ch_count);
770: }
771:
772: #if (APA8 || APA8C)
773:
774: #define DSTBITS ((u_short *)DstBits)
775: #define SRCBITS ((u_short *)SrcBits)
776: #define SIZE_OF_SHORT (sizeof(u_short))
777: #define SIZE_OF_APA8_SHORT (sizeof(u_short) * 2)
778:
779: /*
780: * Copy shorts off of the screen (pbm) into the destination bitmap.
781: */
782:
783: static
784: CopyScreenBits(StartX, StartY, Width, Height, DstBitmap)
785: int StartX, StartY;
786: int Width;
787: register Height;
788: BITMAP *DstBitmap;
789: {
790: register nwords;
791: register char *DstBits;
792: register DstRowBytes;
793: register SrcRowBytes;
794: register char *SrcBits;
795:
796: #ifdef TRACE_X
797: fprintf (stderr, "In CopyScreenBits\n");
798: fflush (stderr);
799: #endif TRACE_X
800:
801: /*
802: * Check StartX and StartY and offset the destination pointer if
803: * one or both are negative and change the source pointer.
804: */
805:
806: if (StartX < 0) {
807: /*
808: * Make sure there are words to be taken off the screen.
809: */
810:
811: if ((nwords = BTOW(StartX + Width)) < 1) {
812: return;
813: }
814: DstRowBytes = MUL_2(DIV_BPW(DstBitmap->width) - nwords);
815: SrcRowBytes = MUL_4(DIV_BPW(pbm.width));
816: DstBits = (char *)DstBitmap->data + MUL_2(DIV_BPW(-StartX));
817:
818: if (StartY < 0) {
819: /*
820: * Figure out the number of scanlines to be copied.
821: */
822:
823: if ((Height += StartY) < 1) {
824: return;
825: }
826:
827: DstBits += (-StartY * (DstBitmap->width >> 3));
828: SrcBits = (char *)pbm.data;
829: } else {
830: SrcBits = (char *)pbm.data + (StartY * SrcRowBytes);
831: }
832: } else {
833: /*
834: * Make sure there are words to be taken off the screen.
835: */
836:
837: if ((nwords = BTOW(StartX + Width) - DIV_BPW(StartX)) < 1) {
838: return;
839: }
840:
841: DstRowBytes = MUL_2(DIV_BPW(DstBitmap->width) - nwords);
842: SrcRowBytes = MUL_4(DIV_BPW(pbm.width));
843: DstBits = (char *)DstBitmap->data;
844:
845: if (StartY < 0) {
846: /*
847: * Figure out the number of scanlines to be copied.
848: */
849:
850: if ((Height += StartY) < 1) {
851: return;
852: }
853:
854: DstBits += (-StartY * (DstBitmap->width >> 3));
855: SrcBits = (char *)pbm.data + MUL_4(DIV_BPW(StartX));
856: } else {
857: SrcBits = (char *)pbm.data + (StartY * SrcRowBytes) +
858: MUL_4(BTOW(StartX));
859: }
860: }
861:
862:
863: if (nwords > 1) { /* more than one short wide */
864: int tmpnWords = nwords;
865:
866: SrcRowBytes -= MUL_4(nwords);
867: while(1) {
868: do {
869: *DSTBITS = *SRCBITS;
870: DstBits += SIZE_OF_SHORT;
871: SrcBits += SIZE_OF_APA8_SHORT;
872: } while(--nwords > 0);
873:
874: if(--Height) {
875: DstBits += DstRowBytes;
876: SrcBits += SrcRowBytes;
877: nwords = tmpnWords;
878: } else {
879: break;
880: }
881: }
882: } else { /* one short wide */
883: /*
884: * Should not have subtracted (nwords << 2) from
885: * DstRowBytes. So now that we know nwords == 1 we will
886: * add (nwords << 2) == 4 back to DstRowBytes.
887: */
888:
889: DstRowBytes += 4;
890:
891: while(1) {
892: *DSTBITS = *SRCBITS;
893: if(--Height) {
894: DstBits += DstRowBytes;
895: SrcBits += SrcRowBytes;
896: } else {
897: break;
898: }
899: }
900: }
901: }
902:
903: #else
904:
905: #define DSTBITS ((u_long *)DstBits)
906: #define SRCBITS ((u_long *)SrcBits)
907: #define SIZE_OF_LONG sizeof(u_long)
908:
909: /*
910: * Copy long words off of the screen (pbm) into the destination bitmap.
911: */
912:
913: static
914: CopyScreenBits(StartX, StartY, Width, Height, DstBitmap)
915: int StartX, StartY;
916: int Width;
917: register Height;
918: BITMAP *DstBitmap;
919: {
920: register nwords;
921: register char *DstBits;
922: register DstRowBytes;
923: register SrcRowBytes;
924: register char *SrcBits;
925: #if (APA16 && USE_APA16_HDWR)
926: int tmp;
927: #endif (APA16 && USE_APA16_HDWR)
928:
929: #ifdef TRACE_X
930: fprintf (stderr, "In CopyScreenBits\n");
931: fflush (stderr);
932: #endif TRACE_X
933:
934: /*
935: * Check StartX and StartY and offset the destination pointer if
936: * one or both are negative and change the source pointer.
937: */
938:
939: if (StartX < 0) {
940: /*
941: * Make sure there are words to be taken off the screen.
942: */
943:
944: if ((nwords = BTOL(StartX + Width)) < 1) {
945: return;
946: }
947:
948: /*
949: * DstRowBytes and SrcRowBytes are MUL_4'ed so that
950: * they are the number of BYTES the address must be incremented.
951: */
952:
953: DstRowBytes = MUL_4(DIV_BPL(DstBitmap->width) - nwords);
954: SrcRowBytes = MUL_4(DIV_BPL(pbm.width));
955: DstBits = (char *)DstBitmap->data + MUL_4(DIV_BPL(-StartX));
956:
957: if (StartY < 0) {
958: /*
959: * Figure out the number of scanlines to be copied.
960: */
961:
962: if ((Height += StartY) < 1) {
963: return;
964: }
965:
966: DstBits += (-StartY * (DstBitmap->width >> 3));
967: SrcBits = (char *)pbm.data;
968: } else {
969: SrcBits = (char *)pbm.data + (StartY*SrcRowBytes);
970: }
971: } else {
972: /*
973: * Make sure there are words to be taken off the screen.
974: */
975:
976: if ((nwords = BTOL(StartX + Width) - DIV_BPL(StartX)) < 1) {
977: return;
978: }
979:
980: DstRowBytes = MUL_4(DIV_BPL(DstBitmap->width) - nwords);
981: SrcRowBytes = MUL_4(DIV_BPL(pbm.width));
982: DstBits = (char *)DstBitmap->data;
983:
984: if (StartY < 0) {
985: /*
986: * Figure out the number of scanlines to be copied.
987: */
988:
989: if ((Height += StartY) < 1) {
990: return;
991: }
992:
993: DstBits += (-StartY * (DstBitmap->width >> 3));
994: SrcBits = (char *)pbm.data + MUL_4(DIV_BPL(StartX));
995: } else {
996: SrcBits = (char *)pbm.data + (StartY * SrcRowBytes) +
997: MUL_4(DIV_BPL(StartX));
998: }
999: }
1000:
1001: #if (APA16 && USE_APA16_HDWR)
1002: #include "../bitblt/bitblt_apa16.h"
1003: /*
1004: * If we are using the APA-16 hardware then we must wait for the
1005: * hardware to be done with the screen.
1006: */
1007:
1008: WAIT_QUE(tmp, 0);
1009: #endif (APA16 && USE_APA16_HDWR)
1010:
1011: if (nwords > 1) { /* more than one long wide */
1012: int tmpnWords = nwords;
1013:
1014: SrcRowBytes -= MUL_4(nwords);
1015: while(1) {
1016: do {
1017: *DSTBITS = *SRCBITS;
1018: DstBits += SIZE_OF_LONG;
1019: SrcBits += SIZE_OF_LONG;
1020: } while(--nwords > 0);
1021:
1022: if(--Height) {
1023: DstBits += DstRowBytes;
1024: SrcBits += SrcRowBytes;
1025: nwords = tmpnWords;
1026: } else {
1027: break;
1028: }
1029: }
1030: } else { /* one long wide */
1031: /*
1032: * Should not have subtracted MUL_4(nwords) from
1033: * DstRowBytes. So now that we know nwords == 1 we will
1034: * add MUL_4(nwords) == 4 back to DstRowBytes.
1035: */
1036:
1037: DstRowBytes += 4;
1038:
1039: while(1) {
1040: *DSTBITS = *SRCBITS;
1041: if(--Height) {
1042: DstBits += DstRowBytes;
1043: SrcBits += SrcRowBytes;
1044: } else {
1045: break;
1046: }
1047: }
1048: }
1049: }
1050: #endif (APA8 || APA8C)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.