![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dofile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / X / ximpv|
Return to dofile.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / ximpv |
1.1 root 1: /*
2: * Copyright (c) 1985 University of Alberta *
3: */
4:
5: #ifndef lint
6: static char *rcsid_dofile_c = "$Header: dofile.c,v 10.2 86/02/01 15:59:47 tony Rel $";
7: #endif
8:
9: #include "site.h"
10: #include "imPdefs.h"
11: #include "imPcodes.h"
12: #include "impv.h"
13: #include <stdio.h>
14: #ifndef XWIND
15: #include <pixrect/pixrect_hs.h>
16: #endif
17:
18: dofile()
19: {
20: register int i, j, code;
21: register struct glyph *gp;
22: register unsigned char *p;
23: #ifdef COLOR
24: register int k, *tp;
25: int t, tmp[1000];
26: unsigned char setcolor();
27: #endif COLOR
28: short rwid, iwid;
29: short hsize, vsize;
30: MSKWORD mw;
31:
32: while ((code = gc()) == '@') /* skip document control stuff */
33: while ((code = gc()) != ')')
34: if (code == '"') while(gc() != '"');
35: do{
36: if(code & 0200) decode(code);
37: switch(code){
38: case ASP0:
39: HPos += SpaceSize;
40: break;
41: case ASP1:
42: HPos += SpaceSize + 1;
43: break;
44: case AM:
45: EXTSIGN(1);
46: HPos += V(1);
47: break;
48: case AMM:
49: HPos--;
50: break;
51: case AMP:
52: HPos++;
53: break;
54: case ASRULE:
55: EXTSIGN(3);
56: P_rule();
57: break;
58: case ABRULE:
59: P_rule();
60: break;
61: case ASGLY:
62: EXTSIGN(4);
63: EXTSIGN(6);
64: case ABGLY:
65: fam = (V(1)>>7)&0177;
66: if(family[fam] == 0){
67: family[fam] = (struct glyph *)malloc((unsigned)sizeof font0);
68: for(i=127; i >= 0; i--)
69: family[fam][i].bits = 0;
70: fam_rot[fam] = (V(1)>>14) & 03;
71: }
72: gp = &family[fam][0177&V(1)];
73: gp->advance = V(2);
74: gp->left = V(4);
75: gp->top = V(6);
76: rwid = ( V(3) + 7) >> 3;
77: #ifdef COLOR
78: if( slide )
79: {
80: gp->width = (V(3) + 2) / 3;
81: gp->height = (V(5) + 2) / 3;
82: iwid = gp->height * gp->width;
83: gp->bits = (unsigned char *)malloc((unsigned)iwid);
84: for (p = gp->bits, i = iwid; i--;) *p++ = 0;
85: for (tp = tmp, i = (gp->width * 3); i--;) *tp++ = 0;
86:
87: for (i = 0; i < V(5); i++)
88: {
89: for (j = 0; j < rwid; j++)
90: {
91: t = gc();
92: for (k = 8; k--;)
93: tmp[j * 8 + (7 - k)]
94: = (t & (1 << k)) ? 1 : 0;
95: }
96: tp = tmp;
97: p = &gp->bits[i/3 * gp->width];
98: for (j = gp->width; j--;)
99: *p++ += *tp++ + *tp++ + *tp++;
100: }
101: for (p = gp->bits, i = iwid; i--; p++)
102: *p = (*p + 1) / 2;
103: } else
104: #endif COLOR
105: {
106: gp->width = (V(3) + 1) >> 1;
107: gp->height = (V(5) + 1) >> 1;
108: /*round size to nearest byte size */
109: iwid = ( gp->width + 7) >> 3;
110: gp->bits = (unsigned char *)malloc((unsigned)gp->height * iwid);
111: /* for the height of the glyph */
112: for (i=0; i<V(5); i++) {
113: /* point at the bytes of glyph storage*/
114: p = &gp->bits[(i>>1) * iwid];
115: /* for two bytes at a time */
116: for (j=0; j < rwid; j += 2, p++) {
117: /* squeez the first byte 4 left */
118: mw = map8_4[gc()]<<4;
119: /* if not the last byte squeez */
120: /* in another */
121: if (j < (rwid - 1))
122: mw |= map8_4[gc()];
123: /* or store byte if i odd */
124: if(i&1) *p |= mw;
125: /* store byte if even */
126: else *p = mw;
127: }
128: }
129: }
130: break;
131: case ADELC:
132: case ADELG:
133: gp = &family[0177 & (V(1)>>7) ][0177 & V(1)];
134: if(gp->bits) free((char *)gp->bits);
135: gp->bits = 0;
136: break;
137: case ADELF:
138: fam =0177 & V(1);
139: if(family[fam] == 0) break;
140: for(i = 127; i >= 0; i--){
141: gp = &family[fam][i];
142: if(gp->bits) free((char *)gp->bits);
143: gp->bits = 0;
144: }
145: break;
146: case AMARGIN:
147: BeginOfLine = V(1);
148: break;
149: case ABSKIP:
150: InterLine = V(1);
151: break;
152: case AN:
153: HPos = BeginOfLine;
154: VPos += InterLine;
155: break;
156: case AEND:
157: if( ppause()) return;
158: case APAGE:
159: HPos = VPos = 0;
160: break;
161: case AF:
162: CurFamily =0177&V(1);
163: break;
164: case ASETSP:
165: SpaceSize = V(1);
166: break;
167: case AH:
168: if( V(1) & 01) HPos += V(1) >> 1;
169: else HPos = V(1) >> 1;
170: break;
171: case AV:
172: if( V(1) & 01) VPos += V(1) >> 1;
173: else VPos = V(1) >> 1;
174: break;
175: case ASET_HV_SYS:
176: /*page orientation not done*/
177: set_hv_sys();
178: break;
179: case ASET_ABS_H:
180: /*set abs major advance pos*/
181: HPos = V(1);
182: break;
183: case ASET_ABS_V:
184: /*set abs minor advance pos*/
185: VPos = V(1);
186: break;
187: case ASET_REL_H:
188: /*set rel major advance pos*/
189: HPos += V(1);
190: break;
191: case ASET_REL_V:
192: /*set rel minor advance pos*/
193: VPos += V(1);
194: break;
195: case AROTMS:
196: /*set advance directions not done*/
197: advance_dir = v(1);
198: break;
199: case AMMOVE:
200: /*add to main dir not done*/
201: if(orient == 0) HPos += V(1);
202: break;
203: case ASMOVE:
204: /*add to main dir not done*/
205: if(orient == 0) VPos += V(1);
206: break;
207: case ACREATE_MAP:
208: /*create font map not done*/
209: /* get name and size*/
210: map_name = v(1);
211: ntuples = v(2);
212: /* read and throw away bytes */
213: for (i=0;i<ntuples*4;i++) (void)gc();
214: #ifdef notdef
215: /* get memory for ntuples*/
216: map = (map_ptr *)malloc(ntuples * sizeof int);
217: /* read in map */
218: for(i=0;i<ntuples;i++) {
219: get and store byte word byte
220: map = map;
221: }
222: #endif
223: break;
224: case ACREATE_FAMILY:
225: /* create family table not done */
226: /* get family name and size*/
227: fam_in = v(1);
228: ntuples = v(2);
229: for (i=0;i<ntuples;i++) {
230: (void)gc();
231: while(gc()!=NULL);
232: }
233: #ifdef notdef
234: /* get memory for ntuples*/
235: /* read in family */
236: for(i=0;i<ntuples;i++) {
237: get and store byte string*
238: }
239: #endif
240: break;
241: case AFORCE_GLY_DELETE:
242: /*delete marked glyphs */
243: break;
244: case ASET_PATH:
245: /*get a line path */
246: /*get vertexcount*/
247: vertex_count = V(1);
248: path_point = (struct path *)malloc
249: (vertex_count * 2 * (sizeof(short)));
250: #ifdef COLOR
251: if (slide)
252: for (i=0; i<vertex_count; i++) {
253: (path_point+i)->hor = getint() / 3;
254: (path_point+i)->vert = getint() / 3;
255: }
256: else
257: #endif COLOR
258: {
259: for (i=0; i<vertex_count; i++) {
260: (path_point+i)->hor = (getint() >> 1);
261: (path_point+i)->vert = (getint() >> 1);
262: }
263: }
264: break;
265: case ASET_TEXTURE:
266: /*set texture for lines? */
267: fam = (V(1) >> 7) & 0177;
268: member = V(1) & 0177;
269: break;
270: case ASET_PEN:
271: /*set pen diameter */
272: #ifdef COLOR
273: if(slide)
274: diameter = (v(1)+2) / 3;
275: else
276: #endif COLOR
277: diameter = (v(1)+1) > 1;
278: break;
279: case ADRAW_PATH:
280: /* draw a path of bits or lines */
281: operation = v(1);
282: if (diameter < 4){ /* draw up to 4 || lines */
283: for(j=0; j<(vertex_count-1); j++){
284: for(i=0; i<diameter; i++){
285: draw_path1((path_point+j)->hor,
286: (path_point+j)->vert,
287: (path_point+j+1)->hor,
288: (path_point+j+1)->vert);
289: }
290: }
291: }
292: else {
293: /* draw a path wider than 4 lines */
294: for(j=0; j<vertex_count; j++) (void)fflush(stdout);
295: }
296: break;
297: case AFILL_PATH:
298: /* fill in a polygon not done*/
299: operation = v(1);
300: break;
301: case ABIT_MAP:
302: /* get a bit map not done*/
303: operation = v(1);
304: hsize = v(2);
305: vsize = v(3);
306: Prnt_Bitmap(hsize,vsize);
307: break;
308: case ASET_MAGNIFICATION:
309: magnification = v(1);
310: break;
311: case ASET_PUSH_MASK:
312: /* set the state mask */
313: push_mask = V(1);
314: break;
315: case APUSH:
316: /*push a state onto the state stack */
317: push_stack[pushed] = (struct state *)
318: malloc((unsigned)sizeof pstack);
319: stap = push_stack[pushed];
320: stap->push_mask =push_mask;
321: if(push_mask& 0400) {
322: stap->diameter = diameter;
323: stap->texture = texture;
324: }
325: if(push_mask& 0200) stap->SpaceSize = SpaceSize;
326: if(push_mask& 0100) stap->InterLine = InterLine;
327: if(push_mask& 040) stap->BeginOfLine = BeginOfLine;
328: if(push_mask& 020) stap->fam = fam;
329: if(push_mask& 010) {
330: stap->HPos = HPos;
331: stap->VPos = VPos;
332: }
333: if(push_mask& 04) stap->advance_dir = advance_dir;
334: if(push_mask& 02) {
335: stap->horigin = horigin;
336: stap->vorigin = vorigin;
337: }
338: if(push_mask& 01) stap->orient = orient;
339: pushed++;
340: break;
341: case APOP:
342: /*pop a state off the state stack */
343: if(pushed >= 1) {
344: pushed--;
345: stap = push_stack[pushed];
346: push_mask = stap->push_mask;
347: if(push_mask& 0400) {
348: diameter = stap->diameter;
349: texture = stap->texture;
350: }
351: if(push_mask& 0200) SpaceSize = stap->SpaceSize;
352: if(push_mask& 0100) InterLine = stap->InterLine;
353: if(push_mask& 040) BeginOfLine = stap->BeginOfLine;
354: if(push_mask& 020) fam = stap->fam;
355: if(push_mask& 010) {
356: HPos = stap->HPos;
357: VPos = stap->VPos;
358: }
359: if(push_mask& 04) advance_dir = stap->advance_dir;
360: if(push_mask& 02) {
361: horigin = stap->horigin;
362: vorigin = stap->vorigin;
363: }
364: if(push_mask& 01) orient = stap->orient;
365: free((char *)push_stack[pushed]);
366: }
367: else fprintf(stderr, "Can not pop more states\n");
368: break;
369: case ADEFINE_MACRO:
370: /* define a macro */
371: /* get the name v(1) and length V(2) of the macro*/
372: #ifdef COLOR
373: if (v(1) == 255)
374: {
375: if (gc() == 0 )
376: {
377: bc.red = (float)gc();
378: bc.green = (float)gc();
379: bc.blue = (float)gc();
380: if( slide )
381: {
382: backcolor = setcolor(0);
383: p = (unsigned char *)(mpr_d(pscreen)->md_image);
384: for (i = scr_size; i--;)
385: *p++ = backcolor;
386: }
387: }
388: else
389: {
390: cc.red = (float)gc();
391: cc.green = (float)gc();
392: cc.blue = (float)gc();
393: }
394: }
395: else
396: #endif COLOR
397: {
398: macro[v(1)].length = V(2);
399: macro_length = V(2);
400: /* get space equal to length */
401: mp = macro[v(1)].pointer =
402: (unsigned char *)malloc((unsigned)macro_length);
403: /*read the macro into the got space*/
404: for(i=0;i<macro_length; i++) mp[i] = gc();
405: }
406: break;
407: case AEXECUTE_MACRO:
408: /* execute a macro */
409: macro_length = macro[v(1)].length;
410: mp = macro[v(1)].pointer;
411: macro_on = TRUE;
412: break;
413: case ANOP:
414: break;
415: default:
416: if(!(code&0200)) {
417: gp = &family[CurFamily][code];
418: Prnt_Glyph(&family[CurFamily][code]);
419: }
420: else {
421: (void)write(1,'$',1);
422: }
423: }
424: }
425: while (AEOF != (code=gc()) );
426: }
427:
428: char r_mask[9] = {
429: 0, 01, 03, 07, 017, 037, 077, 0177, 0377 };
430: char l_mask[9] = {
431: 0377, 0376, 0374, 0370, 0360, 0340, 0300, 0200, 00 };
432: Prnt_Glyph(gp)
433: register struct glyph *gp;
434: {
435: register int i, bit_width, skew;
436: register unsigned char *sp, *base;
437: register unsigned char *bp = gp->bits;
438: short x_bit_pos, y_bit_pos;
439: #ifdef COLOR
440: short int j;
441: unsigned char setcolor();
442: #endif COLOR
443:
444: #ifdef COLOR
445: if( slide )
446: {
447: x_bit_pos = (HPos - gp->left + 2) / 3;
448: y_bit_pos = (VPos - gp->top + 2) / 3;
449: base = ((unsigned char *)(mpr_d(pscreen)->md_image))
450: + y_bit_pos * scr_x + x_bit_pos;
451: }
452: else
453: #endif COLOR
454: {
455: x_bit_pos = (HPos - gp->left + 1) >> 1;
456: y_bit_pos = (VPos - gp->top + 1) >> 1;
457: if(((((HPos+1) >>1) + gp->width) > scr_x) ||
458: ((((VPos+1)>>1) + gp->height) > scr_y) || bp == 0)
459: {
460: big++;
461: return;
462: }
463: if((x_bit_pos < 0) || (y_bit_pos < 0) )
464: {
465: (void)write(1,'-',1);
466: little++;
467: return;
468: }
469: #ifdef XWIND
470: base = pscreen
471: #else XWIND
472: base = ((unsigned char *)(mpr_d(pscreen)->md_image))
473: #endif XWIND
474: + (y_bit_pos * wide) + (x_bit_pos >> 3);
475: }
476: /* skew is bits displacement of glyph from a byte edge*/
477: skew = 8 - (x_bit_pos & 07);
478:
479: #ifdef COLOR
480: if (slide)
481: {
482: for (i = gp->height; i--; base += scr_x)
483: {
484: sp = base;
485: for (j = gp->width; j--;)
486: if( *bp != 0 )
487: *sp++ = setcolor(*bp++);
488: else
489: {
490: bp++;
491: sp++;
492: }
493: }
494: }
495: else
496: #endif COLOR
497: {
498: for(i = gp->height; i--; base += wide){
499: sp = base;
500: for(bit_width = gp->width; bit_width > 0;){
501: if(skew == 8){
502: *sp++ |= *bp++;
503: bit_width -= 8;
504: }
505: else {
506: *sp++ |= (*bp >> (8 - skew)) & r_mask[skew];
507: if((bit_width -= skew) <= 0){
508: bp++;
509: break;
510: }
511: *sp |= (*bp++ << skew) & l_mask[skew];
512: bit_width -= (8 - skew);
513: }
514: }
515: }
516: }
517: HPos += gp->advance;
518: }
519:
520: char l_bits[8] = {
521: 0377, 0200, 0300, 0340, 0360, 0370, 0374, 0376};
522: P_rule()
523: {
524: register int i, bit_width, skew;
525: register unsigned char *sp, *base;
526: register int bits_l;
527: short x_bit_pos, y_bit_pos;
528:
529: if(((V(1) + HPos) > 2048) || ((V(2) + VPos) > 2640)) {
530: big++;
531: return;
532: }
533: x_bit_pos = (HPos + 1) >> 1;
534: y_bit_pos = (VPos + V(3) + 1) >> 1;
535: if((x_bit_pos < 0) || (y_bit_pos < 0)){
536: (void)write(1,'-',1);
537: little++;
538: return;
539: }
540: #ifdef XWIND
541: base = pscreen
542: #else
543: base = ((unsigned char *)(mpr_d(pscreen)->md_image))
544: #endif
545: + (y_bit_pos * wide) + (x_bit_pos >> 3);
546: skew = 8 - (x_bit_pos & 07);
547: V(1) = (V(1) + 1) >> 1;
548: V(2) = (V(2) + 1) >> 1;
549: for(i = V(2); i--; base += wide){
550: sp = base;
551: for(bit_width = V(1); bit_width > 0;){
552: bits_l = l_bits[bit_width>7 ? 0 : bit_width];
553: if(skew == 8){
554: *sp++ |= bits_l;
555: bit_width -= 8;
556: }
557: else {
558: *sp++ |= (bits_l >> (8 - skew)) & r_mask[skew];
559: if((bit_width -= skew) <= 0) break;
560: *sp |= (bits_l << skew) & l_mask[skew];
561: bit_width -= (8 - skew);
562: }
563: }
564: }
565: }
566:
567: set_hv_sys()
568: {
569: register int norigin, naxes, norient;
570:
571: /*set a logical page orientation relative to the physical pagenot done*/
572: norigin = (v(1)>>5 )& 03;
573: naxes = (v(1)>>3)& 03;
574: norient = v(1)&07;
575: if(norient < 4) orient = (orient+norient)%4;
576: else orient = norient - 4;
577: set_axes(naxes, norigin);
578:
579: }
580:
581: set_axes(ax, or)
582: int ax, or;
583: {
584: switch (ax){
585: case 0:
586: break;
587: case 1:
588: hvangle = -hvangle;
589: break;
590: case 2:
591: hvangle = 1;
592: break;
593: case 3:
594: hvangle = -1;
595: break;
596: }
597: set_origin(or);
598: }
599:
600: set_origin(or)
601: int or;
602: {
603: /*set the origin of the logical page relative to the physical*/
604: switch (or){
605: case 0:
606: break;
607: case 1:
608: break;
609: case 2:
610: originlv = 0;
611: switch (orient){
612: case 0:
613: originlh = 0;
614: break;
615: case 1:
616: originlh = MAXx;
617: break;
618: case 2:
619: case 3:
620: originlh = MAXy;
621: break;
622: }
623: case 3:
624: if(orient == 1 ||orient == 3){
625: originlh = xpos;
626: originlv = ypos;
627: }
628: else{
629: originlv = xpos;
630: originlh = ypos;
631: }
632: break;
633: }
634: }
635:
636: draw_path1(x0, y0, x1, y1) /* draw line from here to x0, y0, x1, y1 */
637: int x0, y0, x1, y1;
638: {
639: int d, xd, yd, dx, dy, incr1, incr2;
640: int i, numdots;
641: int motincrx, motincry;
642:
643: xd = x1 - x0;
644: yd = y1 - y0;
645: dx = abs(xd);
646: dy = abs(yd);
647: /* sort between vertical, horizontal and in between */
648: put1(x0, y0);
649: if (xd == 0) {
650: numdots = abs (yd);
651: motincry = (yd<0)? -1 : 1;
652: for (i = 0; i < numdots; i++) {
653: y0 += motincry;
654: put1(x0, y0);
655: }
656: return;
657: }
658: if (yd == 0) {
659: numdots = abs (xd);
660: motincrx = (xd<0)? -1 : 1;
661: for (i = 0; i < numdots; i++) {
662: x0 += motincrx;
663: put1(x0, y0);
664: }
665: return;
666: }
667: if (abs (xd) > abs (yd)) { /* slope less than 1 */
668: d = 2 * dy -dx;
669: incr1 = 2 * dy;
670: incr2 = 2 * (dy - dx);
671: numdots = abs (xd);
672: motincrx = (xd<0)? -1 : 1;
673: motincry = (yd<0)? -1 : 1;
674: for (i = 0; i < numdots; i++) {
675: put1(x0, y0);
676: x0 += motincrx;
677: if(d < 0) d = d + incr1;
678: else{
679: y0 += motincry;
680: d = d + incr2;
681: }
682: }
683: }
684: else { /* slope more than 1 */
685: d = 2 * dx -dy;
686: incr1 = 2 * dx;
687: incr2 = 2 * (dx - dy);
688: numdots = abs (yd);
689: motincrx = (xd<0)? -1 : 1;
690: motincry = (yd<0)? -1 : 1;
691: for (i = 0; i < numdots; i++) {
692: put1(x0, y0);
693: y0 += motincry;
694: if(d < 0) d = d + incr1;
695: else{
696: x0 += motincrx;
697: d = d + incr2;
698: }
699: }
700: }
701: }
702:
703:
704: /* set the value of a t byte (texture) */
705: t_byte(x, y)
706: int x, y;
707: {
708:
709: if(fam == 0 && member == 0)
710: return(r_mask[9]);
711: /* else find the byte in the glyph mask */
712: return( *(family[fam][member].bits + ((x & 017) >> 3) + 2 * (y & 017)) );
713: }
714:
715: /* put a pixel onto a page image. */
716: put1(x,y)
717: int x, y;
718: {
719: register int skew;
720: short x_bit_pos, y_bit_pos;
721: register unsigned char *pbyte, tbyte;
722: #ifdef COLOR
723: unsigned char setcolor();
724: #endif COLOR
725:
726: x_bit_pos = x;
727: y_bit_pos = y;
728: if((x_bit_pos > scr_x) || (y_bit_pos > scr_y)) {
729: (void)write(1, "+pix", 4);
730: return;
731: }
732: if((x_bit_pos < 0) || (y_bit_pos < 0) ) {
733: (void)write(1,'-',1);
734: return;
735: }
736: #ifdef COLOR
737: if( slide )
738: {
739: pbyte = ((unsigned char *)(mpr_d(pscreen)->md_image))
740: + (y_bit_pos * scr_x) + x_bit_pos;
741: }
742: else
743: #endif COLOR
744: {
745: #ifdef XWIND
746: pbyte = pscreen
747: #else
748: pbyte = ((unsigned char *)(mpr_d(pscreen)->md_image))
749: #endif
750: +(y_bit_pos * wide) + (x_bit_pos >> 3);
751: }
752: /* skew is bits displacement of pixel from a byte edge*/
753: skew = 8 - (x_bit_pos & 07);
754: #ifdef COLOR
755: if(slide)
756: {
757: switch(operation) {
758: case(0):
759: *pbyte = backcolor;
760: break;
761: case(3):
762: case(7):
763: default:
764: *pbyte = setcolor(5);
765: break;
766: }
767: }
768: else
769: #endif COLOR
770: {
771: switch(operation)
772: {
773: case(0): /* clear the bit */
774: if (skew == 8) *pbyte &= r_mask[skew-1];
775: else *pbyte &= (r_mask[skew-1] | l_mask[skew+1]);
776: return;
777: case(3): /* opaque with t bit */
778: tbyte = t_byte(x, y);
779: if (skew == 8) *pbyte &= r_mask[skew-1];
780: else *pbyte &= (r_mask[skew-1] | l_mask[skew+1]);
781: if (skew == 8) tbyte &= r_mask[skew-1];
782: else tbyte &= (r_mask[skew-1] | l_mask[skew+1]);
783: *pbyte &= tbyte;
784: return;
785: case(7):/* or with t bit */
786: tbyte = t_byte(x, y);
787: if (skew == 8) tbyte &= r_mask[skew-1];
788: else tbyte &= (r_mask[skew-1] | l_mask[skew+1]);
789: *pbyte |= tbyte;
790: return;
791: default: /* black the bit */
792: if(skew == 8) *(pbyte-1) |= 1;
793: else *pbyte |= 1 << skew;
794: return;
795: }
796: }
797: }
798:
799: #ifdef notdef
800: /* put a line onto a page image. */
801: putline(xstart,xend,y)
802: int xstart,xend,y;
803: {
804: register int nbytes, xh, xs, i;
805: unsigned char pbyte, tbyte, *scptr;
806:
807: /* find how many bytes are affected by the line*/
808: nbytes=1;
809: if (xstart/8 != xend/8) nbytes += xend/8 - xstart/8;
810: switch(operation){
811: case(0): /* clear the bytes */
812: for(i=0; i< nbytes; i++){
813: xh = xstart/8;
814: xs = xstart%8;
815: #ifdef XWIND
816: scptr = pscreen;
817: #else
818: scptr = (unsigned char *)(mpr_d(pscreen)->md_image);
819: #endif
820: pbyte = *scptr+y*wide+xh;
821: if((xend+1)/8 > xh+1)
822: pbyte &= l_mask[xs];
823: else
824: pbyte &= (l_mask[xs]
825: & r_mask[(xend+1)%8]);
826: *(scptr+y*wide+xh) = pbyte;
827: xstart = xstart + 8 - xs;
828: }
829: return;
830:
831: case(15):/* black the bit */
832: for(i=0; i< nbytes; i++){
833: xh = xstart/8;
834: xs = xstart%8;
835: pbyte = *scptr+y*wide+xh;
836: if((xend+1)/8 > xh+1)
837: pbyte &= r_mask[8 - xs];
838: else
839: pbyte &= (r_mask[8 - xs]
840: & l_mask[8 - (xend+1)%8]);
841: *(scptr+y*wide+xh) = pbyte;
842: xstart = xstart + 8 - xs;
843: }
844: return;
845:
846: case(3): /* opaque with t bit */
847: for(i=0; i< nbytes; i++){
848: xh = xstart >> 3;
849: xs = xstart & 07;
850: pbyte = *scptr+wide*y+xh;
851: if((xend+1)/8 > xh+1)
852: pbyte &= l_mask[xs]
853: & t_byte(xstart, (xstart+8-xs), y);
854: else
855: pbyte &= (l_mask[xs]
856: & r_mask[(xend+1)%8])
857: & t_byte(xstart, xend, y);
858: *(scptr+y*wide+xh) = pbyte;
859: xstart = xstart + 8 - xs;
860: }
861: return;
862:
863: case(7):/* or with t bit */
864: for(i=0; i< nbytes; i++){
865: xh = xstart/8;
866: xs = xstart%8;
867: pbyte = *scptr+wide*y+xh;
868: if((xend+1)/8 > xh+1)
869: pbyte |=
870: t_byte(xstart, (xstart+8-xs), y);
871: else
872: pbyte |=
873: t_byte(xstart, xend, y);
874: *(scptr+y*wide+xh) = pbyte;
875: xstart = xstart + 8 - xs;
876: }
877: return;
878: }
879: }
880: #endif
881: Prnt_Bitmap(hsize, vsize)
882: short int hsize, vsize;
883: {
884: register short int i, j, k, l;
885: register unsigned char *sp;
886: unsigned char mw, *base, *basev, *baseb;
887: short x_bit_pos, y_bit_pos;
888:
889: /*
890: * get the bits and put them ???
891: */
892: x_bit_pos = (HPos + 1) >> 1;
893: y_bit_pos = (VPos + 1) >> 1;
894: if((((HPos+hsize*4+1) >> 1) > scr_x) || (((VPos+vsize*32+1) >> 1) > scr_y)){
895: big++;
896: return;
897: }
898: if((x_bit_pos < 0) || (y_bit_pos < 0) ) {
899: (void)write(1,'-',1);
900: little++;
901: return;
902: }
903: #ifdef XWIND
904: base = pscreen
905: #else
906: base = ((unsigned char *)(mpr_d(pscreen)->md_image))
907: #endif
908: +(y_bit_pos * wide) + (x_bit_pos >> 3);
909: basev = base;
910: if(magnification == 0) for(i=0;i<vsize;i++) {
911: /* rows of cols of 32*32 blocks */
912: baseb = basev;
913: /* cols of 32*32 blocks */
914: for(j=0;j<hsize;j++) {
915: sp = baseb;
916: /* block of 32*32 */
917: for(k=0;k<32;k++) {
918: /* row of 32 bits in 32*32 block*/
919: /* point at the bytes of glyph storage*/
920: /* for two bytes at a time */
921: for (l=0; l < 2; l++, sp++) {
922: /* squeez the first byte 4 left */
923: mw = map8_4[gc()]<<4;
924: mw |= map8_4[gc()];
925: /* or store byte if k odd */
926: if(k&1) *sp |= mw;
927: /* store byte if even */
928: else *sp = mw;
929: }
930: sp = baseb + wide * ((1+k)>>1);
931: /* add 1 line to v pos if odd*/
932: }
933: baseb = basev + 2 * (j+1);
934: /* add 16 bits to h pos */
935: }
936: basev = base + wide * 16 *(i+1);
937: /* squeeze to 1/2 height*/
938: }
939: else if (magnification == 1)
940: for (i=0; i<vsize; i++) {
941: baseb = basev;
942: for (j=0; j<hsize; j++) {
943: sp = baseb;
944: for (k=0; k<32; k++) {
945: /* point at the bytes of glyph storage*/
946: for (l=4; l; l--) *sp++ = gc();
947: sp += 124;
948: }
949: baseb += 4;
950: }
951: basev = base + wide * 32 *i;
952: }
953: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.