![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcmd.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 / xgedit|
Return to gcmd.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / xgedit |
1.1 ! root 1: #include <X/mit-copyright.h> ! 2: ! 3: /* Copyright Massachusetts Institute of Technology 1984, 1985 */ ! 4: ! 5: #ifndef lint ! 6: static char *rcsid_gcmd_c = "$Header: gcmd.c,v 10.6 86/02/01 16:18:44 tony Rel $"; ! 7: #endif lint ! 8: ! 9: char *malloc(), *strcpy(); ! 10: ! 11: #include "gedit.h" ! 12: ! 13: int mult = 1; /* command multiplier */ ! 14: int dx,dy,ends; /* used during select operation */ ! 15: int redo; /* set to one if arc cache should be recalculated */ ! 16: struct prototype *previous = NULL; /* last proto to be edited */ ! 17: ! 18: /* process command input from user -- return 1 if it's time to exit, 0 otherwise */ ! 19: command() ! 20: { register int ch; ! 21: fptr cmd; ! 22: extern char mousechanged; ! 23: char buf[100]; ! 24: ! 25: while (mousechanged) { ! 26: ch = track(); ! 27: if (ch & (RECENTER+REDISPLAY)) { ! 28: if (ch & RECENTER) { ! 29: new_window(&cur_state,cur_state.curx,cur_state.cury); ! 30: remouse(cur_state.curx, cur_state.cury, 1); ! 31: } ! 32: redisplay(); ! 33: } ! 34: if (!UserReady()) return(0); ! 35: } ! 36: ! 37: ch = UserChar() & 0xFF; ! 38: if (ch == 0377) return(0); ! 39: ! 40: cmd = dispatch[ch]; ! 41: if (cmd == NULL) { ! 42: Beep(); ! 43: sprintf(buf, "unrecognized command: 0%o", ch); ! 44: msg(buf); ! 45: } else { ! 46: ch = (*cmd)(); ! 47: if (!(ch & MULTIPLIER)) mult = 1; ! 48: if (ch & (RECENTER+REDISPLAY)) { ! 49: if (ch & RECENTER) { ! 50: new_window(&cur_state,cur_state.curx,cur_state.cury); ! 51: remouse(cur_state.curx, cur_state.cury, 1); ! 52: } ! 53: redisplay(); ! 54: } ! 55: if (ch & DONE) return(1); ! 56: } ! 57: ! 58: return(0); ! 59: } ! 60: ! 61: /* go back to editing last thing we were working on */ ! 62: editlast() ! 63: { struct prototype *temp; ! 64: ! 65: if (previous == NULL) return(0); ! 66: ! 67: if (temp = cur_state.curobj) temp->recent = cur_state; ! 68: cur_state = previous->recent; ! 69: previous = temp; ! 70: return(REDISPLAY); ! 71: } ! 72: ! 73: /* accept angle for SEGMENT */ ! 74: angle() ! 75: { register gptr p; ! 76: char buf[100]; ! 77: ! 78: if ((p = cur_state.editee) == NULL) goto done; ! 79: if (p->s.type != SEGMENT) goto done; ! 80: sprintf(buf,"angle = %d, new value (2048 units in a circle): ",p->s.angle); ! 81: if (userinput("",buf)) ! 82: goto done; ! 83: if (typein[0] == 0) goto done; ! 84: p->s.angle = atoi(typein) & 2047; ! 85: redo = 1; ! 86: ! 87: done: return(0); ! 88: } ! 89: ! 90: /* resize window and redisplay */ ! 91: fixwindow() ! 92: { new_window(&cur_state, ! 93: (cur_state.worgx+cur_state.wmaxx)>>1, ! 94: (cur_state.worgy+cur_state.wmaxy)>>1); ! 95: remouse(cur_state.curx, cur_state.cury, 1); ! 96: return(REDISPLAY); ! 97: } ! 98: ! 99: /* recenter window at cursor position */ ! 100: setwindow() ! 101: { return(RECENTER); ! 102: } ! 103: ! 104: /* frob orient parameter of selected object */ ! 105: rotateobj() ! 106: { register gptr p; ! 107: short temp; ! 108: ! 109: if ((p = cur_state.editee) != NULL) switch (p->s.type) { ! 110: case SEGMENT: if (p->s.angle == 0) break; ! 111: temp = p->s.x1; p->s.x1 = p->s.x2; p->s.x2 = temp; ! 112: temp = p->s.y1; p->s.y1 = p->s.y2; p->s.y2 = temp; ! 113: cur_state.whichend = 3 - cur_state.whichend; ! 114: redo = 1; ! 115: break; ! 116: ! 117: case LABEL: p->l.orient += 1; ! 118: if (p->l.orient > BR) p->l.orient = CC; ! 119: break; ! 120: ! 121: case OBJECT: p->o.orient += 1; ! 122: if (p->o.orient > RWEST) p->o.orient = NORTH; ! 123: break; ! 124: } ! 125: ! 126: return(0); ! 127: } ! 128: ! 129: /* edit selected object */ ! 130: editobj() ! 131: { register gptr p; ! 132: ! 133: if ((p = cur_state.editee) != NULL) switch (p->s.type) { ! 134: case LABEL: if (userinput(p->l.string,"edit label: ")) break; ! 135: if (strlen(typein) <= strlen(p->l.string)) ! 136: strcpy(p->l.string,typein); ! 137: else { ! 138: free(p->l.string); ! 139: if ((p->l.string = malloc((unsigned)(strlen(typein)+1))) == NULL) { ! 140: msg("out of room!"); ! 141: break; ! 142: } ! 143: strcpy(p->l.string,typein); ! 144: } ! 145: break; ! 146: ! 147: case OBJECT: cur_state.curobj->recent = cur_state; ! 148: previous = cur_state.curobj; ! 149: cur_state = p->o.proto->recent; ! 150: return(REDISPLAY); ! 151: } ! 152: ! 153: return(0); ! 154: } ! 155: ! 156: /* rescale subpicture */ ! 157: rescale() ! 158: { register gptr p; ! 159: register int ch; ! 160: char buf[100]; ! 161: int in1,in2; ! 162: ! 163: if ((p = cur_state.editee)==NULL || p->o.type!=OBJECT) return(0); ! 164: sprintf(buf,"subpicture scale = %d:%d, new scale: ",p->o.mscale,p->o.dscale); ! 165: if (userinput("",buf)) return(0); ! 166: ch = sscanf(typein,"%d:%d",&in1,&in2); ! 167: if (ch == 1) { ! 168: p->o.mscale = in1; ! 169: p->o.dscale = 1; ! 170: } else if (ch == 2) { ! 171: p->o.mscale = in1; ! 172: p->o.dscale = in2; ! 173: } else return(0); ! 174: remouse(cur_state.curx, cur_state.cury, 1); ! 175: return(REDISPLAY); ! 176: } ! 177: ! 178: /* delete object */ ! 179: delobj() ! 180: { register gptr p; ! 181: ! 182: if ((p = cur_state.editee) == NULL) return(0); ! 183: deselect(0); ! 184: remove(p); ! 185: return(0); ! 186: } ! 187: ! 188: /* abort current selection */ ! 189: quit() ! 190: { deselect(REDISPLAY); ! 191: return(0); ! 192: } ! 193: ! 194: /* drop current selection where cursor is */ ! 195: letgo() ! 196: { deselect(UPDATE+REDISPLAY); ! 197: return(0); ! 198: } ! 199: ! 200: /* drop current selection with same offset as last time */ ! 201: lastgo() ! 202: { deselect(UPDATE+USEOFFSET+REDISPLAY); ! 203: return(0); ! 204: } ! 205: ! 206: /* select nearby object */ ! 207: selobj() ! 208: { register gptr p; ! 209: register int in1 = 0; ! 210: ! 211: if ((p = cur_state.editee) == NULL) { ! 212: if ((p = cur_state.curobj->body) == NULL) return(0); ! 213: in1 = 1; ! 214: } else p = p->s.next; ! 215: ! 216: while (1) { ! 217: if (p == NULL) { ! 218: if (!in1) { ! 219: in1 = 1; ! 220: p = cur_state.curobj->body; ! 221: continue; ! 222: } else break; ! 223: } else if (p == cur_state.editee) break; ! 224: ! 225: if (nearby(p)) { selectobj(p,0); break; } ! 226: else p = p->s.next; ! 227: } ! 228: ! 229: return(0); ! 230: } ! 231: ! 232: /* create a new line segment */ ! 233: newline() ! 234: { register gptr p; ! 235: ! 236: if ((p = (gptr)malloc(sizeof(struct segment))) == NULL) ! 237: msg("out of room!"); ! 238: else { ! 239: p->s.type = SEGMENT; ! 240: p->s.x2 = cur_state.curx; ! 241: p->s.y2 = cur_state.cury; ! 242: p->s.angle = 0; ! 243: p->s.cache = NULL; ! 244: newobj(p); ! 245: } ! 246: return(0); ! 247: } ! 248: ! 249: /* finish creation of new object */ ! 250: newobj(p) ! 251: register gptr p; ! 252: { p->s.next = cur_state.curobj->body; ! 253: cur_state.curobj->body = p; ! 254: cur_state.curobj->modified = 1; ! 255: p->s.parent = cur_state.curobj; ! 256: p->s.x1 = cur_state.curx; ! 257: p->s.y1 = cur_state.cury; ! 258: dx = dy = 0; ! 259: ends = 2; ! 260: selectobj(p,1); ! 261: } ! 262: ! 263: /* instantiate an object */ ! 264: instantiate() ! 265: { register gptr p; ! 266: register struct prototype *new; ! 267: char buf[100]; ! 268: ! 269: if (userinput("","name of definition to instantiate: ")) return(0); ! 270: new = read_def(typein); ! 271: if (new->body == NULL) { ! 272: sprintf(buf,"definition for %s not found",new->name); ! 273: msg(buf); ! 274: retdef: free(new->name); ! 275: directory = new->next; /* remove dir entry */ ! 276: free((char *)new); ! 277: return(0); ! 278: }; ! 279: if ((p = (gptr)malloc(sizeof(struct object))) == NULL) { ! 280: msg("out of room!"); ! 281: goto retdef; ! 282: } ! 283: p->o.type = OBJECT; ! 284: p->o.orient = NORTH; ! 285: p->o.proto = new; ! 286: p->o.mscale = p->o.dscale = 1; ! 287: newobj(p); ! 288: return(0); ! 289: } ! 290: ! 291: /* new label */ ! 292: newlabel() ! 293: { register gptr p; ! 294: ! 295: if (userinput("","label: ")) return(0); ! 296: if ((p = (gptr)malloc(sizeof(struct label))) == NULL) { ! 297: msg("out of room!"); ! 298: return(0); ! 299: } ! 300: p->l.type = LABEL; ! 301: p->l.orient = CC; ! 302: if ((p->l.string = malloc((unsigned) (strlen(typein)+1))) == NULL) { ! 303: msg("out of room!"); ! 304: free((char *) p); ! 305: return(0); ! 306: } ! 307: strcpy(p->l.string,typein); ! 308: newobj(p); ! 309: return(0); ! 310: } ! 311: ! 312: /* start editing new .def file */ ! 313: newin() ! 314: { if (userinput("","name of definition to edit: ") || typein[0]==0) ! 315: return(0); ! 316: ! 317: previous = cur_state.curobj; ! 318: cur_state.curobj->recent = cur_state; ! 319: cur_state = read_def(typein)->recent; ! 320: return(REDISPLAY); ! 321: } ! 322: ! 323: /* write out current .def file */ ! 324: newout() ! 325: { if (userinput(cur_state.curobj->name,"name of output file: ")) return(0); ! 326: if (typein[0] == 0) return(0); ! 327: if (strcmp(typein,cur_state.curobj->name) != 0) { ! 328: if (strlen(typein) <= strlen(cur_state.curobj->name)) ! 329: strcpy(cur_state.curobj->name,typein); ! 330: else { ! 331: free(cur_state.curobj->name); ! 332: if ((cur_state.curobj->name = malloc((unsigned) (strlen(typein)+1))) == NULL) { ! 333: msg("out of room!"); ! 334: return(0); ! 335: } ! 336: strcpy(cur_state.curobj->name,typein); ! 337: } ! 338: } ! 339: write_defn(cur_state.curobj); ! 340: banner(); ! 341: return(0); ! 342: } ! 343: ! 344: /* snap cursor to grid */ ! 345: snap() ! 346: { return(remouse(snap_coord(cur_state.curx), ! 347: snap_coord(cur_state.cury), 0)); ! 348: } ! 349: ! 350: snap_coord(coord) ! 351: register int coord; ! 352: { register int mask = ~(cur_state.csize - 1); ! 353: ! 354: coord += cur_state.csize >> 1; ! 355: coord &= mask; ! 356: return(coord); ! 357: } ! 358: ! 359: /* move cursor to the right */ ! 360: mright() ! 361: { return(remouse(cur_state.curx + mult*cur_state.csize, ! 362: cur_state.cury, 0)); ! 363: } ! 364: ! 365: /* move cursor to the left */ ! 366: mleft() ! 367: { return(remouse(cur_state.curx - mult*cur_state.csize, ! 368: cur_state.cury, 0)); ! 369: } ! 370: ! 371: /* move cursor up */ ! 372: mup() ! 373: { return(remouse(cur_state.curx, ! 374: cur_state.cury + mult*cur_state.csize, 0)); ! 375: } ! 376: ! 377: /* move cursor down */ ! 378: mdown() ! 379: { return(remouse(cur_state.curx, ! 380: cur_state.cury - mult*cur_state.csize, 0)); ! 381: } ! 382: ! 383: /* make cursor larger */ ! 384: curup() ! 385: { if (cur_state.csize < 128) cur_state.csize <<= 1; ! 386: return(0); ! 387: } ! 388: ! 389: /* make cursor smaller */ ! 390: curdown() ! 391: { if (cur_state.csize > 1) cur_state.csize >>= 1; ! 392: return(0); ! 393: } ! 394: ! 395: /* multiply multiplier */ ! 396: multiplier() ! 397: { mult <<= 2; ! 398: return(MULTIPLIER); ! 399: } ! 400: ! 401: /* rescale picture */ ! 402: scale() ! 403: { register int ch; ! 404: int in1,in2; ! 405: ! 406: if (userinput("","new scale (screen:defn): ")) return(0); ! 407: ch = sscanf(typein,"%d:%d",&in1,&in2); ! 408: if (ch == 1) { ! 409: cur_state.mscale = in1; ! 410: cur_state.dscale = 1; ! 411: } else if (ch == 2) { ! 412: cur_state.mscale = in1; ! 413: cur_state.dscale = in2; ! 414: } else return(1); ! 415: ! 416: return(RECENTER); ! 417: } ! 418: ! 419: /* Scale picture up/down by factor of +n/-n: ! 420: */ ! 421: ! 422: magnify(n) ! 423: { if (n<0) /* Make it smaller? */ ! 424: { n = -n; ! 425: if ((cur_state.mscale % n) == 0) cur_state.mscale /= n; ! 426: else cur_state.dscale *= n; ! 427: } ! 428: else if (n > 0) ! 429: { if ((cur_state.dscale % n) == 0) cur_state.dscale /= n; ! 430: else cur_state.mscale *= n; ! 431: } ! 432: return RECENTER; ! 433: } ! 434: ! 435: scaleup() ! 436: { return magnify(4); ! 437: } ! 438: scaledn() ! 439: { return magnify(-4); ! 440: } ! 441: ! 442: /* move origin */ ! 443: neworg() ! 444: { adj_org(cur_state.curobj,cur_state.curx,cur_state.cury); ! 445: cur_state.curobj->modified = 1; ! 446: remouse(0, 0, 0); ! 447: return(RECENTER); ! 448: } ! 449: ! 450: /* move cursor to origin */ ! 451: home() ! 452: { remouse(0, 0, 0); ! 453: return(RECENTER); ! 454: } ! 455: ! 456: /* finished editing current picture */ ! 457: stop() ! 458: { deselect(UPDATE+REDISPLAY); ! 459: return(DONE); ! 460: } ! 461: ! 462: /* toggle grid flag */ ! 463: toggle() ! 464: { cur_state.grid ^= 1; ! 465: return(REDISPLAY); ! 466: } ! 467: ! 468: /* get some input from the user, leave in typein array. Return 1 ! 469: * if user aborted, 0 if he thinks there's something worth reading. ! 470: */ ! 471: userinput(seed,cue) ! 472: char *seed,*cue; ! 473: { register int ch; ! 474: register char *p = typein; ! 475: char temp[100],save[100]; ! 476: int curcol,times,mch; ! 477: ! 478: strcpy(typein,seed); ! 479: sprintf(temp,cue); ! 480: prompt = temp; ! 481: curcol = strlen(prompt); ! 482: times = 1; ! 483: mch = mousechanged; ! 484: mousechanged = 0; ! 485: goto redraw; ! 486: ! 487: while (1) { ! 488: if (mousechanged || UserReady()) { ! 489: if (mousechanged) { ! 490: mch = 1; ! 491: mousechanged = 0; ! 492: continue; ! 493: } ! 494: switch (ch = UserChar() & 0xFF) { ! 495: default: times = 1; ! 496: if (ch < ' ' || ch > 0177) { ! 497: Beep(); ! 498: break; ! 499: } ! 500: if (*p == 0) { /* char at end */ ! 501: *p++ = ch; ! 502: *p = 0; ! 503: disp_char(ch,curcol * chrwid,0,0,NORMAL,1); ! 504: curcol += 1; ! 505: break; ! 506: } ! 507: strcpy(save,p); /* insert char */ ! 508: *p++ = ch; ! 509: curcol += 1; ! 510: strcpy(p,save); ! 511: goto redraw; ! 512: ! 513: case 'C'-0100: ! 514: case 'Q'-0100: ! 515: case 'G'-0100: ! 516: prompt = NULL; ! 517: clearprompt(); ! 518: mousechanged = mch; ! 519: return(1); ! 520: ! 521: case 'A'-0100: ! 522: p = typein; ! 523: curcol = strlen(prompt); ! 524: ctldone: times = 1; ! 525: break; ! 526: ! 527: case 'B'-0100: ! 528: case 'H'-0100: ! 529: while (p!=typein && times>0) { ! 530: times -= 1; ! 531: p -= 1; ! 532: curcol -= 1; ! 533: } ! 534: goto ctldone; ! 535: ! 536: case 'D'-0100: ! 537: while (*p && times>0) { ! 538: strcpy(p,p+1); ! 539: times -= 1; ! 540: } ! 541: goto redraw; ! 542: ! 543: case 'E'-0100: ! 544: for (p=prompt, curcol=0; *p; p+=1, curcol+=1); ! 545: for (p = typein; *p; p += 1) curcol += 1; ! 546: goto ctldone; ! 547: ! 548: case 'F'-0100: ! 549: while (*p && times>0) { ! 550: times -= 1; ! 551: p += 1; ! 552: curcol += 1; ! 553: } ! 554: goto ctldone; ! 555: ! 556: case 'K'-0100: ! 557: *p = 0; ! 558: goto redraw; ! 559: ! 560: case 'Y'-0100: ! 561: new_window(&cur_state,cur_state.curx,cur_state.cury); ! 562: case 'L'-0100: ! 563: redisplay(); ! 564: goto redraw; ! 565: ! 566: case 'U'-0100: ! 567: times <<= 2; ! 568: break; ! 569: ! 570: case '\r': ! 571: case '\n': ! 572: case 033: prompt = NULL; ! 573: clearprompt(); ! 574: mousechanged = mch; ! 575: return(0); ! 576: ! 577: case 0177: ! 578: while (p!=typein && times>0) { ! 579: strcpy(p-1,p); ! 580: p -= 1; ! 581: curcol -= 1; ! 582: times -= 1; ! 583: } ! 584: goto redraw; ! 585: ! 586: redraw: msg(prompt); ! 587: incol += disp_str(typein, incol * chrwid, 0, 0, NORMAL,1); ! 588: times = 1; ! 589: break; ! 590: } ! 591: } else { ! 592: incol = curcol; ! 593: DpyUp(1); ! 594: } ! 595: } ! 596: } ! 597: ! 598: /* given center, calculate various window coords */ ! 599: new_window(s,cx,cy) ! 600: register struct state *s; ! 601: { int wx,wy; ! 602: ! 603: /* half-width of window in defn coords */ ! 604: wx = (wmaxx - wminx) >> 1; ! 605: wx *= s->dscale; ! 606: wx /= s->mscale; ! 607: ! 608: /* half-height of window in defn coords */ ! 609: wy = (wmaxy - wminy) >> 1; ! 610: wy *= s->dscale; ! 611: wy /= s->mscale; ! 612: ! 613: s->worgx = cx - wx; ! 614: s->worgy = cy - wy; ! 615: s->wmaxx = cx + wx; ! 616: s->wmaxy = cy + wy; ! 617: } ! 618: ! 619: #define abs(x) ((x) < 0 ? -(x) : (x)) ! 620: ! 621: /* see if an object is "near enough" to the cursor, sets dx, dy, ends */ ! 622: nearby(p) ! 623: register gptr p; ! 624: { switch (p->s.type) { ! 625: case SEGMENT: dx = p->s.x2 - cur_state.curx; ! 626: dy = p->s.y2 - cur_state.cury; ! 627: if (abs(dx) <= cur_state.csize && ! 628: abs(dy) <= cur_state.csize) { ! 629: ends = 2; ! 630: return(1); ! 631: } ! 632: case OBJECT: ! 633: case LABEL: dx = p->s.x1 - cur_state.curx; ! 634: dy = p->s.y1 - cur_state.cury; ! 635: if (abs(dx) <= cur_state.csize && ! 636: abs(dy) <= cur_state.csize) { ! 637: ends = 1; ! 638: return(1); ! 639: } ! 640: break; ! 641: } ! 642: ! 643: return(0); ! 644: } ! 645: ! 646: /* unselect currently selected object: ! 647: * update & UPDATE update object's info ! 648: * + USEOFFSET -- use lxoff, lyoff ! 649: * update & REDISPLAY redisplay when done ! 650: */ ! 651: deselect(update) ! 652: { register gptr p = cur_state.editee; ! 653: register int temp; ! 654: gptr save; ! 655: ! 656: if (p == NULL) return; /* nothing to do */ ! 657: ! 658: if (update & UPDATE) { ! 659: switch (p->s.type) { ! 660: case SEGMENT: if (cur_state.whichend == 2) { ! 661: if (update & USEOFFSET) { ! 662: p->s.x2 += cur_state.lxoff; ! 663: p->s.y2 += cur_state.lyoff; ! 664: } else { ! 665: temp = cur_state.curx + cur_state.xoff; ! 666: cur_state.lxoff = temp - p->s.x2; ! 667: p->s.x2 = temp; ! 668: temp = cur_state.cury + cur_state.yoff; ! 669: cur_state.lyoff = temp - p->s.y2; ! 670: p->s.y2 = temp; ! 671: } ! 672: break; ! 673: }; ! 674: case LABEL: ! 675: case OBJECT: if (update & USEOFFSET) { ! 676: p->s.x1 += cur_state.lxoff; ! 677: p->s.y1 += cur_state.lyoff; ! 678: } else { ! 679: temp = cur_state.curx + cur_state.xoff; ! 680: cur_state.lxoff = temp - p->s.x1; ! 681: p->s.x1 = temp; ! 682: temp = cur_state.cury + cur_state.yoff; ! 683: cur_state.lyoff = temp - p->s.y1; ! 684: p->s.y1 = temp; ! 685: } ! 686: break; ! 687: } ! 688: cur_state.curobj->modified = 1; ! 689: } ! 690: ! 691: if (p->s.type == SEGMENT) newalist(&p->s,p->s.x1,p->s.y1,p->s.x2,p->s.y2); ! 692: ! 693: cur_state.editee = NULL; ! 694: ! 695: /* to update display we only have to redraw selected object */ ! 696: if (update & REDISPLAY) { ! 697: save = p->s.next; ! 698: p->s.next = NULL; ! 699: display(p,0,0,NORTH,1,1,NORMAL); ! 700: p->s.next = save; ! 701: } ! 702: } ! 703: ! 704: /* update database to reflect newly selected object */ ! 705: selectobj(p,new) ! 706: register gptr p; ! 707: { deselect(UPDATE+REDISPLAY); ! 708: cur_state.editee = p; ! 709: cur_state.xoff = 0; ! 710: cur_state.yoff = 0; ! 711: cur_state.whichend = ends; ! 712: if (!new) { ! 713: if (remouse(cur_state.curx+dx, cur_state.cury+dy,1)) { ! 714: new_window(&cur_state,cur_state.curx+dx,cur_state.cury+dy); ! 715: remouse(cur_state.curx, cur_state.cury, 1); ! 716: } ! 717: redisplay(); ! 718: } ! 719: } ! 720: ! 721: /* redisplay entire screen */ ! 722: redisplay() ! 723: { ! 724: clearscreen(); ! 725: if (cur_state.curobj != NULL) { ! 726: display(cur_state.curobj->body,0,0,NORTH,1,1,NORMAL); ! 727: ctext("*",0,0,CC,NORMAL); ! 728: } ! 729: ! 730: /* grid points fall every csize points */ ! 731: if (cur_state.grid) disp_grid(); ! 732: ! 733: return(0); /* return code when used as a command */ ! 734: } ! 735: ! 736: /* return appropriately oriented x and y coords */ ! 737: xorient(x,y,orient) ! 738: { switch (orient) { ! 739: case NORTH: return(x); ! 740: case EAST: return(y); ! 741: case SOUTH: return(-x); ! 742: case WEST: return(-y); ! 743: case RNORTH: return(-x); ! 744: case REAST: return(-y); ! 745: case RSOUTH: return(x); ! 746: case RWEST: return(y); ! 747: } ! 748: /*NOTREACHED*/ ! 749: } ! 750: ! 751: yorient(x,y,orient) ! 752: { switch (orient) { ! 753: case NORTH: return(y); ! 754: case EAST: return(-x); ! 755: case SOUTH: return(-y); ! 756: case WEST: return(x); ! 757: case RNORTH: return(y); ! 758: case REAST: return(-x); ! 759: case RSOUTH: return(-y); ! 760: case RWEST: return(x); ! 761: } ! 762: /*NOTREACHED*/ ! 763: } ! 764: ! 765: /* display objects with specified translation and rotation */ ! 766: display(o,x,y,orient,mscale,dscale,dflag) ! 767: register gptr o; ! 768: { short tx,ty; ! 769: short ex,ey; ! 770: ! 771: while (o != NULL) { ! 772: tx = xorient(o->l.x, o->l.y, orient); ! 773: tx *= mscale; tx /= dscale; ! 774: tx += x; ! 775: ty = yorient(o->l.x, o->l.y, orient); ! 776: ty *= mscale; ty /= dscale; ! 777: ty += y; ! 778: ! 779: if (cur_state.editee != o) switch (o->s.type) { ! 780: case LABEL: ! 781: ctext(o->l.string,tx,ty,lcomp[orient][o->l.orient],dflag); ! 782: break; ! 783: ! 784: case OBJECT: ! 785: display(o->o.proto->body,tx,ty, ! 786: ocomp[orient][o->o.orient], ! 787: mscale * o->o.mscale, dscale * o->o.dscale, ! 788: dflag); ! 789: break; ! 790: ! 791: case SEGMENT: ! 792: if (o->s.cache != NULL) { ! 793: display(o->s.cache,x,y,orient,mscale,dscale,dflag); ! 794: break; ! 795: } ! 796: ex = xorient(o->s.x2, o->s.y2, orient); ! 797: ex *= mscale; ex /= dscale; ! 798: ex += x; ! 799: ey = yorient(o->s.x2, o->s.y2, orient); ! 800: ey *= mscale; ey /= dscale; ! 801: ey += y; ! 802: cline(tx,ty,ex,ey,dflag); ! 803: break; ! 804: } ! 805: o = o->s.next; ! 806: } ! 807: } ! 808: ! 809: /* output a message on the bottom-most line */ ! 810: msg(string) ! 811: char *string; ! 812: { ! 813: clearprompt(); ! 814: incol += disp_str(string, incol * chrwid, 0, 0, NORMAL,1); ! 815: } ! 816: ! 817: /* display text string with proper orientation clipped by current window */ ! 818: ctext(string,x,y,orient,dflag) ! 819: register char *string; ! 820: { register int i = (strlen(string) * chrwid) >> 1; ! 821: ! 822: /* first translate and scale to the window coord system */ ! 823: y -= cur_state.worgy; ! 824: x -= cur_state.worgx; ! 825: ! 826: y *= cur_state.mscale; y /= cur_state.dscale; ! 827: x *= cur_state.mscale; x /= cur_state.dscale; ! 828: ! 829: /* adjust for character orientation */ ! 830: switch (orient) { ! 831: case CC: x -= i; y -= (chrhgt >> 1); break; ! 832: case TC: x -= i; y -= chrhgt; break; ! 833: case BC: x -= i; break; ! 834: case CL: y -= (chrhgt >> 1); break; ! 835: case TL: y -= chrhgt; break; ! 836: case BL: break; ! 837: case CR: x -= i+i; y -= (chrhgt >> 1); break; ! 838: case TR: x -= i+i; y -= chrhgt; break; ! 839: case BR: x -= i+i; ! 840: } ! 841: ! 842: /* only display chars that lie within current window */ ! 843: x += wminx; ! 844: y += wminy; ! 845: if (y <= wmaxy && y+chrhgt >= wminy && ! 846: x <= wmaxx && x+(strlen(string)*chrwid) >= wminx) ! 847: disp_str(string,x,y,0,dflag,0); ! 848: } ! 849: ! 850: /* draw a clipped vector */ ! 851: #define code(x,y) \ ! 852: ((x<wminx ? 1 : x>wmaxx ? 2 : 0) + (y<wminy ? 4 : y>wmaxy ? 8 : 0)) ! 853: ! 854: cline(fx,fy,tx,ty,dflag) ! 855: { ! 856: ! 857: /* first translate and scale to the window coord system */ ! 858: fx -= cur_state.worgx; ! 859: fy -= cur_state.worgy; ! 860: tx -= cur_state.worgx; ! 861: ty -= cur_state.worgy; ! 862: ! 863: fy *= cur_state.mscale; fy /= cur_state.dscale; ! 864: fx *= cur_state.mscale; fx /= cur_state.dscale; ! 865: ty *= cur_state.mscale; ty /= cur_state.dscale; ! 866: tx *= cur_state.mscale; tx /= cur_state.dscale; ! 867: ! 868: fx += wminx; fy += wminy; ! 869: tx += wminx; ty += wminy; ! 870: ! 871: if ((code(fx,fy) & code(tx,ty)) == 0) ! 872: line(fx,fy,tx,ty,dflag); ! 873: } ! 874: ! 875: /* display grid points at csize intervals */ ! 876: disp_grid() ! 877: { int x,y,incrx,incry; ! 878: ! 879: /* find window coord of lower left grid point */ ! 880: x = cur_state.worgx + cur_state.csize - 1; ! 881: x &= ~(cur_state.csize - 1); ! 882: x -= cur_state.worgx; ! 883: x *= cur_state.mscale; x /= cur_state.dscale; ! 884: ! 885: y = cur_state.worgy + cur_state.csize - 1; ! 886: y &= ~(cur_state.csize - 1); ! 887: y -= cur_state.worgy; ! 888: y *= cur_state.mscale; y /= cur_state.dscale; ! 889: ! 890: x += wminx; ! 891: y = wmaxy - y - wminy; ! 892: ! 893: incrx = (cur_state.csize * cur_state.mscale) / cur_state.dscale; ! 894: if (incrx <= 0) incrx = 8; ! 895: else while (incrx < 8) incrx <<= 1; ! 896: incry = incrx; ! 897: ! 898: drawgrid(x,y,incrx,incry); ! 899: } ! 900: ! 901: /* Xor drawing cursor and selected object */ ! 902: dcurxor() ! 903: { register gptr p; ! 904: int x,y; ! 905: ! 906: if (cur_state.curobj == NULL) return; /* no object on screen */ ! 907: ! 908: if ((p = cur_state.editee) != NULL) { ! 909: if (p->s.type == SEGMENT && (redo || (p->s.angle != 0 && ! 910: (cur_state.curx!=cur_state.oldx || ! 911: cur_state.cury!=cur_state.oldy)))) { ! 912: cur_state.oldx = cur_state.curx; ! 913: cur_state.oldy = cur_state.cury; ! 914: redo = 0; ! 915: if (cur_state.whichend == 2) ! 916: newalist(&p->s,p->s.x1,p->s.y1, ! 917: cur_state.curx + cur_state.xoff, ! 918: cur_state.cury + cur_state.yoff); ! 919: else ! 920: newalist(&p->s,cur_state.curx + cur_state.xoff, ! 921: cur_state.cury + cur_state.yoff, ! 922: p->s.x2,p->s.y2); ! 923: } ! 924: switch(p->s.type) { ! 925: case SEGMENT: ! 926: if (p->s.cache != NULL) { ! 927: for (p = p->s.cache; p != NULL; p = p->s.next) ! 928: cline(p->s.x1,p->s.y1,p->s.x2,p->s.y2,HIGHLIGHT); ! 929: break; ! 930: } ! 931: if (cur_state.whichend == 2) { x = p->s.x1; y = p->s.y1; } ! 932: else { x = p->s.x2; y = p->s.y2; } ! 933: cline(x,y, ! 934: cur_state.curx + cur_state.xoff, ! 935: cur_state.cury + cur_state.yoff,HIGHLIGHT); ! 936: break; ! 937: ! 938: case LABEL: ! 939: ctext(p->l.string, ! 940: cur_state.curx + cur_state.xoff, ! 941: cur_state.cury + cur_state.yoff, ! 942: p->l.orient, ! 943: HIGHLIGHT); ! 944: break; ! 945: ! 946: case OBJECT: ! 947: display(p->o.proto->body, ! 948: cur_state.curx + cur_state.xoff, ! 949: cur_state.cury + cur_state.yoff, ! 950: p->o.orient,p->o.mscale,p->o.dscale, ! 951: HIGHLIGHT); ! 952: return; /* no cursor needed here */ ! 953: } ! 954: } ! 955: ! 956: /* draw x-shaped graphic cursor */ ! 957: cline(cur_state.curx - cur_state.csize, ! 958: cur_state.cury - cur_state.csize, ! 959: cur_state.curx + cur_state.csize, ! 960: cur_state.cury + cur_state.csize, ! 961: HIGHLIGHT); ! 962: cline(cur_state.curx - cur_state.csize, ! 963: cur_state.cury + cur_state.csize, ! 964: cur_state.curx + cur_state.csize, ! 965: cur_state.cury - cur_state.csize, ! 966: HIGHLIGHT); ! 967: } ! 968: ! 969: /* Help stuff */ ! 970: Help() ! 971: { struct prototype *help_proto; ! 972: char buf[100]; ! 973: ! 974: help_proto = read_def(HELPFILE); /* Load the file, if any. */ ! 975: ! 976: if (help_proto->body == NULL) { ! 977: sprintf(buf, "Can't read '%s.DEF' -- NO HELP", HELPFILE); ! 978: msg(buf); ! 979: return 0; ! 980: } ! 981: previous = cur_state.curobj; ! 982: if (cur_state.curobj) cur_state.curobj->recent = cur_state; ! 983: cur_state = help_proto->recent; ! 984: return REDISPLAY; ! 985: } ! 986: ! 987: /* Adjust coordinates in body of an object by the origin of that object. ! 988: * This routine is called after an object is edited, so that an adjusted ! 989: * subpicture origin is reflected immediately in pictures which reference ! 990: * it. ! 991: */ ! 992: adj_org(p,adjx,adjy) ! 993: register struct prototype *p; ! 994: { register gptr o; ! 995: struct prototype temp; ! 996: ! 997: for (o = p->body; o != NULL; o = o->s.next) switch (o->s.type) { ! 998: case SEGMENT: o->s.x1 -= adjx; ! 999: o->s.y1 -= adjy; ! 1000: o->s.x2 -= adjx; ! 1001: o->s.y2 -= adjy; ! 1002: if (o->s.cache) { ! 1003: temp.body = o->s.cache; ! 1004: adj_org(&temp,adjx,adjy); ! 1005: } ! 1006: break; ! 1007: ! 1008: case LABEL: o->l.x -= adjx; ! 1009: o->l.y -= adjy; ! 1010: break; ! 1011: ! 1012: case OBJECT: o->o.x -= adjx; ! 1013: o->o.y -= adjy; ! 1014: break; ! 1015: } ! 1016: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.