![[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] / 43BSDTahoe / new / X / ximpv|
Return to dofile.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / 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.