![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to icon.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / cmd|
Return to icon.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / cmd |
1.1 root 1: #define bool int
2: #define true 1
3: #define false 0
4:
5: #define NOHIT -1
6:
7: #define I_NULL -1
8: #define I_OR 0
9: #define I_STORE 1
10: #define I_CLR 2
11: #define I_XOR 3
12: #define I_AND 4
13:
14: #include "jerq.h"
15: #include <stdio.h>
16:
17: #define SPACING 24
18:
19: #define sgn(x) ((x)<0 ? -1 : (x)==0 ? 0 : 1)
20:
21: int XSIZE = 50, YSIZE = 50;
22:
23: int horsize(r)
24: Rectangle r;
25: {
26: return(r.corner.x - r.origin.x);
27: }
28:
29: int versize(r)
30: Rectangle r;
31: {
32: return(r.corner.y - r.origin.y);
33: }
34:
35: extern Texture *(imenu[]);
36:
37: int lasthitx = 0, lasthity = 0;
38: #define SRC_ID 0
39: #define SRC_CLR 1
40: char *blitsrctext[] =
41: {"src := src","src := 0",NULL};
42:
43: #define DST_STORE 0
44: #define DST_OR 1
45: #define DST_XOR 2
46: #define DST_AND 3
47: #define DST_CLR 4
48:
49: char *blitdsttext[] =
50: {"dst := src","dst := src or dst","dst := src xor dst","dst := src and dst","dst := 0",NULL};
51:
52: Menu blitsrcmenu = {blitsrctext};
53: Menu blitdstmenu = {blitdsttext};
54:
55: short Cmove_bits[] = {
56: 0x0000, 0x0000, 0x00C0, 0x00E0,
57: 0x00F0, 0x7FF8, 0x7FDC, 0x600E,
58: 0x6007, 0x600E, 0x7FDC, 0x7FF8,
59: 0x00F0, 0x00E0, 0x00C0, 0x0000,
60: };
61: Texture Cmove;
62:
63: short Ccopy_bits[] = {
64: 0x0000, 0x7FE0, 0x4020, 0x4020,
65: 0x473F, 0x4FA1, 0x4DA1, 0x4C39,
66: 0x4FBD, 0x472D, 0x4021, 0x403D,
67: 0x7FF9, 0x0201, 0x0201, 0x03FF,
68: };
69: Texture Ccopy;
70:
71: short Cerase_bits[] = {
72: 0x03FE, 0x0556, 0x0556, 0x0AAE,
73: 0x0AAE, 0x1FFC, 0x101C, 0x2028,
74: 0x2028, 0x4050, 0x4050, 0xFFA0,
75: 0x80A0, 0x80C0, 0x80C0, 0xFF80,
76: };
77: Texture Cerase;
78:
79: short Cinvert_bits[] = {
80: 0x0000, 0x0000, 0x07C0, 0x07C0,
81: 0x07C0, 0x07C0, 0x07C0, 0x783C,
82: 0x783C, 0x783C, 0x07C0, 0x07C0,
83: 0x07C0, 0x07C0, 0x07C0, 0x0000,
84: };
85: Texture Cinvert;
86:
87: short Cblit_bits[] = {
88: 0x0000, 0x7FE0, 0x4020, 0x4020,
89: 0x403F, 0x4021, 0x4021, 0x4021,
90: 0x4021, 0x4021, 0x4021, 0x4021,
91: 0x7FE1, 0x0201, 0x0201, 0x03FF,
92: };
93: Texture Cblit;
94:
95: short Creflx_bits[] = {
96: 0x0000, 0x0000, 0x7FFE, 0x8001,
97: 0x8011, 0xC033, 0xBC5D, 0x8781,
98: 0x8501, 0x8501, 0x4482, 0x3C5C,
99: 0x0030, 0x0010, 0x0000, 0x0000,
100: };
101: Texture Creflx;
102:
103: short Crefly_bits[] = {
104: 0x03F8, 0x0424, 0x0844, 0x0844,
105: 0x0844, 0x0FC4, 0x0084, 0x0384,
106: 0x0484, 0x0844, 0x1024, 0x3874,
107: 0x0844, 0x0844, 0x0424, 0x03F8,
108: };
109: Texture Crefly;
110:
111: short Crotplus_bits[] = {
112: 0x0000, 0x0000, 0x3FE0, 0x2010,
113: 0x2008, 0x2008, 0x2008, 0x3F08,
114: 0x0108, 0x0108, 0x070E, 0x0204,
115: 0x0108, 0x0090, 0x0060, 0x0000,
116: };
117: Texture Crotplus;
118:
119: short Crotminus_bits[] = {
120: 0x0000, 0x0400, 0x0C00, 0x17F0,
121: 0x2008, 0x4004, 0x4004, 0x2004,
122: 0x1784, 0x0C84, 0x0484, 0x0084,
123: 0x0084, 0x00FC, 0x0000, 0x0000,
124: };
125: Texture Crotminus;
126:
127: short Cshearx_bits[] = {
128: 0x0000, 0x0000, 0x0000, 0x0000,
129: 0x0000, 0x03FF, 0x0000, 0x0FFC,
130: 0x0000, 0x3FF0, 0x0000, 0xFFC0,
131: 0x0000, 0x0000, 0x0000, 0x0000,
132: };
133: Texture Cshearx;
134:
135: short Csheary_bits[] = {
136: 0x0800, 0x0800, 0x0A00, 0x0A00,
137: 0x0A80, 0x0A80, 0x0AA0, 0x0AA0,
138: 0x0AA0, 0x0AA0, 0x02A0, 0x02A0,
139: 0x00A0, 0x00A0, 0x0020, 0x0020,
140: };
141: Texture Csheary;
142:
143: short Cstretch_bits[] = {
144: 0x0000, 0x7CAA, 0x7CAA, 0x7CAA,
145: 0x7CAA, 0x7CAA, 0x0000, 0x0000,
146: 0x7CAA, 0x0000, 0x7CAA, 0x0000,
147: 0x7CAA, 0x0000, 0x7CAA, 0x0000,
148: };
149: Texture Cstretch;
150:
151: short Ctexture_bits[] = {
152: 0x4000, 0x7000, 0xE000, 0x2000,
153: 0x0444, 0x0777, 0x0EEE, 0x0222,
154: 0x0444, 0x0777, 0x0EEE, 0x0222,
155: 0x0444, 0x0777, 0x0EEE, 0x0222,
156: };
157: Texture Ctexture;
158:
159: short Cgrid_bits[] = {
160: 0x4040, 0xFFFF, 0x4040, 0x4444,
161: 0x4040, 0x5555, 0x4040, 0x4444,
162: 0x4040, 0xFFFF, 0x4040, 0x4444,
163: 0x4040, 0x5555, 0x4040, 0x4444,
164: };
165: Texture Cgrid;
166:
167: short Ccursor_bits[] = {
168: 0x0000, 0x0000, 0x03E0, 0x17F0,
169: 0x3FF0, 0x5FFE, 0xFFF1, 0x0421,
170: 0x0002, 0x00FC, 0x0100, 0x0080,
171: 0x0040, 0x0080, 0x0000, 0x0000,
172: };
173: Texture Ccursor;
174:
175: short Cread_bits[] = {
176: 0x0000, 0x0FFE, 0x1FFA, 0x1811,
177: 0x0021, 0x8021, 0xC061, 0xC1F1,
178: 0x622A, 0x3414, 0x1810, 0x0810,
179: 0x0420, 0x03C0, 0x0000, 0x0000,
180: };
181: Texture Cread;
182:
183: short Cwrite_bits[] = {
184: 0xF000, 0xFC00, 0x6B00, 0x3580,
185: 0x12C0, 0x1960, 0x0CA0, 0x06B0,
186: 0x0250, 0x0358, 0x01A8, 0x00D8,
187: 0x0074, 0x101C, 0xBB06, 0xEEFB,
188: };
189: Texture Cwrite;
190:
191: short Cresize_bits[] = {
192: 0xFF54, 0x8100, 0x8104, 0x8100,
193: 0x8104, 0x8100, 0x8104, 0xFF00,
194: 0x0004, 0x8000, 0x0014, 0x8038,
195: 0x001D, 0xAAAF, 0x0007, 0x000F,
196: };
197: Texture Cresize;
198:
199: short Chelp_bits[] = {
200: 0x0000, 0x0000, 0x0000, 0x0000,
201: 0xE0E0, 0x6060, 0x7F7E, 0x7DFF,
202: 0x6FFB, 0x6C7B, 0x6FFE, 0xFFF8,
203: 0x003C, 0x0000, 0x0000, 0x0000,
204: };
205: Texture Chelp;
206:
207: short Cundo_bits[] = {
208: 0x001C, 0x0022, 0x0041, 0x0081,
209: 0x0101, 0x0282, 0x0544, 0x0AA8,
210: 0x1550, 0x22A0, 0x4140, 0x8080,
211: 0x8100, 0x8200, 0x4400, 0x3800,
212: };
213: Texture Cundo;
214:
215: short white_bits[] = {
216: 0x0000, 0x0000, 0x0000, 0x0000,
217: 0x0000, 0x0000, 0x0000, 0x0000,
218: 0x0000, 0x0000, 0x0000, 0x0000,
219: 0x0000, 0x0000, 0x0000, 0x0000,
220: };
221: Cursor white;
222: Texture whiteT;
223:
224: short menucursor_bits[] = {
225: 0xFFC0, 0x8040, 0x8040, 0x8040,
226: 0xFFC0, 0xFFC0, 0xFE00, 0xFEF0,
227: 0x80E0, 0x80F0, 0x80B8, 0xFE1C,
228: 0x800E, 0x8047, 0x8042, 0xFFC0,
229: };
230: Cursor menucursor;
231: Texture menucursorT;
232:
233: short sweepcursor_bits[] = {
234: 0x43FF, 0xE001, 0x7001, 0x3801,
235: 0x1D01, 0x0F01, 0x8701, 0x8F01,
236: 0x8001, 0x8001, 0x8001, 0x8001,
237: 0x8001, 0x8001, 0x8001, 0xFFFF,
238: };
239: Cursor sweepcursor;
240: Texture sweepcursorT;
241:
242: short sweeportrack_bits[] = {
243: 0x43FF, 0xE001, 0x70FD, 0x3805,
244: 0x1D05, 0x0F05, 0x8705, 0x8F05,
245: 0xA005, 0xA005, 0xA005, 0xA005,
246: 0xA005, 0xBFFD, 0x8001, 0xFFFF,
247: };
248: Cursor sweeportrack;
249: Texture sweeportrackT;
250:
251: short clock_bits[] = {
252: 0x03C0, 0x3420, 0x37E0, 0x13C0,
253: 0x17F0, 0x1828, 0x2054, 0x20D4,
254: 0x418A, 0x430A, 0x430A, 0x418A,
255: 0x2094, 0x201C, 0x787E, 0x67F6,
256: };
257: Cursor clock;
258: Texture clockT;
259:
260: short deadmouse_bits[] = {
261: 0x0000, 0x0000, 0x0008, 0x0004,
262: 0x0082, 0x0441, 0xFFE1, 0x5FF1,
263: 0x3FFE, 0x17F0, 0x03E0, 0x0000,
264: 0x0000, 0x0000, 0x0000, 0x0000,
265: };
266: Cursor deadmouse;
267: Texture deadmouseT;
268:
269: initicons()
270: {
271: Cmove = ToTexture(Cmove_bits);
272: Ccopy = ToTexture(Ccopy_bits);
273: Cerase = ToTexture(Cerase_bits);
274: Cinvert = ToTexture(Cinvert_bits);
275: Cblit = ToTexture(Cblit_bits);
276: Creflx = ToTexture(Creflx_bits);
277: Crefly = ToTexture(Crefly_bits);
278: Crotplus = ToTexture(Crotplus_bits);
279: Crotminus = ToTexture(Crotminus_bits);
280: Cshearx = ToTexture(Cshearx_bits);
281: Csheary = ToTexture(Csheary_bits);
282: Cstretch = ToTexture(Cstretch_bits);
283: Ctexture = ToTexture(Ctexture_bits);
284: Cgrid = ToTexture(Cgrid_bits);
285: Ccursor = ToTexture(Ccursor_bits);
286: Cread = ToTexture(Cread_bits);
287: Cwrite = ToTexture(Cwrite_bits);
288: Cresize = ToTexture(Cresize_bits);
289: Chelp = ToTexture(Chelp_bits);
290: Cundo = ToTexture(Cundo_bits);
291: whiteT = ToTexture(white_bits);
292: white = ToCursor(white_bits, white_bits, 7, 7);
293: menucursorT = ToTexture(menucursor_bits);
294: menucursor = ToCursor(menucursor_bits, menucursor_bits, 7, 7);
295: sweepcursorT = ToTexture(sweepcursor_bits);
296: sweepcursor = ToCursor(sweepcursor_bits, sweepcursor_bits, 7, 7);
297: sweeportrackT = ToTexture(sweeportrack_bits);
298: sweeportrack = ToCursor(sweeportrack_bits, sweeportrack_bits, 7, 7);
299: clockT = ToTexture(clock_bits);
300: clock = ToCursor(clock_bits, clock_bits, 7, 7);
301: deadmouseT = ToTexture(deadmouse_bits);
302: deadmouse = ToCursor(deadmouse_bits, deadmouse_bits, 7, 7);
303: }
304:
305: #define MOVE 0
306: #define COPY 1
307: #define INVERT 2
308: #define ERASE 3
309:
310: #define REFLECTX 5
311: #define REFLECTY 6
312: #define ROTATEPLUS 7
313: #define ROTATEMINUS 8
314:
315: #define SHEARX 10
316: #define SHEARY 11
317: #define STRETCH 12
318: #define TEXTURE 13
319:
320: #define READ 15
321: #define GRID 16
322: #define RESIZE 17
323: #define WRITE 18
324:
325: #define BLIT 20
326: #define PICK 21
327: #define HELP 22
328: #define UNDO 23
329:
330: Texture *(imenu[]) =
331: {&Cmove,&Ccopy,&Cinvert,&Cerase,0,
332: &Creflx,&Crefly,&Crotplus,&Crotminus,0,
333: &Cshearx,&Csheary,&Cstretch,&Ctexture,0,
334: &Cread,&Cgrid,&Cresize,&Cwrite,0,
335: &Cblit,&Ccursor,&Chelp,&Cundo,0,
336: 0,0,0,0
337: };
338:
339:
340: char exa[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
341: char buf[100],FNAME[50];
342: Point nullpoint, point16x16;
343: Rectangle icon, ICON, sweep, outl, nullrect, rect16x16;
344: int Xsize,Ysize;
345: int Xblocks,Yblocks;
346: int modx,divx,mody,divy;
347:
348: flipring(p)
349: Point p;
350: {
351: outline(&display,raddp(Rect(1,1,SPACING-2,SPACING-2),p));
352: outline(&display,raddp(Rect(2,2,SPACING-3,SPACING-3),p));
353: }
354:
355: drawimenu(xicons,yicons,r)
356: Rectangle r;
357: {
358: Bitmap *textr;
359: int i,j;
360: rectf(&display,r,F_CLR);
361: outline(&display,Rpt(r.origin,sub(r.corner,Pt(1,1))));
362: textr = balloc(Rect(0,0,16,16));
363: if (textr == ((Bitmap *) 0)) return(0);
364: for (j=0; j<yicons; j++) {
365: for (i=0; i<xicons; i++) {
366: texture(textr,textr->rect,imenu[j*(xicons+1)+i],F_STORE);
367: bitblt(textr,textr->rect,
368: &display,
369: add(r.origin,Pt(i*SPACING+(SPACING-16)/2,j*SPACING+(SPACING-16)/2)),
370: F_OR);
371: }
372: }
373: bfree(textr);
374: }
375:
376: Point imenuhit()
377: {
378: Bitmap *offscreen;
379: Point ms,valley,diff,result,menudrift;
380: Rectangle menurect;
381: Cursor *oldcursor;
382: int i,j,hitx,hity, ohitx,ohity;
383: int xicons,yicons;
384: oldcursor = cursswitch(&white);
385: xicons = 0;
386: for (j=0; imenu[xicons*j]; j++) {
387: for (i=0; imenu[xicons*j+i]; i++);
388: i++;
389: xicons = i;
390: }
391: xicons -= 1;
392: yicons = j;
393: /* while (!button3()) wait(MOUSE); */
394: ms = mouse.xy;
395: menurect = raddp(Rect(0,0,SPACING*xicons,SPACING*yicons),ms);
396: menurect = rsubp(menurect,Pt(SPACING*lasthitx,SPACING*lasthity));
397: menudrift.x = min(menurect.corner.x,Drect.corner.x);
398: menudrift.y = min(menurect.corner.y,Drect.corner.y);
399: menudrift = sub(menudrift,menurect.corner);
400: menurect = raddp(menurect,menudrift); cursset(ms=add(ms,menudrift));
401: menudrift.x = max(menurect.origin.x,Drect.origin.x);
402: menudrift.y = max(menurect.origin.y,Drect.origin.y);
403: menudrift = sub(menudrift,menurect.origin);
404: menurect = raddp(menurect,menudrift); cursset(add(ms,menudrift));
405: offscreen = balloc(menurect);
406: if (offscreen != ((Bitmap *) 0)) {
407: bitblt(&display,menurect,offscreen,offscreen->rect.origin,F_STORE);
408: }
409: drawimenu(xicons,yicons,menurect);
410: hitx = hity = -1;
411: while (button3()) {
412: jnap(1);
413: ms = mouse.xy;
414: ohitx = hitx; ohity = hity;
415: if (ptinrect(ms,menurect)) {
416: lasthitx = hitx = (ms.x-menurect.origin.x)/SPACING;
417: lasthity = hity = (ms.y-menurect.origin.y)/SPACING;
418: } else hitx = hity = -1;
419: if (hitx == -1) {
420: if (ohitx != -1) {
421: flipring(valley);
422: cursswitch(oldcursor);
423: }
424: continue;
425: }
426: if (ohitx == -1) {
427: cursswitch(&white);
428: valley = add(menurect.origin,Pt(SPACING*hitx,SPACING*hity));
429: flipring(valley);
430: } else if (ohitx != hitx || ohity != hity){
431: flipring(valley);
432: valley = add(menurect.origin,Pt(SPACING*hitx,SPACING*hity));
433: flipring(valley);
434: }
435: }
436: if (offscreen != ((Bitmap *) 0)) {
437: bitblt(offscreen,offscreen->rect,&display,menurect.origin,F_STORE);
438: bfree(offscreen);
439: }
440: result.x = hitx;
441: result.y = hity;
442: cursswitch(oldcursor);
443: return(result);
444: }
445:
446: Rectangle canonrect(p1, p2)
447: Point p1, p2;
448: {
449: Rectangle r;
450: r.origin.x = min(p1.x, p2.x);
451: r.origin.y = min(p1.y, p2.y);
452: r.corner.x = max(p1.x, p2.x);
453: r.corner.y = max(p1.y, p2.y);
454: return(r);
455: }
456:
457: int pttopt(p,q)
458: /* manhattan topology distance between two points */
459: Point p,q;
460: {
461: return(abs(p.x-q.x)+abs(p.y-q.y));
462: }
463:
464: Point nearestcorner(r,p)
465: Rectangle r;
466: Point p;
467: {
468: int mindist,dist;
469: Point minq,q;
470: q = r.origin;
471: mindist = pttopt(p,q); minq = q;
472: q.x = r.origin.x; q.y = r.corner.y;
473: if ((dist = pttopt(p,q))<mindist) {mindist = dist; minq = q;}
474: q = r.corner;
475: if ((dist = pttopt(p,q))<mindist) {mindist = dist; minq = q;}
476: q.x = r.corner.x; q.y = r.origin.y;
477: if ((dist = pttopt(p,q))<mindist) {mindist = dist; minq = q;}
478: return(minq);
479: }
480:
481: outline(b,r)
482: Bitmap *b;
483: Rectangle r;
484: {
485: rectf(b,Rect(r.origin.x,r.origin.y,r.origin.x+1,r.corner.y),F_XOR);
486: rectf(b,Rect(r.origin.x,r.corner.y,r.corner.x,r.corner.y+1),F_XOR);
487: rectf(b,Rect(r.corner.x,r.origin.y+1,r.corner.x+1,r.corner.y+1),F_XOR);
488: rectf(b,Rect(r.origin.x+1,r.origin.y,r.corner.x+1,r.origin.y+1),F_XOR);
489: }
490:
491: Border(r)
492: Rectangle r;
493: {
494: outline(&display,inset(r,1));
495: outline(&display,inset(r,-1));
496: }
497:
498: Rectangle sweeprect()
499: {
500: Rectangle r;
501: Point p1, p2;
502: Cursor *oldcursor;
503: oldcursor = cursswitch(&sweepcursor);
504: while (!button123()) wait(MOUSE);
505: p1=mouse.xy;
506: p2=p1;
507: r=canonrect(p1, p2);
508: outline(&display,r);
509: for(; button3(); nap(2)){
510: outline(&display,r);
511: p2=mouse.xy;
512: r=canonrect(p1, p2);
513: outline(&display,r);
514: }
515: outline(&display,r);
516: cursswitch(oldcursor);
517: return r;
518: }
519:
520: bool getr(cliprect,sweep)
521: Rectangle cliprect;
522: Rectangle *sweep;
523: {
524: int j;
525: *sweep = sweeprect();
526: return(rectclip(sweep,cliprect));
527: }
528:
529: Point IconPoint(p)
530: /* convert screen coord to icon coord */
531: Point p;
532: {
533: p.x = (p.x+Xsize-modx)/Xsize - divx - 1;
534: p.y = (p.y+Ysize-mody)/Ysize - divy - 1;
535: return(p);
536: }
537:
538: short IconCoordX(x)
539: short x;
540: {
541: return((x+Xsize-modx)/Xsize - divx - 1);
542: }
543:
544: short IconCoordY(y)
545: short y;
546: {
547: return((y+Ysize-mody)/Ysize - divy - 1);
548: }
549:
550: Point ScreenPoint(p)
551: /* convert icon coord to screen coord */
552: Point p;
553: {
554: p.x = p.x*Xsize + ICON.origin.x;
555: p.y = p.y*Ysize + ICON.origin.y;
556: return(p);
557: }
558:
559: short ScreenCoordX(x)
560: short x;
561: {
562: return(x*Xsize + ICON.origin.x);
563: }
564:
565: short ScreenCoordY(y)
566: short y;
567: {
568: return(y*Ysize + ICON.origin.y);
569: }
570:
571:
572: Rectangle IconRect(r)
573: /* convert a screen rectangle to the biggest totally contained icon rectangle */
574: Rectangle r;
575: {
576: r.origin = IconPoint(add(r.origin,Pt(Xsize-1,Ysize-1)));
577: r.corner = IconPoint(r.corner);
578: if (horsize(r)<0) r.origin.x = r.corner.x;
579: if (versize(r)<0) r.origin.y = r.corner.y;
580: return(r);
581: }
582:
583: Rectangle TrackBorder(r,buttonup)
584: /* tracks a rectangle "r" (in icon coords) and returns it as it is
585: at the end of tracking, clipped to the icon */
586: Rectangle r;
587: bool buttonup;
588: {
589: Point newP, oldP;
590: Cursor *oldcursor;
591: oldcursor = cursswitch(&white);
592: outl.origin = nullpoint;
593: outl.corner.x = horsize(r)*Xsize;
594: outl.corner.y = versize(r)*Ysize;
595: newP = ScreenPoint(r.origin);
596: while (buttonup?(button123()):(!button123()))
597: wait(MOUSE);
598: cursset(newP);
599: oldP = newP;
600: Border(raddp(outl,newP));
601: while (buttonup?(!button123()):(button123())) {
602: wait(MOUSE);
603: newP = ScreenPoint(IconPoint(mouse.xy));
604: if (!eqpt(newP,oldP)) {
605: Border(raddp(outl,oldP));
606: Border(raddp(outl,newP));
607: oldP = newP;
608: }
609: }
610: Border(raddp(outl,newP));
611: cursswitch(oldcursor);
612: return(IconRect(raddp(outl,newP)));
613: }
614:
615: bool SweepIconRect(r)
616: Rectangle *r;
617: {
618: Point p;
619: if (!getr(ICON,&sweep)) return(false);
620: *r = IconRect(sweep);
621: if ((horsize(*r)==0) || (versize(*r)==0)) return(false);
622: return(true);
623: }
624:
625: int GetIconRect(r)
626: /* returns: 0 if no rectangle is provided;
627: 2 if button2 is used (tracking a 16x16 rectangle);
628: 3 if button3 is used (sweeping a rectangle);
629: if a rectangle is provided, r returns it in icon coordinates */
630: Rectangle *r;
631: {
632: int result;
633: Cursor *oldcursor;
634: oldcursor = cursswitch(&sweeportrack);
635: while (!button123()) wait(MOUSE);
636: if (button3()) {
637: if (SweepIconRect(r)) result = 3;
638: else result = 0;
639: } else if (button2()) {
640: *r = TrackBorder(raddp(rect16x16,add(IconPoint(mouse.xy),Pt(1,1))),false);
641: result = 2;
642: } else {while(button1())jnap(1); result = 0;}
643: cursswitch(oldcursor);
644: return(result);
645: }
646:
647: bool GetIconPoint(p)
648: Point *p;
649: {
650: Rectangle r;
651: r = TrackBorder(raddp(Rect(0,0,1,1),IconPoint(mouse.xy)),true);
652: while (button123())jnap(1);
653: *p = r.origin;
654: return((horsize(r) == 1) && (versize(r) == 1));
655: }
656:
657: Bitmap *bittester;
658:
659: bool bitmapbit(b,p)
660: Bitmap *b;
661: Point p;
662: {
663: if (!(ptinrect(p,b->rect))) return(false);
664: return (getpoint(b,p));
665: }
666:
667: char getnibble(b,p)
668: Bitmap *b;
669: Point p;
670: {
671: int nibble;
672: nibble = 8*bitmapbit(b,p) + 4*bitmapbit(b,Pt(p.x+1,p.y)) +
673: 2*bitmapbit(b,Pt(p.x+2,p.y)) + bitmapbit(b,Pt(p.x+3,p.y));
674: return(exa[nibble]);
675: }
676:
677: putnibble(ch,b,clipr,p)
678: int ch;
679: Bitmap *b;
680: Rectangle clipr;
681: Point p;
682: {
683: int nibble, mask;
684: if (ch<'0') return;
685: if (ch<='9') nibble = ch - '0';
686: else if (ch<='F') nibble = 10 + (ch - 'A');
687: else nibble = 10 + (ch - 'a');
688: if (nibble != 0)
689: for (mask = 0x10; mask >>= 1; p.x++)
690: if ((mask & nibble) && ptinrect(p, clipr))
691: point(b, p, F_OR);
692: }
693:
694: Bitmap *Source, *Undo;
695:
696: FlipOntoScreen(p)
697: Point p;
698: {
699: Rectangle ICONp;
700: if (!ptinrect(p,Source->rect)) return(0);
701: point(&display,add(icon.origin,p),F_XOR);
702: ICONp.origin = add(Pt(p.x*Xsize,p.y*Ysize),ICON.origin);
703: ICONp.corner = add(Pt((p.x+1)*Xsize,(p.y+1)*Ysize),ICON.origin);
704: if ((ICONp.origin.x > icon.corner.x) ||
705: (ICONp.origin.y > icon.corner.y))
706: rectf(&display,ICONp,F_XOR);
707: }
708:
709: bool geticonpoint(p)
710: Point p;
711: {
712: if (!ptinrect(p,Source->rect)) return(false);
713: return(bitmapbit(Source,p));
714: }
715:
716: flipiconpoint(p)
717: Point p;
718: {
719: point(Source,p,F_XOR);
720: FlipOntoScreen(p);
721: }
722:
723: IconOp(bit,p,op)
724: bool bit;
725: Point p;
726: int op;
727: {
728: if ((p.x>=0) && (p.x<Xblocks) && (p.y>=0) && (p.y<Yblocks))
729: switch (op) {
730: case I_STORE:
731: if (geticonpoint(p) != bit) flipiconpoint(p);
732: break;
733: case I_CLR:
734: if (geticonpoint(p)) flipiconpoint(p);
735: break;
736: case I_OR:
737: if (bit && !geticonpoint(p)) flipiconpoint(p);
738: break;
739: case I_XOR:
740: if (bit) flipiconpoint(p);
741: break;
742: case I_AND:
743: if (!bit && geticonpoint(p)) flipiconpoint(p);
744: break;
745: }
746: }
747:
748: IconBitBlit(from,to,clip,srccode,dstcode)
749: Rectangle from; /* icon coords */
750: Point to; /* icon coords */
751: Rectangle clip; /* icon coords */
752: int srccode,dstcode;
753: {
754: Rectangle region;
755: int dx,dy,di,dj,i,j;
756: int left,up;
757: bool bit;
758: dx = to.x - from.origin.x;
759: dy = to.y - from.origin.y;
760: left = dx<0;
761: up = dy<0;
762: di = (left?1:-1);
763: dj = (up?1:-1);
764: region = from;
765: if (!rectclip(®ion,raddp(clip,sub(from.origin,to))))
766: region = nullrect;
767: for (j=(up?from.origin.y:from.corner.y-1);
768: up?(j<from.corner.y):(j>=from.origin.y); j+=dj) {
769: wait(CPU);
770: for (i=(left?from.origin.x:from.corner.x-1);
771: left?(i<from.corner.x):(i>=from.origin.x); i+=di) {
772: bit = geticonpoint(Pt(i,j));
773: IconOp(false,Pt(i,j),srccode);
774: if (ptinrect(Pt(i,j),region)) IconOp(bit,Pt(i+dx,j+dy),dstcode);
775: }
776: }
777: }
778:
779: horshear(b,r,dx,top)
780: Bitmap *b;
781: Rectangle r;
782: int dx;
783: bool top;
784: {
785: int i,j,hsize,vsize,shift;
786: bool bit,dir;
787: hsize = horsize(r);
788: vsize = versize(r);
789: dir = (dx>0);
790: for (j=0; j<vsize; j++) {
791: wait(CPU);
792: shift = top ? vsize-j-1 : j;
793: bitblt(b,Rect(r.origin.x,r.origin.y+j,r.corner.x,r.origin.y+j+1),
794: b,Pt(r.origin.x+muldiv(shift,dx,vsize),r.origin.y+j),
795: F_STORE);
796: }
797: }
798:
799: vershear(b,r,dy,lft)
800: Bitmap *b;
801: Rectangle r;
802: int dy;
803: bool lft;
804: {
805: int i,j,hsize,vsize,shift;
806: bool bit,dir;
807: hsize = horsize(r);
808: vsize = versize(r);
809: dir = (dy>0);
810: for (i=0; i<hsize; i++) {
811: wait(CPU);
812: shift = lft ? hsize-i-1 : i;
813: bitblt(b,Rect(r.origin.x+i,r.origin.y,r.origin.x+i+1,r.corner.y),
814: b,Pt(r.origin.x+i,r.origin.y+muldiv(shift,dy,hsize)),
815: F_STORE);
816: }
817: }
818:
819: OpRotPlus()
820: {
821: int vsize,hsize,size;
822: Rectangle r,rbuf;
823: Bitmap *buffer;
824: if (GetIconRect(&r)==0) return(0);
825: hsize = horsize(r); vsize = versize(r); size = hsize+vsize;
826: buffer = balloc(Rect(0,0,size,size));
827: if (buffer == ((Bitmap *) 0)) return(0);
828: rectf(buffer,buffer->rect,F_CLR);
829: rbuf = rsubp(r,r.origin);
830: SaveForUndo();
831: cursswitch(&clock);
832: bitblt(&display,raddp(r,icon.origin),buffer,rbuf.origin,F_XOR);
833: horshear(buffer,rbuf,vsize,true);
834: vershear(buffer,
835: Rect(rbuf.origin.x,rbuf.origin.y,rbuf.corner.x+vsize,rbuf.corner.y),
836: size,false);
837: horshear(buffer,
838: Rect(rbuf.origin.x,rbuf.corner.y-1,
839: rbuf.corner.x+vsize,rbuf.corner.y+hsize-1),
840: -hsize,false);
841: Erase(r);
842: OrOntoPicture(buffer,
843: Rect(rbuf.origin.x,rbuf.corner.y-1,
844: rbuf.origin.x+vsize,rbuf.corner.y+hsize-1),
845: add(r.origin,sub(Pt(hsize/2,vsize/2),Pt(vsize/2,hsize/2))));
846: cursswitch((Cursor *) 0);
847: bfree(buffer);
848: }
849:
850: OpRotMinus()
851: {
852: int vsize,hsize,size;
853: Rectangle r,rbuf;
854: Bitmap *buffer;
855: if (GetIconRect(&r)==0) return(0);
856: hsize = horsize(r); vsize = versize(r); size = hsize+vsize;
857: buffer = balloc(Rect(0,0,size,size));
858: if (buffer == ((Bitmap *) 0)) return(0);
859: rectf(buffer,buffer->rect,F_CLR);
860: rbuf = raddp(r,sub(Pt(vsize,0),r.origin));
861: SaveForUndo();
862: cursswitch(&clock);
863: bitblt(&display,raddp(r,icon.origin),buffer,rbuf.origin,F_XOR);
864: horshear(buffer,rbuf,-vsize,true);
865: vershear(buffer,
866: Rect(rbuf.origin.x-vsize,rbuf.origin.y,rbuf.corner.x,rbuf.corner.y),
867: size,true);
868: horshear(buffer,
869: Rect(rbuf.origin.x-vsize,rbuf.corner.y-1,
870: rbuf.corner.x,rbuf.corner.y+hsize-1),
871: hsize,false);
872: Erase(r);
873: OrOntoPicture(buffer,
874: Rect(rbuf.corner.x-vsize,rbuf.corner.y-1,
875: rbuf.corner.x,rbuf.corner.y+hsize-1),
876: add(r.origin,sub(Pt(hsize/2,vsize/2),Pt(vsize/2,hsize/2))));
877: cursswitch((Cursor *) 0);
878: bfree(buffer);
879: }
880:
881: OpReflY()
882: {
883: Rectangle r;
884: int i,j;
885: bool bit1,bit2;
886: if (GetIconRect(&r)==0) return(0);
887: SaveForUndo();
888: cursswitch(&clock);
889: for (i=r.origin.x; i<r.corner.x; i+=1) {
890: wait(CPU);
891: for (j=0; j<(versize(r)/2); j+=1) {
892: bit1 = geticonpoint(Pt(i,r.origin.y+j));
893: bit2 = geticonpoint(Pt(i,r.corner.y-1-j));
894: IconOp(bit1,Pt(i,r.corner.y-1-j),I_STORE);
895: IconOp(bit2,Pt(i,r.origin.y+j),I_STORE);
896: }
897: }
898: cursswitch((Cursor *) 0);
899: }
900:
901: OpReflX()
902: {
903: Rectangle r;
904: int i,j;
905: bool bit1,bit2;
906: if (GetIconRect(&r)==0) return(0);
907: SaveForUndo();
908: cursswitch(&clock);
909: for (i=0; i<(horsize(r)/2); i+=1) {
910: wait(CPU);
911: for (j=r.origin.y; j<r.corner.y; j+=1) {
912: bit1 = geticonpoint(Pt(r.origin.x+i,j));
913: bit2 = geticonpoint(Pt(r.corner.x-1-i,j));
914: IconOp(bit1,Pt(r.corner.x-1-i,j),I_STORE);
915: IconOp(bit2,Pt(r.origin.x+i,j),I_STORE);
916: }
917: }
918: cursswitch((Cursor *) 0);
919: }
920:
921: OpBlit(srcop,dstop)
922: int srcop,dstop;
923: {
924: Rectangle r, r1;
925: Point p;
926: if (GetIconRect(&r)==0) return(0);
927: r1 = TrackBorder(r,true);
928: p = r1.origin;
929: if (button23()) {
930: while (button23())jnap(1);
931: SaveForUndo();
932: cursswitch(&clock);
933: IconBitBlit(r,p,Rect(0,0,Xblocks,Yblocks),srcop,dstop);
934: cursswitch((Cursor *) 0);
935: } else while (button1())jnap(1);
936: }
937:
938:
939: OpGeneralBlit()
940: {
941: int srcop, dstop;
942: cursswitch(&menucursor);
943: while (!button123()) wait(MOUSE);
944: cursswitch((Cursor *) 0);
945: if (!button3()) return(0);
946: switch (menuhit(&blitsrcmenu,3)) {
947: case NOHIT:
948: srcop = I_NULL;
949: break;
950: case SRC_ID:
951: srcop = I_OR;
952: break;
953: case SRC_CLR:
954: srcop = I_CLR;
955: break;
956: }
957: if (srcop==I_NULL) {cursswitch((Cursor *) 0); return(0);}
958: cursswitch(&menucursor);
959: while (!button123()) wait(MOUSE);
960: cursswitch((Cursor *) 0);
961: if (!button3()) return(0);
962: switch (menuhit(&blitdstmenu,3)) {
963: case NOHIT:
964: dstop = I_NULL;
965: break;
966: case DST_STORE:
967: dstop = I_STORE;
968: break;
969: case DST_OR:
970: dstop = I_OR;
971: break;
972: case DST_XOR:
973: dstop = I_XOR;
974: break;
975: case DST_AND:
976: dstop = I_AND;
977: break;
978: case DST_CLR:
979: dstop = I_CLR;
980: break;
981: }
982: if (dstop==I_NULL) {cursswitch((Cursor *) 0); return(0);}
983: OpBlit(srcop,dstop);
984: }
985:
986: Erase(r)
987: Rectangle r;
988: {
989: int i,j;
990: for (j = r.origin.y ; j < r.corner.y ; j++) {
991: wait(CPU);
992: for (i = r.origin.x ; i < r.corner.x ; i++) {
993: if (geticonpoint(Pt(i,j)) == true) flipiconpoint(Pt(i,j));
994: }
995: }
996: }
997:
998: OpErase()
999: {
1000: Rectangle r;
1001: if (GetIconRect(&r)==0) return(0);
1002: SaveForUndo();
1003: cursswitch(&clock);
1004: Erase(r);
1005: cursswitch((Cursor *)0);
1006: }
1007:
1008: OpInvert()
1009: {
1010: Rectangle r;
1011: int i,j;
1012: if (GetIconRect(&r)==0) return(0);
1013: SaveForUndo();
1014: cursswitch(&clock);
1015: for (j = r.origin.y ; j < r.corner.y ; j++) {
1016: wait(CPU);
1017: for (i = r.origin.x ; i < r.corner.x ; i++) {
1018: flipiconpoint(Pt(i,j));
1019: }
1020: }
1021: cursswitch((Cursor *)0);
1022: }
1023:
1024: getstr(s,p)
1025: char *s;
1026: Point p;
1027: {
1028: char c,*t;
1029: static char str[]="x";
1030: t = s;
1031: for (;;) {
1032: wait(KBD);
1033: if (((c=kbdchar()) == '\r') || (c == '\n')) {
1034: *s = '\0';
1035: return;
1036: }
1037: if (c == '\b') {
1038: if (s>t) {
1039: str[0] = *(--s);
1040: string(&defont,str,&display,(p = sub(p,Pt(9,0))),F_XOR);
1041: }
1042: } else if ((c >= '!') && (c <= '~')) {
1043: if (s-t<50) {
1044: *s++ = (str[0] = c);
1045: p = string(&defont,str,&display,p,F_XOR);
1046: }
1047: }
1048: }
1049: }
1050:
1051: GetFNAME()
1052: {
1053: Point p;
1054: Bitmap *b;
1055: cursswitch(&deadmouse);
1056: b = balloc(Rpt(Drect.origin,Pt(Drect.corner.x,Drect.origin.y+18)));
1057: if (b!=0) {
1058: bitblt(&display,b->rect,b,Drect.origin,F_STORE);
1059: rectf(&display,b->rect,F_CLR);
1060: outline(&display,inset(b->rect,1));
1061: }
1062: p = string(&defont,"File: ",&display,add(Drect.origin,Pt(10,3)),F_XOR);
1063: getstr(FNAME,p);
1064: p = string(&defont,"File: ",&display,add(Drect.origin,Pt(10,3)),F_XOR);
1065: string(&defont,FNAME,&display,p,F_XOR);
1066: if (b!=0) {
1067: bitblt(b,b->rect,&display,Drect.origin,F_STORE);
1068: bfree(b);
1069: }
1070: cursswitch((Cursor *) 0);
1071: }
1072:
1073: Bitmap *pickupmap;
1074:
1075: PickUpCursor()
1076: {
1077: /*
1078: Cursor *oldcursor;
1079: Cursor pickuptexture;
1080: Rectangle r;
1081: int i;
1082: r = TrackBorder(raddp(rect16x16,IconPoint(mouse.xy)),true);
1083: r = raddp(r,icon.origin);
1084: bitblt(&display,r,pickupmap,Pt(0,0),F_STORE);
1085: for (i=0; i<16; i++) pickuptexture.bits[i] = (short)(pickupmap->base[i]>>16);
1086: oldcursor = cursswitch(&pickuptexture);
1087: while (button123())jnap(1);
1088: while (!button123())jnap(1);
1089: while (button123())jnap(1);
1090: cursswitch(oldcursor);
1091: */
1092: }
1093:
1094: char SFbuffer[100];
1095: char *SFlist[] = { /* Where to look */
1096: "", /* Look in local directory first */
1097: "/usr/jerq/icon/16x16/", /* Ick! "/usr/jerq/icon" should be a parameter */
1098: "/usr/jerq/icon/texture/",
1099: "/usr/jerq/icon/large/",
1100: "/usr/jerq/icon/face48/",
1101: (char *) 0
1102: };
1103:
1104: FILE *SearchFile(filename,mode,filefound)
1105: char *filename, *mode, **filefound;
1106: {
1107: FILE *fp;
1108: char **sf = SFlist;
1109: int namez = strlen(filename);
1110: *filefound = SFbuffer;
1111: fp = (FILE *) 0;
1112: for (; (fp == (FILE *) 0) && (*sf != (char *) 0); sf++) {
1113: if ((strlen(*sf) + namez) < sizeof(SFbuffer)) {
1114: strcpy(SFbuffer, *sf);
1115: strcat(SFbuffer, filename);
1116: fp = fopen(SFbuffer, mode);
1117: }
1118: }
1119: return(fp);
1120: }
1121:
1122: Rectangle OpLoad(bitmap,filename)
1123: Bitmap *bitmap;
1124: char *filename;
1125: {
1126: FILE *fp;
1127: Rectangle rect;
1128: Cursor *oldcursor;
1129: char *filefound;
1130: int ch,i,j;
1131: int xsize,ysize;
1132: rect = bitmap->rect;
1133: oldcursor = cursswitch(&clock);
1134: fp = SearchFile(filename,"r",&filefound);
1135: if (fp == ((FILE *) 0)) {cursswitch((Cursor *) 0); return(nullrect);}
1136: ch = getc(fp);
1137: if (ch=='0') {
1138: i = rect.origin.x; j = rect.origin.y;
1139: xsize = 0;
1140: for (;;) {
1141: getc(fp); /* 'x' */
1142: putnibble(getc(fp),bitmap,rect,Pt(i,j)); i+=4;
1143: putnibble(getc(fp),bitmap,rect,Pt(i,j)); i+=4;
1144: putnibble(getc(fp),bitmap,rect,Pt(i,j)); i+=4;
1145: putnibble(getc(fp),bitmap,rect,Pt(i,j)); i+=4;
1146: getc(fp); /* ',' */
1147: while ((ch = getc(fp))==' '); /* '0' or '\n' */
1148: if (ch=='\n') {
1149: xsize = max(xsize,i-rect.origin.x);
1150: i = rect.origin.x;
1151: j++;
1152: ch = getc(fp); /* '0' */
1153: } else if (ch == EOF) break;
1154: }
1155: ysize = j-rect.origin.y;
1156: } else {
1157: while ((ch!='{')&&(ch!=EOF)) ch=getc(fp);
1158: for (j=rect.origin.y; j<rect.origin.y+16; j++) {
1159: while (((ch=getc(fp))!='x')&&(ch!='X')&&(ch!=EOF)) {};
1160: putnibble(getc(fp),bitmap,rect,Pt(rect.origin.x,j));
1161: putnibble(getc(fp),bitmap,rect,Pt(rect.origin.x+4,j));
1162: putnibble(getc(fp),bitmap,rect,Pt(rect.origin.x+8,j));
1163: putnibble(getc(fp),bitmap,rect,Pt(rect.origin.x+12,j));
1164: }
1165: xsize = ysize = 16;
1166: }
1167: fclose(fp);
1168: rect.origin.x = 0; rect.origin.y = 0;
1169: rect.corner.x = xsize; rect.corner.y = ysize;
1170: cursswitch(oldcursor);
1171: return(rect);
1172: }
1173:
1174: OpRead()
1175: {
1176: Rectangle rect, r1;
1177: Bitmap *buffer;
1178: Point p;
1179: GetFNAME();
1180: if (!FNAME[0]) return(0);
1181: buffer = balloc(Source->rect);
1182: if (buffer == ((Bitmap *) 0)) {cursswitch((Cursor *) 0); return(0);}
1183: rectf(buffer,buffer->rect,F_CLR);
1184: rect = OpLoad(buffer,FNAME);
1185: if (!eqrect(rect,nullrect)) {
1186: SaveForUndo();
1187: r1 = TrackBorder(raddp(rect,IconPoint(mouse.xy)),true);
1188: p = r1.origin;
1189: while (button3())jnap(1);
1190: cursswitch(&clock);
1191: OrOntoPicture(buffer,rect,p);
1192: cursswitch((Cursor *)0);
1193: }
1194: bfree(buffer);
1195: }
1196:
1197: #ifdef BSD
1198: #define BUFSIZE BUFSIZ
1199: #endif BSD
1200: char buffer[BUFSIZE];
1201: char *bufend;
1202:
1203: bclear()
1204: {
1205: bufend = buffer;
1206: }
1207:
1208: bsend(fp)
1209: FILE *fp;
1210: {
1211: *bufend = '\0';
1212: fputs(buffer,fp);
1213: bclear();
1214: }
1215:
1216: bputc(c,fp)
1217: char c;
1218: FILE *fp;
1219: {
1220: if (bufend >= buffer+BUFSIZE-3) bsend(fp);
1221: *bufend++ = c;
1222: }
1223:
1224: OpWrite()
1225: {
1226: FILE *fp;
1227: Rectangle r;
1228: Point p;
1229: int i,j,butt;
1230: butt = GetIconRect(&r);
1231: if (butt==0) return(0);
1232: if (butt==3) {
1233: GetFNAME();
1234: if (!FNAME[0]) return(0);
1235: fp = fopen(FNAME,"w");
1236: if (fp == ((FILE *) 0)) return(0);
1237: rectf(&display,Drect,F_XOR);
1238: bclear();
1239: for (j = r.origin.y; j<r.corner.y; j++) {
1240: for (i=r.origin.x; i<r.corner.x; i+=16) {
1241: bputc('0',fp);bputc('x',fp);
1242: bputc(getnibble(Source,Pt(i,j)),fp);
1243: bputc(getnibble(Source,Pt(i+4,j)),fp);
1244: bputc(getnibble(Source,Pt(i+8,j)),fp);
1245: bputc(getnibble(Source,Pt(i+12,j)),fp);
1246: bputc(',',fp);
1247: }
1248: bputc('\n',fp);
1249: bsend(fp);
1250: }
1251: fclose(fp);
1252: rectf(&display,Drect,F_XOR);
1253: } else if (butt==2) {
1254: GetFNAME();
1255: if (!FNAME[0]) return(0);
1256: fp = fopen(FNAME,"w");
1257: if (fp == ((FILE *) 0)) return(0);
1258: rectf(&display,Drect,F_XOR);
1259: fputs("Texture ",fp); fputs(FNAME,fp); fputs(" = {\n",fp);
1260: j = r.origin.y; i = r.origin.x;
1261: bclear();
1262: while (j < r.corner.y) {
1263: if (((j-r.origin.y)%4) == 0) bputc('\t',fp);
1264: bputc(' ',fp);bputc('0',fp);bputc('x',fp);
1265: bputc(getnibble(Source,Pt(i,j)),fp);
1266: bputc(getnibble(Source,Pt(i+4,j)),fp);
1267: bputc(getnibble(Source,Pt(i+8,j)),fp);
1268: bputc(getnibble(Source,Pt(i+12,j)),fp);
1269: bputc(',',fp);
1270: if (((j-r.origin.y)%4) == 3) bputc('\n',fp);
1271: j = j+1;
1272: bsend(fp);
1273: }
1274: fputs("};\n",fp);
1275: fclose(fp);
1276: rectf(&display,Drect,F_XOR);
1277: }
1278:
1279: }
1280:
1281: OpTexture()
1282: {
1283: Bitmap *buffer,*buffer1;
1284: Rectangle source,dest;
1285: Point target;
1286: int repx,repy,i,j,hsize,vsize;
1287: if (GetIconRect(&source)==0) return(0);
1288: if (GetIconRect(&dest)==0) return(0);
1289: hsize = horsize(source);
1290: vsize = versize(source);
1291: if ((hsize==0) || (vsize==0)) return(0);
1292: buffer = balloc(source);
1293: if (buffer == ((Bitmap *) 0)) return(0);
1294: buffer1 = balloc(source);
1295: if (buffer1 == ((Bitmap *) 0)) {bfree(buffer); return(0);}
1296: SaveForUndo();
1297: cursswitch(&clock);
1298: bitblt(&display,raddp(source,icon.origin),buffer,buffer->rect.origin,F_STORE);
1299: repx = horsize(dest)/hsize;
1300: repy = versize(dest)/vsize;
1301: for (j=0; j<=repy; j++)
1302: for (i=0; i<=repx; i++) {
1303: bitblt(buffer,buffer->rect,buffer1,buffer1->rect.origin,F_STORE);
1304: OrOntoPictureClipped(buffer1,
1305: buffer1->rect,add(dest.origin,Pt(i*hsize,j*vsize)),dest);
1306: }
1307: cursswitch((Cursor *) 0);
1308: bfree(buffer);
1309: bfree(buffer1);
1310: }
1311:
1312: int GridSwitch=0;
1313:
1314: OpGrid()
1315: {
1316: if ((GridSwitch%2)==0) DrawFineGrid(); else DrawCoarseGrid();
1317: GridSwitch = (GridSwitch+1)%4;
1318: }
1319:
1320: OpResize()
1321: {
1322: Point p;
1323: Rectangle r;
1324: Bitmap *NewSource, *NewUndo;
1325: Cursor *oldcursor;
1326: bool doit;
1327: oldcursor = cursswitch(&clock);
1328: p=mouse.xy;
1329: r=canonrect(icon.origin,p);
1330: outline(&display,r);
1331: for(; !button123(); nap(2)){
1332: outline(&display,r);
1333: p=mouse.xy;
1334: r=canonrect(icon.origin,p);
1335: outline(&display,r);
1336: }
1337: doit = button3();
1338: outline(&display,r);
1339: cursswitch(oldcursor);
1340: while (button123())jnap(1);
1341: if (!doit) return(0);
1342: if (!rectclip(&r,Rpt(icon.origin,ICON.corner))) return(0);
1343: r = rsubp(r,icon.origin);
1344: NewSource = balloc(r); if (NewSource==0) return(0);
1345: NewUndo = balloc(r); if (NewUndo==0) {bfree(NewSource); return(0);}
1346: rectf(NewSource,NewSource->rect,F_CLR);
1347: rectf(NewUndo,NewUndo->rect,F_CLR);
1348: bitblt(Source,Source->rect,NewSource,NewSource->rect.origin,F_XOR);
1349: bitblt(Undo,Undo->rect,NewUndo,NewUndo->rect.origin,F_XOR);
1350: bfree(Source); bfree(Undo);
1351: Source = NewSource; Undo = NewUndo;
1352: rectf(&display,Drect,F_CLR);
1353: XSIZE = horsize(r); YSIZE = versize(r);
1354: Redraw();
1355: }
1356:
1357:
1358: HorShear(r,dx,top)
1359: Rectangle r;
1360: int dx;
1361: bool top;
1362: {
1363: int j,vsize,shift;
1364: vsize = versize(r);
1365: for (j=0; j<vsize; j++) {
1366: shift = top ? vsize-j-1 : j;
1367: IconBitBlit(Rect(r.origin.x,r.origin.y+j,r.corner.x,r.origin.y+j+1),
1368: Pt(r.origin.x+muldiv(shift,dx,vsize),r.origin.y+j),
1369: Rect(0,0,Xblocks,Yblocks),
1370: I_CLR,I_OR);
1371: }
1372: }
1373:
1374: VerShear(r,dy,lft)
1375: Rectangle r;
1376: int dy;
1377: bool lft;
1378: {
1379: int i,hsize,shift;
1380: hsize = horsize(r);
1381: for (i=0; i<hsize; i++) {
1382: shift = lft ? hsize-i-1 : i;
1383: IconBitBlit(Rect(r.origin.x+i,r.origin.y,r.origin.x+i+1,r.corner.y),
1384: Pt(r.origin.x+i,r.origin.y+muldiv(shift,dy,hsize)),
1385: Rect(0,0,Xblocks,Yblocks),
1386: I_CLR,I_OR);
1387: }
1388: }
1389:
1390: OpHorShear()
1391: {
1392: Rectangle r;
1393: int dx;
1394: bool top;
1395: Point p,nearcorner;
1396: if (GetIconRect(&r)==0) return(0);
1397: if ((horsize(r)==0) || (versize(r)==0)) return(0);
1398: if (!GetIconPoint(&p)) return(0);
1399: SaveForUndo();
1400: cursswitch(&clock);
1401: nearcorner = nearestcorner(r,p);
1402: dx = p.x - nearcorner.x;
1403: top = (nearcorner.y == r.origin.y);
1404: HorShear(r,dx,top);
1405: cursswitch((Cursor *) 0);
1406: }
1407:
1408: OpVerShear()
1409: {
1410: Rectangle r;
1411: int dy;
1412: bool lft;
1413: Point p,nearcorner;
1414: if (GetIconRect(&r)==0) return(0);
1415: if ((horsize(r)==0) || (versize(r)==0)) return(0);
1416: if (!GetIconPoint(&p)) return(0);
1417: SaveForUndo();
1418: cursswitch(&clock);
1419: nearcorner = nearestcorner(r,p);
1420: dy = p.y - nearcorner.y;
1421: lft = (nearcorner.x == r.origin.x);
1422: VerShear(r,dy,lft);
1423: cursswitch((Cursor *) 0);
1424: }
1425:
1426: Stretch(sb,sr,db,dr,op)
1427: Bitmap *sb,*db;
1428: Rectangle sr,dr;
1429: Code op;
1430: {
1431: int i,j,shsize,svsize,dhsize,dvsize;
1432: shsize = horsize(sr);
1433: svsize = versize(sr);
1434: dhsize = horsize(dr);
1435: dvsize = versize(dr);
1436: for (j=0; j<svsize; j++) {
1437: wait(CPU);
1438: for (i=0; i<shsize; i++) {
1439: bitblt(sb,
1440: Rect(sr.origin.x+i,sr.origin.y+j,sr.origin.x+i+1,sr.origin.y+j+1),
1441: db,
1442: Pt(dr.origin.x+muldiv(dhsize,i,shsize),
1443: dr.origin.y+muldiv(dvsize,j,svsize)),
1444: op);
1445: }
1446: }
1447: }
1448:
1449: OpStretch()
1450: {
1451: Bitmap *buffer;
1452: Rectangle source,dest;
1453: if (GetIconRect(&source)==0) return(0);
1454: if ((horsize(source)==0) || (versize(source)==0)) return(0);
1455: if (GetIconRect(&dest)==0) return(0);
1456: if ((horsize(dest)==0) || (versize(dest)==0)) return(0);
1457: buffer = balloc(dest);
1458: if (buffer == ((Bitmap *) 0)) return(0);
1459: SaveForUndo();
1460: cursswitch(&clock);
1461: rectf(buffer,buffer->rect,F_CLR);
1462: Stretch(&display,raddp(source,icon.origin),buffer,buffer->rect,F_XOR);
1463: IconBitBlit(source,source.origin,Rect(0,0,0,0),F_CLR,F_CLR);
1464: OrOntoPictureClipped(buffer,buffer->rect,dest.origin,dest);
1465: cursswitch((Cursor *) 0);
1466: bfree(buffer);
1467: }
1468:
1469: DrawHorGridLine(p,op)
1470: Point p;
1471: Code op;
1472: {
1473: if ((p.y < icon.corner.y+2) && (p.x < icon.corner.x+2))
1474: p.x = ScreenCoordX(IconCoordX(icon.corner.x+Xsize));
1475: rectf(&display,Rpt(p,Pt(ICON.corner.x,p.y+1)),op);
1476: }
1477:
1478: DrawVerGridLine(p,op)
1479: Point p;
1480: Code op;
1481: {
1482: if ((p.x < icon.corner.x+2) && (p.y < icon.corner.y+2))
1483: p.y = ScreenCoordY(IconCoordY(icon.corner.y+Ysize));
1484: rectf(&display,Rpt(p,Pt(p.x+1,ICON.corner.y)),op);
1485: }
1486:
1487: DrawGridBorder()
1488: {
1489: DrawHorGridLine(ICON.origin,F_OR);
1490: DrawHorGridLine(add(ICON.origin,Pt(0,Yblocks*Ysize)),F_OR);
1491: DrawVerGridLine(ICON.origin,F_OR);
1492: DrawVerGridLine(add(ICON.origin,Pt(Xblocks*Xsize,0)),F_OR);
1493: point(&display,ICON.corner,F_OR);
1494: }
1495:
1496: DrawFineGrid()
1497: {
1498: register int i,j;
1499: for (j=1; j<Yblocks; j++) DrawHorGridLine(add(ICON.origin,Pt(0,j*Ysize)),F_XOR);
1500: for (i=1; i<Xblocks; i++) DrawVerGridLine(add(ICON.origin,Pt(i*Xsize,0)),F_XOR);
1501: }
1502:
1503: DrawCoarseGrid()
1504: {
1505: Point p;
1506: register int i,j;
1507: for (j=0; j<=Yblocks; j+=16)
1508: DrawHorGridLine(add(ICON.origin,Pt(0,j*Ysize+1)),F_XOR);
1509: for (j=8; j<=Yblocks; j+=16) {
1510: p=add(ICON.origin,Pt(0,j*Ysize+1));
1511: if ((p.y < icon.corner.y+2) && (p.x < icon.corner.x+2))
1512: p.x = ScreenCoordX(IconCoordX(icon.corner.x+Xsize));
1513: for (i=0; i<=Xblocks*Xsize; i+=2)
1514: point(&display,Pt(p.x+i,p.y),F_XOR);
1515: }
1516: for (i=0; i<=Xblocks; i+=16)
1517: DrawVerGridLine(add(ICON.origin,Pt(i*Xsize+1,0)),F_XOR);
1518: for (i=8; i<=Xblocks; i+=16) {
1519: p=add(ICON.origin,Pt(i*Xsize+1,0));
1520: if ((p.x < icon.corner.x+2) && (p.y < icon.corner.y+2))
1521: p.y = ScreenCoordY(IconCoordY(icon.corner.y+Ysize));
1522: for (j=0; j<=Yblocks*Ysize; j+=2)
1523: point(&display,Pt(p.x,p.y+j),F_XOR);
1524: }
1525: }
1526:
1527: Bitmap *HelpBuffer, *HelpTexture;
1528:
1529: helpline(i,icon,str)
1530: int i;
1531: Texture *icon;
1532: char *str;
1533: {
1534: texture(HelpTexture,HelpTexture->rect,icon,F_STORE);
1535: bitblt(HelpTexture,HelpTexture->rect,HelpBuffer,Pt(2,2+16*i),F_XOR);
1536: string(&defont,str,HelpBuffer,Pt(2+32,2+16*i),F_XOR);
1537: }
1538:
1539: HelpSorry()
1540: {
1541: string(&defont,"Not enough space on blit",
1542: &display,add(icon.corner,Pt(15,-20)),F_XOR);
1543: }
1544:
1545: Help()
1546: {
1547: HelpBuffer = balloc(Rect(0,0,302,482));
1548: HelpTexture = balloc(Rect(0,0,16,16));
1549: if ((HelpBuffer==0) || (HelpTexture==0)) {
1550: HelpSorry();
1551: while (!button123()) wait(MOUSE);
1552: HelpSorry();
1553: while (button123())jnap(1);
1554: return(0);
1555: }
1556: rectf(HelpBuffer,HelpBuffer->rect,F_CLR);
1557: outline(HelpBuffer,Rpt(HelpBuffer->rect.origin,sub(HelpBuffer->rect.corner,Pt(1,1))));
1558: helpline(0,&whiteT,"left button: draw");
1559: helpline(1,&whiteT,"middle button: erase");
1560: helpline(2,&whiteT,"");
1561: helpline(3,&Cmove,"move region");
1562: helpline(4,&Ccopy,"copy region");
1563: helpline(5,&Cinvert,"invert region");
1564: helpline(6,&Cerase,"erase region");
1565: helpline(7,&Creflx,"reflect x region");
1566: helpline(8,&Crefly,"reflect y region");
1567: helpline(9,&Crotplus,"rotate + region");
1568: helpline(10,&Crotminus,"rotate - region");
1569: helpline(11,&Cshearx,"shear x region");
1570: helpline(12,&Csheary,"shear y region");
1571: helpline(13,&Cstretch,"stretch region");
1572: helpline(14,&Ctexture,"texture region");
1573: helpline(15,&Cread,"read file");
1574: helpline(16,&Cgrid,"background grids");
1575: helpline(17,&Cresize,"resize drawing area");
1576: helpline(18,&Cwrite,"write file");
1577: helpline(19,&Cblit,"bitblit region");
1578: helpline(20,&Ccursor,"pick cursor icon");
1579: helpline(21,&Chelp,"(press a button to continue)");
1580: helpline(22,&Cundo,"undo last operation");
1581: helpline(23,&whiteT,"");
1582: helpline(24,&clockT,"wait");
1583: helpline(25,&deadmouseT,"mouse inactive");
1584: helpline(26,&menucursorT, "menu on right button");
1585: helpline(27,&sweepcursorT,"sweep rect (right button)");
1586: helpline(28,&sweeportrackT,"sweep rect (right button) or");
1587: helpline(29,&whiteT,"get 16x16 frame (middle butt)");
1588: screenswap(HelpBuffer,HelpBuffer->rect,raddp(HelpBuffer->rect,Drect.origin));
1589: while (!button123())jnap(1);
1590: screenswap(HelpBuffer,HelpBuffer->rect,raddp(HelpBuffer->rect,Drect.origin));
1591: while (button123())jnap(1);
1592: bfree(HelpBuffer);
1593: bfree(HelpTexture);
1594: }
1595:
1596: SaveForUndo()
1597: {
1598: bitblt(Source,Source->rect,Undo,Undo->rect.origin,F_STORE);
1599: }
1600:
1601: OpUndo()
1602: {
1603: Rectangle r;
1604: int hsize,vsize,i,j;
1605: bool bit;
1606: Cursor *oldcursor;
1607: oldcursor = cursswitch(&clock);
1608: r = Source->rect;
1609: bitblt(Undo,r,Source,r.origin,F_XOR);
1610: XorOntoScreen(Source,r,r.origin);
1611: bitblt(Source,r,Undo,r.origin,F_XOR);
1612: bitblt(Undo,r,Source,r.origin,F_XOR);
1613: cursswitch(oldcursor);
1614: }
1615:
1616: XorOntoScreen(b,r,p)
1617: Bitmap *b;
1618: Rectangle r;
1619: Point p;
1620: {
1621: int i,j,h,v;
1622: h = horsize(r); v = versize(r);
1623: for(j=0; j<h; j++) {
1624: wait(CPU);
1625: for (i=0; i<v; i++) {
1626: if (bitmapbit(b,add(r.origin,Pt(j,i))))
1627: FlipOntoScreen(add(p,Pt(j,i)));
1628: }
1629: }
1630: }
1631:
1632: XorOntoPicture(b,r,p)
1633: Bitmap *b;
1634: Rectangle r;
1635: Point p;
1636: {
1637: XorOntoScreen(b,r,p);
1638: bitblt(b,r,Source,p,F_XOR);
1639: }
1640:
1641: OrOntoPicture(b,r,p)
1642: Bitmap *b;
1643: Rectangle r;
1644: Point p;
1645: /* Scrambles the contents of b */
1646: {
1647: rectf(b,r,F_XOR);
1648: bitblt(Source,raddp(rsubp(r,r.origin),p),b,r.origin,F_OR);
1649: rectf(b,r,F_XOR);
1650: XorOntoPicture(b,r,p);
1651: }
1652:
1653: OrOntoPictureClipped(b,r,p,clip)
1654: Bitmap *b;
1655: Rectangle r;
1656: Point p;
1657: Rectangle clip;
1658: {
1659: if (!rectclip(&r,rsubp(clip,sub(p,r.origin)))) r = nullrect;
1660: OrOntoPicture(b,r,p);
1661: }
1662:
1663: bool FirstTime = true;
1664:
1665: Redraw()
1666: {
1667: Xblocks = XSIZE;
1668: Yblocks = YSIZE;
1669:
1670: Xsize = (horsize(Drect)-1)/Xblocks;
1671: Ysize = (versize(Drect)-1)/Yblocks;
1672:
1673: if (Xsize==0) Xsize = 1;
1674: if (Ysize==0) Ysize = 1;
1675:
1676: Ysize = (Xsize = (Xsize<Ysize)?Xsize:Ysize);
1677:
1678: icon.origin = add(Drect.origin,Pt(2,2));
1679: icon.corner = add(icon.origin,Pt(Xblocks,Yblocks));
1680:
1681: ICON.origin = sub(Drect.corner,Pt(1+Xsize*Xblocks,1+Ysize*Yblocks));
1682: ICON.corner = add(ICON.origin,Pt(Xsize*Xblocks,Ysize*Yblocks));
1683: modx = ICON.origin.x % Xsize;
1684: divx = ICON.origin.x / Xsize;
1685: mody = ICON.origin.y % Ysize;
1686: divy = ICON.origin.y / Ysize;
1687:
1688: rectf(&display, Drect, F_CLR);
1689: DrawGridBorder();
1690: outline(&display,inset(Rpt(icon.origin,add(icon.corner,Pt(-1,-1))),-2));
1691: if ((GridSwitch==1)||(GridSwitch==2)) DrawFineGrid();
1692: if ((GridSwitch==2)||(GridSwitch==3)) DrawCoarseGrid();
1693:
1694: if (FirstTime) FirstTime = false;
1695: else {
1696: cursswitch(&clock);
1697: XorOntoScreen(Source,Source->rect,Source->rect.origin);
1698: cursswitch((Cursor *)0);
1699: }
1700: }
1701:
1702: Icon()
1703: {
1704: Bitmap *b;
1705: Point p,cur,hit;
1706: int i,j;
1707:
1708: Redraw();
1709:
1710: cur.x = 0; cur.y = 0;
1711:
1712: for (;;) {
1713: wait(MOUSE);
1714: if (P->state&RESHAPED) return(0);
1715: if (button1()) {
1716: SaveForUndo();
1717: while(button1()) {
1718: if (ptinrect((p=mouse.xy),ICON)) {
1719: p = sub(p,ICON.origin);
1720: cur.x = p.x/Xsize;
1721: cur.y = p.y/Ysize;
1722: if (geticonpoint(cur) == false) flipiconpoint(cur);
1723: }
1724: wait(MOUSE);
1725: }
1726: } else if (button2()) {
1727: SaveForUndo();
1728: while(button2()) {
1729: if (ptinrect((p=mouse.xy),ICON)) {
1730: p = sub(p,ICON.origin);
1731: cur.x = p.x/Xsize;
1732: cur.y = p.y/Ysize;
1733: if (geticonpoint(cur) == true) flipiconpoint(cur);
1734: }
1735: wait(MOUSE);
1736: }
1737: }
1738: if (button3()) {
1739: hit = imenuhit(imenu);
1740: switch (5*hit.y+hit.x) {
1741: case BLIT: OpGeneralBlit(); break;
1742: case MOVE: OpBlit(I_CLR,I_OR); break;
1743: case COPY: OpBlit(I_OR,I_OR); break;
1744: case ERASE: OpErase(); break;
1745: case INVERT: OpInvert(); break;
1746: case REFLECTX: OpReflX(); break;
1747: case REFLECTY: OpReflY(); break;
1748: case ROTATEPLUS: OpRotPlus(); break;
1749: case ROTATEMINUS: OpRotMinus(); break;
1750: case SHEARX: OpHorShear(); break;
1751: case SHEARY: OpVerShear(); break;
1752: case STRETCH: OpStretch(); break;
1753: case TEXTURE: OpTexture(); break;
1754: case GRID: OpGrid(); break;
1755: case PICK: PickUpCursor(); break;
1756: case READ: OpRead(); break;
1757: case WRITE: OpWrite(); break;
1758: case RESIZE: OpResize(); break;
1759: case HELP: Help(); break;
1760: case UNDO: OpUndo(); break;
1761: }
1762: }
1763: }
1764: }
1765:
1766:
1767: main(argc,argv)
1768: char *argv[];
1769: {
1770: request(MOUSE|SEND|KBD);
1771: mousemotion();
1772: initdisplay(argc, argv);
1773: initicons();
1774:
1775: nullpoint.x = 0;
1776: nullpoint.y = 0;
1777: point16x16.x = 16;
1778: point16x16.y = 16;
1779: nullrect.origin = nullpoint;
1780: nullrect.corner = nullpoint;
1781: rect16x16.origin = nullpoint;
1782: rect16x16.corner = point16x16;
1783:
1784: bittester = balloc(Rect(0,0,1,1));
1785: pickupmap = balloc(Rect(0,0,16,16));
1786: Source = balloc(Rect(0,0,XSIZE,YSIZE));
1787: if (Source == ((Bitmap *) 0)) exit();
1788: rectf(Source,Source->rect,F_CLR);
1789: Undo = balloc(Rect(0,0,XSIZE,YSIZE));
1790: if (Undo == ((Bitmap *) 0)) exit();
1791: rectf(Undo,Undo->rect,F_CLR);
1792:
1793: do {
1794: P->state&=~RESHAPED;
1795: Icon();
1796: } while (P->state&RESHAPED);
1797:
1798: exit();
1799:
1800: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.