~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / Glass / !Glass / c / editIcon
1 /*
2 * editIcon.c
3 *
4 * Edit icon dialogue box
5 *
6 * © 1994-1998 Straylight
7 */
8
9 /*----- Licensing note ----------------------------------------------------*
10 *
11 * This file is part of Straylight's Glass.
12 *
13 * Glass is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2, or (at your option)
16 * any later version.
17 *
18 * Glass is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with Glass. If not, write to the Free Software Foundation,
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 */
27
28 /*----- Header files ------------------------------------------------------*/
29
30 /*
31 * ANSI standard headers
32 */
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37
38 /*
39 * Steel headers
40 */
41
42 #define _STDAPP
43 #define _LOWLVL
44 #include "steel/Steel.h"
45
46 #include "steel/buttons.h"
47 #include "steel/fontMenu.h"
48 #include "steel/akbd.h"
49 #include "steel/bbc.h"
50 #include "steel/buffer.h"
51 #include "steel/font.h"
52
53 /*
54 * Glass headers
55 */
56
57 #include "gStruct.h"
58 #include "gMenus.h"
59 #include "gIcons.h"
60
61 #include "glass.h"
62 #include "tfile.h"
63 #include "window.h"
64 #include "intMsgs.h"
65 #include "editIcon.h"
66 #include "colSelect.h"
67 #include "indir.h"
68 #include "gPrefs.h"
69
70 /*----- Static variables --------------------------------------------------*/
71
72 static char *editIcon__panels[]=
73 {
74 "iconData",
75 "iconAppear",
76 "iconActions",
77 "iconColours",
78 "iconPos",
79 "iconSize",
80 };
81
82 /*----- Support routines --------------------------------------------------*/
83
84 #define max2(a,b) ((a)>(b) ? (a) : (b))
85 #define min2(a,b) ((a)<(b) ? (a) : (b))
86
87 /*
88 * void editIcon__setupPanel(glass_editIcon *ed)
89 *
90 * Use
91 * Sets up a panel from the icon description given.
92 *
93 * Parameters
94 * glass_editIcon *ed == the edit to handle.
95 */
96
97 static void editIcon__setupPanel(glass_editIcon *ed)
98 {
99 char *p;
100
101 switch (ed->e.panel)
102 {
103 case glass_EIDATA:
104 dbox_setfield(ed->e.pd,glass_EIDVALSTRING,"%s",ed->valid);
105 dbox_setfield(ed->e.pd,glass_EIDDATA,"%s",ed->data);
106 if (!(ed->idef.flags&3))
107 {
108 dbox_shadeicon(ed->e.pd,glass_EIDINDIR,TRUE);
109 dbox_shadeicon(ed->e.pd,glass_EIDDATA,TRUE);
110 dbox_selecticon(ed->e.pd,glass_EIDINDIR,FALSE);
111 dbox_selecticon(ed->e.pd,glass_EIDVALID,FALSE);
112 dbox_shadeicon(ed->e.pd,glass_EIDVALSTRING,TRUE);
113 dbox_shadeicon(ed->e.pd,glass_EIDVALID,TRUE);
114 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,TRUE);
115 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,TRUE);
116 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,TRUE);
117 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,TRUE);
118 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,TRUE);
119 dbox_setfield(ed->e.pd,glass_EIDINDSIZE,"%i",12);
120 }
121 else if (ed->idef.flags & wimp_INDIRECT)
122 {
123 dbox_shadeicon(ed->e.pd,glass_EIDINDIR,FALSE);
124 dbox_shadeicon(ed->e.pd,glass_EIDDATA,FALSE);
125 dbox_selecticon(ed->e.pd,glass_EIDINDIR,TRUE);
126 dbox_selecticon(ed->e.pd,glass_EIDVALID,ed->hasValid);
127 dbox_shadeicon(ed->e.pd,glass_EIDVALSTRING,!ed->hasValid);
128 dbox_shadeicon(ed->e.pd,glass_EIDVALID,
129 !(ed->idef.flags&wimp_ITEXT));
130 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,FALSE);
131 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,FALSE);
132 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,FALSE);
133 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,FALSE);
134 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,FALSE);
135 dbox_setfield(ed->e.pd,glass_EIDINDSIZE,"%i",ed->indLen);
136 }
137 else
138 {
139 dbox_shadeicon(ed->e.pd,glass_EIDINDIR,FALSE);
140 dbox_shadeicon(ed->e.pd,glass_EIDDATA,FALSE);
141 dbox_selecticon(ed->e.pd,glass_EIDINDIR,FALSE);
142 dbox_selecticon(ed->e.pd,glass_EIDVALID,FALSE);
143 dbox_shadeicon(ed->e.pd,glass_EIDVALSTRING,TRUE);
144 dbox_shadeicon(ed->e.pd,glass_EIDVALID,TRUE);
145 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,TRUE);
146 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,TRUE);
147 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,TRUE);
148 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,TRUE);
149 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,TRUE);
150 dbox_setfield(ed->e.pd,glass_EIDINDSIZE,"%i",12);
151 }
152 dbox_selecticon(ed->e.pd,glass_EIDTEXT,
153 !!(ed->idef.flags&wimp_ITEXT));
154 dbox_selecticon(ed->e.pd,glass_EIDSPRITE,
155 !!(ed->idef.flags&wimp_ISPRITE));
156 break;
157 case glass_EIAPPEARANCE:
158 dbox_setfield(ed->e.pd,glass_EIAFONTNAME,"%.%s",ed->font);
159 dbox_setfield(ed->e.pd,glass_EIAFSIZEWRITE,"%i",ed->fontSize);
160 if (ed->idef.flags & wimp_ITEXT)
161 {
162 if (ed->idef.flags & wimp_IFONT)
163 {
164 dbox_selecticon(ed->e.pd,glass_EIAFONT,TRUE);
165 dbox_shadeicon(ed->e.pd,glass_EIAFONTNAME,FALSE);
166 dbox_shadeicon(ed->e.pd,glass_EIAFONTMENU,FALSE);
167 dbox_shadeicon(ed->e.pd,glass_EIAFONT,FALSE);
168 dbox_shadeicon(ed->e.pd,glass_EIAFSIZEUP,FALSE);
169 dbox_shadeicon(ed->e.pd,glass_EIAFSIZEDOWN,FALSE);
170 dbox_shadeicon(ed->e.pd,glass_EIAFSIZEWRITE,FALSE);
171 }
172 else
173 {
174 dbox_selecticon(ed->e.pd,glass_EIAFONT,FALSE);
175 dbox_shadeicon(ed->e.pd,glass_EIAFONT,FALSE);
176 dbox_shadeicon(ed->e.pd,glass_EIAFONTNAME,TRUE);
177 dbox_shadeicon(ed->e.pd,glass_EIAFONTMENU,TRUE);
178 dbox_shadeicon(ed->e.pd,glass_EIAFSIZEUP,TRUE);
179 dbox_shadeicon(ed->e.pd,glass_EIAFSIZEDOWN,TRUE);
180 dbox_shadeicon(ed->e.pd,glass_EIAFSIZEWRITE,TRUE);
181 }
182 }
183 else
184 {
185 dbox_selecticon(ed->e.pd,glass_EIAFONT,FALSE);
186 dbox_shadeicon(ed->e.pd,glass_EIAFONT,TRUE);
187 dbox_shadeicon(ed->e.pd,glass_EIAFONTNAME,TRUE);
188 dbox_shadeicon(ed->e.pd,glass_EIAFONTMENU,TRUE);
189 dbox_shadeicon(ed->e.pd,glass_EIAFSIZEUP,TRUE);
190 dbox_shadeicon(ed->e.pd,glass_EIAFSIZEDOWN,TRUE);
191 dbox_shadeicon(ed->e.pd,glass_EIAFSIZEWRITE,TRUE);
192 }
193 dbox_selecticon(ed->e.pd,glass_EIAHCENTRE,
194 !!(ed->idef.flags & wimp_IHCENTRE));
195 dbox_selecticon(ed->e.pd,glass_EIAVCENTRE,
196 !!(ed->idef.flags & wimp_IVCENTRE));
197 dbox_selecticon(ed->e.pd,glass_EIARALIGN,
198 !!(ed->idef.flags & wimp_IRJUST));
199 dbox_selecticon(ed->e.pd,glass_EIABORDER,
200 !!(ed->idef.flags & wimp_IBORDER));
201 dbox_selecticon(ed->e.pd,glass_EIAFILL,
202 !!(ed->idef.flags & wimp_IFILLED));
203 if (ed->idef.flags & wimp_ISPRITE)
204 {
205 dbox_selecticon(ed->e.pd,glass_EIAHALFSIZE,
206 !!(ed->idef.flags & wimp_IHALVESPRITE));
207 dbox_shadeicon(ed->e.pd,glass_EIAHALFSIZE,FALSE);
208 }
209 else
210 {
211 dbox_selecticon(ed->e.pd,glass_EIAHALFSIZE,FALSE);
212 dbox_shadeicon(ed->e.pd,glass_EIAHALFSIZE,TRUE);
213 }
214 dbox_selecticon(ed->e.pd,glass_EIANEEDSHELP,
215 !!(ed->idef.flags & wimp_IREDRAW));
216 break;
217 case glass_EIACTIONS:
218 p=buffer_find();
219 sprintf(p,"eiBTYPE%i",(ed->idef.flags>>12) & 0x0f);
220 dbox_setfield(ed->e.pd,glass_EIABTYPE,"%s",msgs_lookup(p));
221 dbox_setfield(ed->e.pd,glass_EIAESGWRITE,"%i",
222 (ed->idef.flags>>16) & 0x1f);
223 dbox_selecticon(ed->e.pd,glass_EIAADJUST,
224 !!(ed->idef.flags & wimp_IESG_NOC));
225 dbox_selecticon(ed->e.pd,glass_EIASELECT,
226 !!(ed->idef.flags & wimp_ISELECTED));
227 dbox_selecticon(ed->e.pd,glass_EIASHADE,
228 !!(ed->idef.flags & wimp_INOSELECT));
229 break;
230 case glass_EICOLOURS:
231 colSelect_setColourButton(ed->e.pd,glass_EICFORE,
232 (ed->idef.flags>>24) & 15);
233 colSelect_setColourButton(ed->e.pd,glass_EICBACK,
234 (ed->idef.flags>>28) & 15);
235 break;
236 case glass_EISIZE:
237 dbox_setfield(ed->e.pd,
238 glass_EIPWRITE,
239 "%i,%i",
240 ed->idef.box.x1-ed->idef.box.x0,
241 ed->idef.box.y1-ed->idef.box.y0);
242 dbox_shadeicon(ed->e.pd,glass_EIPSETSIZE,!(ed->idef.flags & 3));
243 break;
244 case glass_EIPOSITION:
245 dbox_setfield(ed->e.pd,
246 glass_EIPWRITE,
247 "%i,%i",
248 ed->idef.box.x0,
249 ed->idef.box.y0);
250 break;
251 }
252 }
253
254 /*
255 * BOOL editIcon__getSpriteSize(char *name,sprite_area *a,int *x,int *y)
256 *
257 * Use
258 * Attempts to read the size of a sprite in OS units.
259 *
260 * Returns
261 * TRUE if it really worked
262 */
263
264 static BOOL editIcon__getSpriteSize(char *name,sprite_area *a,int *x,int *y)
265 {
266 os_error *e;
267 os_regset r;
268
269 /* --- First look in the given area --- */
270
271 e=os_swivr(OS_SpriteOp,&r,40+256,a,name);
272
273 /* --- Now, OS version permitting, look in the WIMP area --- */
274
275 if (e && wimpt_getVersion()>=300)
276 e=os_swivr(Wimp_SpriteOp,&r,40,0,name);
277
278 /* --- If it worked, read out all the info and return it --- */
279
280 if (!e)
281 {
282 *x=r.r[3]<<bbc_modevar(r.r[6],bbc_XEigFactor);
283 *y=r.r[4]<<bbc_modevar(r.r[6],bbc_YEigFactor);
284 }
285
286 /* --- Return the success value --- */
287
288 return (!e);
289 }
290
291 /*
292 * void editIcon__setSize(glass_editIcon *ed)
293 *
294 * Use
295 * Reads the size of the icon correctly from the definition, assuming
296 * various things:
297 *
298 * 1. The icon isn't word-wrapped
299 * 2. Both selected and unselected versions of the sprite to use are the
300 * same size
301 * 3. Size is independent of things like button type
302 */
303
304 static void editIcon__setSize(glass_editIcon *ed)
305 {
306 int w,h;
307 int sw,sh;
308 char sname[15];
309 static int posns[]={1,1,2,2,1,1,3,2};
310 int f;
311 char *sprname;
312
313 /* --- Read the current width and height from dbox --- */
314
315 dbox_scanfield(ed->e.pd,glass_EIPWRITE,"%d,%d",&w,&h);
316
317 /* --- Find out if this is going to be easy --- */
318
319 switch (ed->idef.flags & 3)
320 {
321 /* --- No icon data -- ignore this operation --- */
322
323 case 0:
324 break;
325
326 /* --- Only text -- work it out (assuming system font size) --- */
327
328 case 1:
329 h=48;
330 w=16*(strlen(ed->data)+1);
331 break;
332
333 /* --- Only a sprite -- use the size of the sprite --- */
334
335 case 2:
336 if (!editIcon__getSpriteSize(ed->data,ed->w->t->s,&w,&h))
337 note(msgs_lookup("eiSPRGONE"),ed->data);
338 break;
339
340 /* --- Text and sprite together --- */
341
342 case 3:
343 sprname=ed->data;
344
345 if ((ed->idef.flags & 0x100) && ed->hasValid)
346 {
347 /* --- Parse the validation string to find the sprite name --- */
348
349 int state=1;
350 char *p=ed->valid;
351 char *q=sname;
352
353 for (;*p>31 && state!=3;p++)
354 {
355 switch (*p)
356 {
357 case '\\':
358 if (p[1]>31)
359 p++;
360 if (state==1)
361 state=0;
362 else if (state==2)
363 *q++=*p;
364 break;
365 case ';':
366 if (state>1)
367 {
368 *q++=0;
369 state=3;
370 }
371 else
372 state=1;
373 break;
374 case 'S':
375 case 's':
376 if (state==1)
377 state=2;
378 else if (state==2)
379 *q++=*p;
380 break;
381 case ',':
382 switch (state)
383 {
384 case 2:
385 *q++=0;
386 state++;
387 }
388 break;
389 default:
390 switch (state)
391 {
392 case 1:
393 state=0;
394 break;
395 case 2:
396 *q++=*p;
397 break;
398 }
399 break;
400 }
401 }
402
403 if (state==2)
404 {
405 *q++=0;
406 state=3;
407 }
408
409 if (state==3)
410 sprname=sname;
411 }
412
413 if (editIcon__getSpriteSize(sprname,ed->w->t->s,&sw,&sh))
414 {
415 if (ed->data[0])
416 {
417 h=48;
418 w=16*(strlen(ed->data)+1);
419
420 f=posns[(tst(ed->idef.flags,3)<<2) |
421 (tst(ed->idef.flags,4)<<1) |
422 (tst(ed->idef.flags,9)<<0)];
423
424 if (f & 2)
425 h=max2(h,sh);
426 else
427 h+=sh;
428
429 if (f & 1)
430 w=max2(w,sw);
431 else
432 w+=sw;
433 }
434 else
435 {
436 h=sh;
437 w=sw;
438 }
439 }
440 else
441 note(msgs_lookup("eiSPRGONE"),sprname);
442 break;
443 }
444
445 dbox_setfield(ed->e.pd,glass_EIPWRITE,"%i,%i",w,h);
446 }
447
448 /*
449 * void editIcon__closePanel(glass_editIcon *ed)
450 *
451 * Use
452 * Records the settings in a panel for future reference, for example when
453 * the panel is being replaced by a different one.
454 *
455 * Parameters
456 * glass_editIcon *ed == the edit box we're talking about
457 */
458
459 #define Q dbox_READSTATE
460
461 static void editIcon__closePanel(glass_editIcon *ed)
462 {
463 int esg;
464 int x,y;
465 switch (ed->e.panel)
466 {
467 case glass_EIDATA:
468 dbox_getfield(ed->e.pd,glass_EIDDATA,ed->data,256);
469 dbox_getfield(ed->e.pd,glass_EIDVALSTRING,ed->valid,256);
470 dbox_scanfield(ed->e.pd,glass_EIDINDSIZE,"%d",&ed->indLen);
471 ed->hasValid=dbox_selecticon(ed->e.pd,glass_EIDVALID,Q);
472 ed->idef.flags&=~0x00000103;
473 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIDTEXT,Q)<<0;
474 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIDSPRITE,Q)<<1;
475 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIDINDIR,Q)<<8;
476 break;
477 case glass_EIAPPEARANCE:
478 ed->idef.flags&=~0x00000afc;
479 dbox_scanfield(ed->e.pd,glass_EIAFSIZEWRITE,"%d",&ed->fontSize);
480 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIAHCENTRE,Q)<<3;
481 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIAVCENTRE,Q)<<4;
482 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIABORDER,Q)<<2;
483 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIAFILL,Q)<<5;
484 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIAFONT,Q)<<6;
485 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIANEEDSHELP,Q)<<7;
486 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIARALIGN,Q)<<9;
487 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIAHALFSIZE,Q)<<11;
488 break;
489 case glass_EIACTIONS:
490 ed->idef.flags&=~0x007f0400;
491 dbox_scanfield(ed->e.pd,glass_EIAESGWRITE,"%d",&esg);
492 ed->idef.flags|=esg<<16;
493 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIAADJUST,Q)<<10;
494 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIASELECT,Q)<<21;
495 ed->idef.flags|=dbox_selecticon(ed->e.pd,glass_EIASHADE,Q)<<22;
496 break;
497 case glass_EISIZE:
498 dbox_scanfield(ed->e.pd,glass_EIPWRITE,"%d,%d",&x,&y);
499 ed->idef.box.x1=ed->idef.box.x0+x;
500 ed->idef.box.y1=ed->idef.box.y0+y;
501 break;
502 case glass_EIPOSITION:
503 dbox_scanfield(ed->e.pd,glass_EIPWRITE,"%d,%d",&x,&y);
504 ed->idef.box.x1+=x-ed->idef.box.x0;
505 ed->idef.box.y1+=y-ed->idef.box.y0;
506 ed->idef.box.x0=x;
507 ed->idef.box.y0=y;
508 break;
509 }
510 }
511
512 #undef Q
513
514 /*
515 * void editIcon__setPanel(glass_editIcon *ed,dbox_field f)
516 *
517 * Use
518 * Creates a new panel based on a radio button click or some-such.
519 *
520 * Parameters
521 * glass_editIcon *ed == the edit window to change panel
522 * dbox_field f == the radio button associated with the desired panel
523 */
524
525 static void editIcon__panelHandler(dbox d,dbox_field f,void *handle);
526 static BOOL editIcon__panelRaw(dbox d,wimp_eventstr *e,void *handle);
527
528 static void editIcon__setPanel(glass_editIcon *ed,dbox_field f)
529 {
530 dbox d;
531 wimp_wstate s;
532 wimp_icon i;
533 int width,height;
534 int ox,oy;
535 wimp_w behind;
536 wimp_caretstr c;
537 BOOL ownCaret=TRUE;
538 if (f==ed->e.panel)
539 return;
540 editIcon__closePanel(ed);
541 wimpt_noerr(wimp_get_wind_state(dbox_syshandle(ed->e.d),&s));
542 wimpt_noerr(wimp_get_icon_info(dbox_syshandle(ed->e.d),
543 glass_EIPOSN,&i));
544 ox=s.o.box.x0-s.o.x;
545 oy=s.o.box.y1-s.o.y;
546 mem_useUser(indir_alloc,indir_free);
547 if (f==-1)
548 d=dbox_create("iconNowt");
549 else
550 d=dbox_create(editIcon__panels[f-glass_EIDATA]);
551 if (!d)
552 {
553 mem_useMalloc();
554 return;
555 }
556 dbox_eventHandler(d,editIcon__panelHandler,ed);
557 dbox_rawEventHandler(d,editIcon__panelRaw,ed);
558 if (ed->e.panel)
559 {
560 wimpt_noerr(wimp_get_caret_pos(&c));
561 ownCaret=(c.w==dbox_syshandle(ed->e.pd));
562 dbox_selecticon(ed->e.d,ed->e.panel,dbox_RESETSTATE);
563 wimpt_noerr(wimp_get_wind_state(dbox_syshandle(ed->e.pd),&s));
564 pane_removePane(ed->e.p,dbox_syshandle(ed->e.pd));
565 dbox_delete(ed->e.pd);
566 }
567 dbox_selecticon(ed->e.d,f,dbox_SETSTATE);
568 behind=s.o.behind;
569 wimpt_noerr(wimp_get_wind_state(dbox_syshandle(d),&s));
570 width=s.o.box.x1-s.o.box.x0;
571 height=s.o.box.y1-s.o.box.y0;
572 s.o.box.x0=i.box.x0+ox+wimpt_dx();
573 s.o.box.y0=i.box.y0+oy+wimpt_dy();
574 s.o.box.x1=s.o.box.x0+width;
575 s.o.box.y1=s.o.box.y0+height;
576 s.o.y=10000;
577 s.o.behind=behind;
578 ed->e.pd=d;
579 ed->e.panel=f;
580 editIcon__setupPanel(ed);
581 wimpt_noerr(wimp_open_wind(&s.o));
582 if (ownCaret)
583 {
584 c.w=dbox_syshandle(d);
585 c.i=-1;
586 c.x=-500000;
587 c.y=0;
588 c.height=0x02000000;
589 wimpt_noerr(wimp_set_caret_pos(&c));
590 }
591 pane_addPane(ed->e.p,dbox_syshandle(d));
592 mem_useMalloc();
593 }
594
595 /*
596 * void editIcon__recreate(glass_editIcon *ed)
597 *
598 * Use
599 * Recreates the icon from the dialogue box settings
600 *
601 * Parameters
602 * glass_editIcon *ed == info about the edit
603 */
604
605 static void editIcon__recreate(glass_editIcon *ed)
606 {
607 char *p=0;
608 char *q=0;
609 int inum;
610 int fhandle;
611 ed->w->def->i[ed->i].edit=0; /* Delink temporarily */
612 window_redrawIcon(ed->w,ed->i); /* Force redraw of old icon */
613
614 if (!(ed->idef.flags & wimp_INDIRECT))
615 {
616 ed->indLen=12;
617 ed->hasValid=FALSE;
618 }
619 if (strlen(ed->data)>=ed->indLen)
620 {
621 ed->idef.flags|=wimp_INDIRECT;
622 ed->indLen=strlen(ed->data)+1;
623 }
624 if (ed->idef.flags & wimp_INDIRECT)
625 {
626 if (p=indir_alloc(ed->indLen),!p)
627 {
628 werr(FALSE,msgs_lookup("eiNEMUI"));
629 return;
630 }
631 if (ed->hasValid && (ed->idef.flags & wimp_ITEXT))
632 {
633 if (q=indir_alloc(strlen(ed->valid)+1),!q)
634 {
635 indir_free(p);
636 werr(FALSE,msgs_lookup("eiNEMUI"));
637 return;
638 }
639 strcpy(q,ed->valid);
640 ed->w->size+=strlen(ed->valid)+1;
641 }
642 strcpy(p,ed->data);
643 ed->w->size+=ed->indLen;
644 }
645
646 if (ed->w->def->i[ed->i].i.flags & wimp_IFONT) /* Was old anti? */
647 {
648 fhandle=(ed->w->def->i[ed->i].i.flags >> 24) & 255;
649 wimpt_noerr(font_lose(fhandle));
650 ed->w->fonts[fhandle]--;
651 }
652 if (ed->idef.flags & wimp_IFONT) /* Is new icon antialiased? */
653 {
654 if (font_find(ed->font,ed->fontSize*16,ed->fontSize*16,0,0,&fhandle))
655 {
656 werr(FALSE,msgs_lookup("eiCFF"),ed->font);
657 ed->idef.flags&=~wimp_IFONT;
658 }
659 else
660 {
661 ed->w->antiAliased=TRUE;
662 ed->w->fonts[fhandle]++;
663 ed->idef.flags=(ed->idef.flags & 0x00ffffff) | (fhandle<<24);
664 }
665 }
666
667 if (ed->w->def->i[ed->i].i.flags & wimp_INDIRECT)
668 {
669 indir_free(ed->w->def->i[ed->i].i.data.indirecttext.buffer);
670 ed->w->size-=ed->w->def->i[ed->i].i.data.indirecttext.bufflen;
671 if ((ed->w->def->i[ed->i].i.flags & wimp_ITEXT) &&
672 (ed->w->def->i[ed->i].i.data.indirecttext.validstring!=(char *)-1))
673 {
674 utils_ctermToNterm(ed->w->def->i[ed->i].
675 i.data.indirecttext.validstring);
676 ed->w->size-=
677 strlen(ed->w->def->i[ed->i].i.data.indirecttext.validstring)+1;
678 indir_free(ed->w->def->i[ed->i].i.data.indirecttext.validstring);
679 }
680 }
681
682 if (p)
683 {
684 ed->idef.data.indirecttext.buffer=p;
685 ed->idef.data.indirecttext.bufflen=ed->indLen;
686 if (q)
687 ed->idef.data.indirecttext.validstring=q;
688 else if (ed->idef.flags & wimp_ITEXT)
689 ed->idef.data.indirecttext.validstring=(char *)-1;
690 else
691 ed->idef.data.indirectsprite.spritearea=ed->w->t->s;
692 }
693 else
694 memcpy(ed->idef.data.text,ed->data,12);
695
696 ed->w->def->i[ed->i].i=ed->idef;
697 dbox_scanfield(ed->e.d,glass_EINUMWRITE,"%d",&inum);
698 if (!window_renumber(ed->w,ed->i,inum))
699 dbox_setfield(ed->e.d,glass_EINUMWRITE,"%i",ed->i);
700 else
701 ed->i=inum;
702
703 window_redrawIcon(ed->w,ed->i); /* Force redraw of new icon */
704 ed->w->def->i[ed->i].edit=ed; /* Relink again */
705 tfile_markAsAltered(ed->w->t);
706 }
707
708 /*
709 * void editIcon__nextPanel(glass_editIcon *ed,int dir)
710 *
711 * Use
712 * Changes panel to the next one in the given direction. Skips shaded
713 * panels and handles everything nicely.
714 *
715 * Parameters
716 * glass_editIcon *ed == the edit dialogue box to move about in
717 * int dir == the direction (-1 for up, 1 for down)
718 */
719
720 static void editIcon__nextPanel(glass_editIcon *ed,int dir)
721 {
722 int i=ed->e.panel;
723
724 if (i==-1)
725 i=(dir==1 ? glass_EIDATA : glass_EISIZE);
726 else
727 i+=dir;
728
729 for (;i>=glass_EIDATA && i<=glass_EISIZE;i+=dir)
730 {
731 if (!dbox_shadeicon(ed->e.d,i,dbox_READSTATE))
732 {
733 editIcon__setPanel(ed,i);
734 break;
735 }
736 }
737 }
738
739 /*----- Event handlers ----------------------------------------------------*/
740
741 /*
742 * void editIcon__dboxHandler(dbox d,dbox_field f,void *handle)
743 *
744 * Use
745 * Handles any and all events directed at the dbox. Well, almost all...
746 *
747 * Parameters
748 * dbox d == the dbox handle
749 * dbox_field f == the event that happened
750 * void *handle == pointer to the dialogue box control info
751 */
752
753 static void editIcon__dboxHandler(dbox d,dbox_field f,void *handle)
754 {
755 glass_editIcon *ed=handle;
756 buttons_simpleArrow sa={0,9999,FALSE};
757
758 switch (f)
759 {
760 case dbox_CLOSE:
761 if (ed->e.pd)
762 dbox_deleteNoUpdate(ed->e.pd);
763 pane_delete(ed->e.p);
764 dbox_delete(ed->e.d);
765 ed->w->def->i[ed->i].edit=0;
766 mem_free(ed);
767 break;
768 case dbox_HELP:
769 help_startHelp();
770 help_addLine(msgs_lookup("eihEIDB"));
771 help_readFromIcon();
772 help_endHelp();
773 break;
774 case glass_EICAN:
775 dbox_clickicon(d,f);
776 if (!dbox_wasAdjustClick())
777 pane_close(ed->e.p);
778 else
779 {
780 /* --- set up for old icon --- */
781 ed->idef=ed->w->def->i[ed->i].i;
782 editIcon_readData(ed->w,ed->i);
783 dbox_setfield(ed->e.d,glass_EINUMWRITE,"%i",ed->i);
784 editIcon__setupPanel(ed);
785 }
786 dbox_unclick();
787 if (!dbox_wasAdjustClick())
788 editIcon_close(ed->w,ed->i);
789 break;
790 case glass_EIOK:
791 dbox_clickicon(d,f);
792 editIcon__closePanel(ed);
793 if (!dbox_wasAdjustClick())
794 {
795 pane_close(ed->e.p);
796 editIcon__recreate(ed);
797 dbox_unclick();
798 editIcon_close(ed->w,ed->i);
799 }
800 else
801 {
802 editIcon__recreate(ed);
803 editIcon_readData(ed->w,ed->i);
804 editIcon__setupPanel(ed);
805 dbox_unclick();
806 }
807 break;
808 case glass_EIDELETE:
809 dbox_clickicon(d,f);
810 if (gPrefs_current()->cDelIcon)
811 {
812 if (!warning(msgs_lookup("eiCDIP"),
813 msgs_lookup("eiCDI")))
814 {
815 dbox_unclick();
816 return;
817 }
818 }
819 pane_close(ed->e.p);
820 dbox_unclick();
821 window_deleteIcon(ed->w,ed->i); /* Closes the edit for us */
822 break;
823 case glass_EIDATA:
824 case glass_EIAPPEARANCE:
825 case glass_EIACTIONS:
826 case glass_EICOLOURS:
827 case glass_EIPOSITION:
828 case glass_EISIZE:
829 editIcon__setPanel(ed,f);
830 break;
831 case glass_EINUMUP:
832 buttons_arrow(d,f,d,glass_EINUMWRITE,0,+1,&sa);
833 break;
834 case glass_EINUMDOWN:
835 buttons_arrow(d,f,d,glass_EINUMWRITE,0,-1,&sa);
836 break;
837 }
838 }
839
840 /*
841 * BOOL editIcon__dboxRaw(dbox d,wimp_eventstr *e,void *handle)
842 *
843 * Use
844 * Handles open window requests and things for the main Preferences dbox.
845 *
846 * Parameters
847 * dbox d == the dbox handle
848 * wimp_eventstr *e == the event that happened
849 * void *handle == a unused pointer
850 *
851 * Returns
852 * TRUE if the event has been handled;
853 */
854
855 static BOOL editIcon__dboxRaw(dbox d,wimp_eventstr *e,void *handle)
856 {
857 BOOL handled=FALSE;
858 glass_editIcon *ed=handle;
859 glass_intMsgstr *m;
860 unused(d);
861 switch (e->e)
862 {
863 case wimp_EOPEN:
864 pane_moved(ed->e.p);
865 handled=TRUE;
866 break;
867 case wimp_EKEY:
868 switch (e->data.key.chcode)
869 {
870 case akbd_UpK+akbd_Sh:
871 editIcon__nextPanel(ed,-1);
872 handled=TRUE;
873 break;
874 case akbd_DownK+akbd_Sh:
875 editIcon__nextPanel(ed,+1);
876 handled=TRUE;
877 break;
878 }
879 break;
880 case wimp_ESEND:
881 case wimp_ESENDWANTACK:
882 switch (e->data.msg.hdr.action)
883 {
884 case wimp_MINTERNAL:
885 m=intMsgs_receive(e);
886 switch(e->data.msg.data.words[0])
887 {
888 case glass_DELETEFILE:
889 if (m->df.t==ed->w->t)
890 editIcon_close(ed->w,ed->i);
891 break;
892 case glass_DELETEWINDOW:
893 if (m->dw.w==ed->w)
894 editIcon_close(ed->w,ed->i);
895 break;
896 case glass_RENAME:
897 if (m->rn.w==ed->w)
898 dbox_setfield(ed->e.d,glass_EIWINDISP,"%s",ed->w->id);
899 break;
900 }
901 break;
902 }
903 break;
904 }
905 return (handled);
906 }
907
908 /*
909 * menu editIcon__fontMaker(void *handle)
910 *
911 * Use
912 * Sets up the font menu.
913 *
914 * Parameters
915 * void *handle == pointer to this edit
916 *
917 * Returns
918 * A menu to display
919 */
920
921 static menu editIcon__fontMaker(void *handle)
922 {
923 glass_editIcon *ed=handle;
924 menu m=fontMenu_createFontMenu(FALSE);
925 fontMenu_tickGivenName(ed->font);
926 return (m);
927 }
928
929 /*
930 * void editIcon__fontHandler(int hit[],void *handle)
931 *
932 * Use
933 * Gets the font chosen from the font menu.
934 *
935 * Parameters
936 * int hit[] == the hit string
937 * void *handle == pointer to this edit
938 */
939
940 static void editIcon__fontHandler(int hit[],void *handle)
941 {
942 glass_editIcon *ed=handle;
943 if (hit[0])
944 {
945 strcpy(ed->font,fontMenu_fontname(hit[0],hit[1]));
946 dbox_setfield(ed->e.pd,glass_EIAFONTNAME,"%.%s",ed->font);
947 }
948 }
949
950 /*
951 * void editIcon__fontHelp(int hit[],void *handle)
952 *
953 * Use
954 * Gives help on a font menu item
955 *
956 * Parameters
957 * int hit[] == the hit string
958 * void *handle == pointer to this edit
959 */
960
961 static void editIcon__fontHelp(int hit[],void *handle)
962 {
963 unused(handle);
964 if (hit[0])
965 {
966 help_startHelp();
967 help_addLine(msgs_lookup("eimhFONT"),fontMenu_fontname(hit[0],hit[1]));
968 help_endHelp();
969 }
970 }
971
972 /*
973 * menu editIcon__btypeMaker(void *handle)
974 *
975 * Use
976 * Generates and sets up a button type menu for an edit dialogue box
977 *
978 * Parameters
979 * void *handle == pointer to the edit
980 *
981 * Returns
982 * The menu to use
983 */
984
985 static menu editIcon__btypeMaker(void *handle)
986 {
987 static menu m;
988 static int ticked;
989 glass_editIcon *ed=handle;
990 int i;
991 char *buf=buffer_find();
992 if (!m)
993 {
994 m=menu_new(msgs_lookup("eiBTMT"),msgs_lookup("eiBTYPE0"));
995 for (i=1;i<=15;i++)
996 {
997 sprintf(buf,"eiBTYPE%i",i);
998 menu_extend(m,msgs_lookup(buf));
999 }
1000 }
1001 if (ticked)
1002 menu_setflags(m,ticked,FALSE,FALSE);
1003 ticked=((ed->idef.flags>>12)&0x0f)+1;
1004 menu_setflags(m,ticked,TRUE,FALSE);
1005 return (m);
1006 }
1007
1008 /*
1009 * void editIcon__btypeHandler(int hit[],void *handle)
1010 *
1011 * Use
1012 * Handles a click on the button type menu.
1013 *
1014 * Parameters
1015 * int hit[] == the mouse click info
1016 * void *handle == pointer to edit information
1017 */
1018
1019 static void editIcon__btypeHandler(int hit[],void *handle)
1020 {
1021 glass_editIcon *ed=handle;
1022 char *buf=buffer_find();
1023 if (hit[0])
1024 {
1025 ed->idef.flags&=~0x0000f000;
1026 ed->idef.flags+=(hit[0]-1)<<12;
1027 sprintf(buf,"eiBTYPE%i",hit[0]-1);
1028 dbox_setfield(ed->e.pd,glass_EIABTYPE,"%s",msgs_lookup(buf));
1029 }
1030 }
1031
1032 /*
1033 * void editIcon__colProc(dbox d,dbox_field f,int colour, void *handle)
1034 *
1035 * Use
1036 * This routine is called when a colour is selected in the colours panel.
1037 *
1038 * Parameters
1039 * dbox d == the panel's handle
1040 * dbox_field f == the colour button that has changed
1041 * int colour == the new colour for the button
1042 * void *handle == pointer to this edit
1043 */
1044
1045 static void editIcon__colProc(dbox d,dbox_field f,int colour,void *handle)
1046 {
1047 glass_editIcon *ed=handle;
1048 unused(d);
1049 switch (f)
1050 {
1051 case glass_EICFORE:
1052 ed->idef.flags=(ed->idef.flags & ~0x0f000000)+(colour<<24);
1053 break;
1054 case glass_EICBACK:
1055 ed->idef.flags=(ed->idef.flags & ~0xf0000000)+(colour<<28);
1056 break;
1057 }
1058 }
1059
1060 /*
1061 * void editIcon__btypeHelp(int hit[],void *handle)
1062 *
1063 * Use
1064 * Handles a help request for the button type menu.
1065 *
1066 * Parameters
1067 * int hit[] == the helpq info
1068 * void *handle == pointer to edit information
1069 */
1070
1071 static void editIcon__btypeHelp(int hit[],void *handle)
1072 {
1073 char *buf=buffer_find();
1074 unused(handle);
1075 if (hit[0])
1076 {
1077 help_startHelp();
1078 sprintf(buf,"eiBTYPE%i",hit[0]-1);
1079 help_addLine(msgs_lookup("eimhBTYPE"),msgs_lookup(buf));
1080 help_endHelp();
1081 }
1082 }
1083
1084 /*
1085 * void editIcon__posSizeArrows(dbox d,dbox_field f,int diff,void *handle)
1086 *
1087 * Use
1088 * Handles a click event on one of the position or size arrow buttons in
1089 * the dialogue box. See the structure definition below for a description
1090 * of the data structure required.
1091 */
1092
1093 typedef struct
1094 {
1095 BOOL xOrY;
1096 BOOL sizing;
1097 }
1098 editIcon__posSizeArrowstr;
1099
1100 static void editIcon__posSizeArrows(dbox d,
1101 dbox_field f,
1102 int diff,
1103 void *handle)
1104 {
1105 editIcon__posSizeArrowstr *s=handle;
1106 int x,y;
1107 int *v;
1108
1109 dbox_scanfield(d,f,"%d,%d",&x,&y);
1110 v=s->xOrY ? &x : &y;
1111 *v+=diff;
1112 if (s->sizing && *v<0)
1113 *v=0;
1114 dbox_setfield(d,f,"%i,%i",x,y);
1115 }
1116
1117 /*
1118 * void editIcon__panelHandler(dbox d,dbox_field f,void *handle)
1119 *
1120 * Use
1121 * Handles simple click events for the current panel in an edit dbox
1122 *
1123 * Parameters
1124 * dbox d == the panel's dbox handle
1125 * dbox_field f == the icon that was clicked
1126 * void *handle == pointer to edit information
1127 */
1128
1129 static void editIcon__panelHandler(dbox d,dbox_field f,void *handle)
1130 {
1131 glass_editIcon *ed=handle;
1132 buttons_simpleArrow sa={0,9999,FALSE};
1133 buttons_simpleArrow esga={0,31,FALSE};
1134 editIcon__posSizeArrowstr psa={0,FALSE};
1135 BOOL indon;
1136
1137 switch (f)
1138 {
1139 case dbox_CLOSE:
1140 case dbox_HELP:
1141 case glass_EIOK:
1142 case glass_EICAN:
1143 editIcon__dboxHandler(ed->e.d,f,ed);
1144 return;
1145 break;
1146 }
1147 switch (ed->e.panel)
1148 {
1149 case glass_EIDATA:
1150 switch (f)
1151 {
1152 case glass_EIDINDIR:
1153 if (dbox_selecticon(d,f,dbox_READSTATE))
1154 {
1155 if (dbox_selecticon(ed->e.pd,glass_EIDTEXT,dbox_READSTATE))
1156 {
1157 dbox_shadeicon(ed->e.pd,glass_EIDVALID,FALSE);
1158 dbox_shadeicon(ed->e.pd,
1159 glass_EIDVALSTRING,
1160 !dbox_selecticon(ed->e.pd,
1161 glass_EIDVALID,
1162 dbox_READSTATE));
1163 }
1164 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,FALSE);
1165 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,FALSE);
1166 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,FALSE);
1167 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,FALSE);
1168 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,FALSE);
1169 }
1170 else
1171 {
1172 dbox_shadeicon(ed->e.pd,glass_EIDVALSTRING,TRUE);
1173 dbox_shadeicon(ed->e.pd,glass_EIDVALID,TRUE);
1174 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,TRUE);
1175 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,TRUE);
1176 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,TRUE);
1177 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,TRUE);
1178 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,TRUE);
1179 }
1180 break;
1181 case glass_EIDINDUP:
1182 buttons_arrow(ed->e.pd,f,ed->e.pd,glass_EIDINDSIZE,0,+1,&sa);
1183 break;
1184 case glass_EIDINDDOWN:
1185 buttons_arrow(ed->e.pd,f,ed->e.pd,glass_EIDINDSIZE,0,-1,&sa);
1186 break;
1187 case glass_EIDVALID:
1188 dbox_shadeicon(ed->e.pd,glass_EIDVALSTRING,dbox_TOGGLESTATE);
1189 break;
1190 case glass_EIDMINIMISE:
1191 dbox_clickicon(d,f);
1192 dbox_getfield(d,glass_EIDDATA,ed->data,256);
1193 dbox_setfield(d,glass_EIDINDSIZE,"%i",strlen(ed->data)+1);
1194 dbox_unclick();
1195 break;
1196 case glass_EIDTEXT:
1197 if (dbox_selecticon(ed->e.pd,glass_EIDTEXT,dbox_READSTATE))
1198 {
1199 dbox_shadeicon(ed->e.pd,glass_EIDDATA,FALSE);
1200 dbox_shadeicon(ed->e.pd,glass_EIDINDIR,FALSE);
1201 if (dbox_selecticon(d,glass_EIDINDIR,dbox_READSTATE))
1202 {
1203 dbox_shadeicon(ed->e.pd,glass_EIDVALID,FALSE);
1204 dbox_shadeicon(ed->e.pd,glass_EIDVALSTRING,
1205 !dbox_selecticon(ed->e.pd,glass_EIDVALID,dbox_READSTATE));
1206 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,FALSE);
1207 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,FALSE);
1208 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,FALSE);
1209 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,FALSE);
1210 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,FALSE);
1211 }
1212 else
1213 {
1214 dbox_shadeicon(ed->e.pd,glass_EIDVALID,TRUE);
1215 dbox_shadeicon(ed->e.pd,glass_EIDVALSTRING,TRUE);
1216 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,TRUE);
1217 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,TRUE);
1218 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,TRUE);
1219 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,TRUE);
1220 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,TRUE);
1221 }
1222 dbox_shadeicon(ed->e.d,glass_EICOLOURS,
1223 !!(ed->idef.flags & wimp_IFONT));
1224 }
1225 else
1226 {
1227 dbox_shadeicon(ed->e.pd,glass_EIDVALID,TRUE);
1228 dbox_shadeicon(ed->e.pd,glass_EIDVALSTRING,TRUE);
1229 if (dbox_selecticon(d,glass_EIDSPRITE,dbox_READSTATE))
1230 {
1231 dbox_shadeicon(ed->e.pd,glass_EIDDATA,FALSE);
1232 dbox_shadeicon(ed->e.pd,glass_EIDINDIR,FALSE);
1233 indon=dbox_selecticon(d,glass_EIDINDIR,dbox_READSTATE);
1234 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,!indon);
1235 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,!indon);
1236 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,!indon);
1237 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,!indon);
1238 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,!indon);
1239 }
1240 else
1241 {
1242 dbox_shadeicon(ed->e.pd,glass_EIDDATA,TRUE);
1243 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,TRUE);
1244 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,TRUE);
1245 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,TRUE);
1246 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,TRUE);
1247 dbox_shadeicon(ed->e.pd,glass_EIDINDIR,TRUE);
1248 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,TRUE);
1249 }
1250 dbox_shadeicon(ed->e.d,glass_EICOLOURS,FALSE);
1251 }
1252 break;
1253 case glass_EIDSPRITE:
1254 if (dbox_selecticon(ed->e.pd,glass_EIDSPRITE,dbox_READSTATE))
1255 {
1256 dbox_shadeicon(ed->e.pd,glass_EIDDATA,FALSE);
1257 dbox_shadeicon(ed->e.pd,glass_EIDINDIR,FALSE);
1258 indon=dbox_selecticon(d,glass_EIDINDIR,dbox_READSTATE);
1259 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,!indon);
1260 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,!indon);
1261 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,!indon);
1262 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,!indon);
1263 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,!indon);
1264 }
1265 else if (!dbox_selecticon(ed->e.pd,glass_EIDTEXT,dbox_READSTATE))
1266 {
1267 dbox_shadeicon(ed->e.pd,glass_EIDDATA,TRUE);
1268 dbox_shadeicon(ed->e.pd,glass_EIDINDIR,TRUE);
1269 dbox_shadeicon(ed->e.pd,glass_EIDINDSIZE,TRUE);
1270 dbox_shadeicon(ed->e.pd,glass_EIDINDUP,TRUE);
1271 dbox_shadeicon(ed->e.pd,glass_EIDINDDOWN,TRUE);
1272 dbox_shadeicon(ed->e.pd,glass_EIDMINIMISE,TRUE);
1273 dbox_shadeicon(ed->e.pd,glass_EIDINDPART,TRUE);
1274 }
1275 break;
1276 }
1277 break;
1278 case glass_EIAPPEARANCE:
1279 switch (f)
1280 {
1281 case glass_EIAFONT:
1282 if (dbox_selecticon(d,f,dbox_READSTATE) ||
1283 fontMenu_createFontMenu(FALSE))
1284 {
1285 dbox_selecticon(d,f,dbox_TOGGLESTATE);
1286 dbox_shadeicon(d,glass_EIAFONTNAME,dbox_TOGGLESTATE);
1287 dbox_shadeicon(d,glass_EIAFONTMENU,dbox_TOGGLESTATE);
1288 dbox_shadeicon(d,glass_EIAFSIZEUP,dbox_TOGGLESTATE);
1289 dbox_shadeicon(d,glass_EIAFSIZEDOWN,dbox_TOGGLESTATE);
1290 dbox_shadeicon(d,glass_EIAFSIZEWRITE,dbox_TOGGLESTATE);
1291 dbox_shadeicon(ed->e.d,glass_EICOLOURS,dbox_TOGGLESTATE);
1292 }
1293 break;
1294 case glass_EIAFSIZEUP:
1295 buttons_arrow(ed->e.pd,f,ed->e.pd,glass_EIAFSIZEWRITE,0,+1,&sa);
1296 break;
1297 case glass_EIAFSIZEDOWN:
1298 buttons_arrow(ed->e.pd,f,ed->e.pd,glass_EIAFSIZEWRITE,0,-1,&sa);
1299 break;
1300 }
1301 break;
1302 case glass_EIACTIONS:
1303 switch (f)
1304 {
1305 case glass_EIAESGUP:
1306 buttons_arrow(d,f,d,glass_EIAESGWRITE,0,+1,&esga);
1307 break;
1308 case glass_EIAESGDOWN:
1309 buttons_arrow(d,f,d,glass_EIAESGWRITE,0,-1,&esga);
1310 break;
1311 }
1312 break;
1313 case glass_EICOLOURS:
1314 /* Nothin' doing */
1315 break;
1316 case glass_EISIZE:
1317 psa.sizing=TRUE;
1318 /* Drop through */
1319 case glass_EIPOSITION:
1320 switch (f)
1321 {
1322 case glass_EIPUP:
1323 psa.xOrY=FALSE;
1324 buttons_arrow(d,f,d,glass_EIPWRITE,
1325 editIcon__posSizeArrows,
1326 +wimpt_dy(),
1327 &psa);
1328 break;
1329 case glass_EIPDOWN:
1330 psa.xOrY=FALSE;
1331 buttons_arrow(d,f,d,glass_EIPWRITE,
1332 editIcon__posSizeArrows,
1333 -wimpt_dy(),
1334 &psa);
1335 break;
1336 case glass_EIPLEFT:
1337 psa.xOrY=TRUE;
1338 buttons_arrow(d,f,d,glass_EIPWRITE,
1339 editIcon__posSizeArrows,
1340 -wimpt_dx(),
1341 &psa);
1342 break;
1343 case glass_EIPRIGHT:
1344 psa.xOrY=TRUE;
1345 buttons_arrow(d,f,d,glass_EIPWRITE,
1346 editIcon__posSizeArrows,
1347 +wimpt_dx(),
1348 &psa);
1349 break;
1350 case glass_EIPSETSIZE:
1351 dbox_clickicon(d,f);
1352 editIcon__setSize(ed);
1353 dbox_unclick();
1354 break;
1355 }
1356 break;
1357 }
1358 }
1359
1360 /*
1361 * BOOL editIcon__panelRaw(dbox d,wimp_eventstr *e,void *handle)
1362 *
1363 * Use
1364 * Handles the more wierd events for a particular panel.
1365 *
1366 * Parameters
1367 * dbox d == the dbox handle of the panel
1368 * wimp_eventstr *e == the event to look at
1369 * void *handle == pointer to the current edit
1370 *
1371 * Returns
1372 * TRUE if the event is dead (long live the event...)
1373 */
1374
1375 static BOOL editIcon__panelRaw(dbox d,wimp_eventstr *e,void *handle)
1376 {
1377 BOOL handled=FALSE;
1378 glass_editIcon *ed=handle;
1379 BOOL cursor=FALSE;
1380 if (e->e==wimp_EKEY)
1381 {
1382 switch (e->data.key.chcode)
1383 {
1384 case akbd_UpK+akbd_Sh:
1385 editIcon__nextPanel(ed,-1);
1386 handled=TRUE;
1387 break;
1388 case akbd_DownK+akbd_Sh:
1389 editIcon__nextPanel(ed,+1);
1390 handled=TRUE;
1391 break;
1392 }
1393 }
1394 if (!handled) switch (ed->e.panel)
1395 {
1396 case glass_EIDATA:
1397 /* Nothin' doing */
1398 break;
1399 case glass_EIAPPEARANCE:
1400 switch (e->e)
1401 {
1402 case wimp_EBUT:
1403 switch (e->data.but.m.i)
1404 {
1405 case glass_EIAFONTNAME:
1406 menu_make(editIcon__fontMaker,editIcon__fontHandler,
1407 editIcon__fontHelp,ed);
1408 handled=TRUE;
1409 break;
1410 case glass_EIAFONTMENU:
1411 dbox_clickicon(d,glass_EIAFONTMENU);
1412 menu_make(editIcon__fontMaker,editIcon__fontHandler,
1413 editIcon__fontHelp,ed);
1414 dbox_unclick();
1415 handled=TRUE;
1416 break;
1417 }
1418 break;
1419 }
1420 break;
1421 case glass_EIACTIONS:
1422 switch (e->e)
1423 {
1424 case wimp_EBUT:
1425 switch (e->data.but.m.i)
1426 {
1427 case glass_EIABTYPE:
1428 menu_make(editIcon__btypeMaker,editIcon__btypeHandler,
1429 editIcon__btypeHelp,ed);
1430 handled=TRUE;
1431 break;
1432 case glass_EIABTMENU:
1433 dbox_clickicon(d,glass_EIABTMENU);
1434 menu_make(editIcon__btypeMaker,editIcon__btypeHandler,
1435 editIcon__btypeHelp,ed);
1436 dbox_unclick();
1437 handled=TRUE;
1438 break;
1439 }
1440 break;
1441 case wimp_EKEY:
1442 switch (e->data.key.c.i)
1443 {
1444 case glass_EIAESGWRITE:
1445 switch (e->data.key.chcode)
1446 {
1447 case akbd_DownK:
1448 case akbd_UpK:
1449 case akbd_TabK:
1450 case akbd_TabK+akbd_Sh:
1451 case akbd_UpK+akbd_Ctl:
1452 case akbd_DownK+akbd_Ctl:
1453 cursor=TRUE;
1454 break;
1455 }
1456 handled=buttons_insertChar(d,e->data.key.chcode,'0','9');
1457 if (handled || cursor)
1458 buttons_arrowClick(d,glass_EIAESGWRITE,0,31,0,FALSE);
1459 break;
1460 }
1461 break;
1462 }
1463 break;
1464 case glass_EICOLOURS:
1465 switch (e->e)
1466 {
1467 case wimp_EBUT:
1468 switch (e->data.but.m.i)
1469 {
1470 case glass_EICFORE:
1471 colSelect(ed->e.pd,glass_EICFORE,e->data.but.m.bbits,
1472 msgs_lookup("eiFGC"),FALSE,
1473 editIcon__colProc,ed);
1474 break;
1475 case glass_EICBACK:
1476 colSelect(ed->e.pd,glass_EICBACK,e->data.but.m.bbits,
1477 msgs_lookup("eiBGC"),FALSE,
1478 editIcon__colProc,ed);
1479 break;
1480 }
1481 break;
1482 }
1483 break;
1484 case glass_EISIZE:
1485 case glass_EIPOSITION:
1486 /* Nothin' doin' */
1487 break;
1488 }
1489 return (FALSE);
1490 }
1491
1492 /*----- External routines -------------------------------------------------*/
1493
1494 /*
1495 * void editIcon_renumber(glass_windPointer *w,int icon,int new)
1496 *
1497 * Use
1498 * Informs an edit dialogue that an icon has been renumbered.
1499 *
1500 * Parameters
1501 * glass_windPointer *w == the window containing the icon
1502 * int icon == the icon number
1503 * int new == the new number for the icon
1504 */
1505
1506 void editIcon_renumber(glass_windPointer *w,int icon,int new)
1507 {
1508 glass_editIcon *ed=w->def->i[icon].edit;
1509 if (!ed)
1510 return;
1511 ed->i=new;
1512 dbox_setfield(ed->e.d,glass_EINUMWRITE,"%i",new);
1513 }
1514
1515 /*
1516 * void editIcon_iconMoved(glass_windPointer *w,int icon)
1517 *
1518 * Use
1519 * Informs an edit dialogue that an icon has been moved.
1520 *
1521 * Parameters
1522 * glass_windPointer *w == the window containing the icon
1523 * int icon == the icon number. This may not be the same during the edit...
1524 */
1525
1526 void editIcon_iconMoved(glass_windPointer *w,int icon)
1527 {
1528 glass_editIcon *ed=w->def->i[icon].edit;
1529 if (!ed)
1530 return;
1531 ed->idef.box=ed->w->def->i[ed->i].i.box;
1532 if (ed->e.panel==glass_EIPOSITION || ed->e.panel==glass_EISIZE)
1533 editIcon__setupPanel(ed);
1534 }
1535
1536 /*
1537 * void editIcon_readData(glass_windPointer *w,int icon)
1538 *
1539 * Use
1540 * Forces a re-read of the icon data for the given icon edit
1541 *
1542 * Parameters
1543 * glass_windPointer *w == the window containing the icon
1544 * int icon == the icon number. This may not be the same during the edit...
1545 */
1546
1547 void editIcon_readData(glass_windPointer *w,int icon)
1548 {
1549 glass_editIcon *ed=w->def->i[icon].edit;
1550 if (!ed)
1551 return;
1552 ed->idef.data=ed->w->def->i[ed->i].i.data;
1553 if (ed->idef.flags & wimp_INDIRECT)
1554 {
1555 utils_ctermToNterm(ed->idef.data.indirecttext.buffer);
1556 strcpy(ed->data,ed->idef.data.indirecttext.buffer);
1557 ed->indLen=ed->idef.data.indirecttext.bufflen;
1558 if (ed->idef.flags & wimp_ITEXT &&
1559 ed->idef.data.indirecttext.validstring!=(char *)-1)
1560 {
1561 utils_ctermToNterm(ed->idef.data.indirecttext.validstring);
1562 strcpy(ed->valid,ed->idef.data.indirecttext.validstring);
1563 ed->hasValid=TRUE;
1564 }
1565 else
1566 {
1567 ed->valid[0]=0;
1568 ed->hasValid=FALSE;
1569 }
1570 }
1571 else
1572 {
1573 ed->data[12]=0;
1574 memcpy(ed->data,ed->idef.data.text,12);
1575 utils_ctermToNterm(ed->data);
1576 ed->valid[0]=0;
1577 ed->indLen=12;
1578 }
1579 if (ed->e.panel==glass_EIDATA)
1580 editIcon__setupPanel(ed);
1581 if (ed->idef.flags & wimp_IFONT)
1582 {
1583 if (ed->e.panel==glass_EICOLOURS)
1584 editIcon__setPanel(ed,-1);
1585 dbox_shadeicon(ed->e.d,glass_EICOLOURS,TRUE);
1586 }
1587 else
1588 dbox_shadeicon(ed->e.d,glass_EICOLOURS,FALSE);
1589 }
1590
1591 /*
1592 * void editIcon_close(glass_windPointer *w,int icon)
1593 *
1594 * Use
1595 * Closes an edit window
1596 *
1597 * Parameters
1598 * glass_windPointer *w == the window containing the icon
1599 * int icon == the icon number. This may not be the same during the edit...
1600 */
1601
1602 void editIcon_close(glass_windPointer *w,int icon)
1603 {
1604 glass_editIcon *ed=w->def->i[icon].edit;
1605 if (ed)
1606 {
1607 if (ed->e.pd)
1608 dbox_deleteNoUpdate(ed->e.pd);
1609 pane_delete(ed->e.p);
1610 dbox_deleteNoUpdate(ed->e.d);
1611 ed->w->def->i[ed->i].edit=0;
1612 mem_free(ed);
1613 }
1614 }
1615
1616 /*
1617 * void editIcon(glass_windPointer *w,int icon)
1618 *
1619 * Use
1620 * Edits the given icon in a dialogue box.
1621 *
1622 * Parameters
1623 * glass_windPointer *w == the window containing the icon
1624 * int icon == the icon number. This may not be the same during the edit...
1625 */
1626
1627 void editIcon(glass_windPointer *w,int icon)
1628 {
1629 glass_editIcon *ed;
1630 os_regset r;
1631 if (w->def->i[icon].edit)
1632 {
1633 dbox_display(w->def->i[icon].edit->e.d,TRUE);
1634 pane_front(w->def->i[icon].edit->e.p);
1635 return;
1636 }
1637 mem_useUser(indir_alloc,indir_free);
1638 ed=mem_alloc(sizeof(glass_editIcon));
1639 if (!ed)
1640 {
1641 werr(FALSE,msgs_lookup("eiNEM"));
1642 mem_useMalloc();
1643 return;
1644 }
1645 if (ed->e.d=dbox_create("editIcon"),!ed->e.d)
1646 {
1647 mem_free(ed);
1648 mem_useMalloc();
1649 return;
1650 }
1651 if (ed->e.p=pane_create(dbox_syshandle(ed->e.d)),!ed->e.p)
1652 {
1653 dbox_delete(ed->e.d);
1654 mem_free(ed);
1655 mem_useMalloc();
1656 return;
1657 }
1658 mem_useMalloc();
1659 ed->w=w;
1660 ed->i=icon;
1661 ed->idef=w->def->i[icon].i;
1662 w->def->i[icon].edit=ed;
1663 ed->e.panel=0;
1664
1665 /* --- Set up icon data now --- */
1666 editIcon_readData(w,icon);
1667 if (ed->idef.flags & wimp_IFONT)
1668 {
1669 r.r[0]=ed->idef.flags >> 24;
1670 r.r[1]=(int)(ed->font);
1671 wimpt_noerr(os_swix(XFont_ReadDefn,&r));
1672 utils_ctermToNterm(ed->font);
1673 ed->fontSize=r.r[2]/16;
1674 dbox_shadeicon(ed->e.d,glass_EICOLOURS,TRUE);
1675 }
1676 else
1677 {
1678 strcpy(ed->font,"Homerton.Medium");
1679 ed->fontSize=12;
1680 dbox_shadeicon(ed->e.d,glass_EICOLOURS,FALSE);
1681 }
1682
1683 /* --- Now do handlers, and final setting up --- */
1684 dbox_setfield(ed->e.d,glass_EINUMWRITE,"%i",icon);
1685 dbox_setfield(ed->e.d,glass_EIWINDISP,"%s",w->id);
1686 dbox_eventHandler(ed->e.d,editIcon__dboxHandler,ed);
1687 dbox_rawEventHandler(ed->e.d,editIcon__dboxRaw,ed);
1688 dbox_openDisplaced(ed->e.d);
1689 editIcon__setPanel(ed,glass_EIDATA);
1690 }
The Straylight Source Distribution (obsolete software for RISC OS)