?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
correction - use screenwidth/screenheight
[AROS-Contrib.git] / dopus / Config / main.c
blob8b1330b0f2625a938c81d6f97076639a30ccbb30
1 /*
2
3 Directory Opus 4
4 Original GPL release version 4.12
5 Copyright 1993-2000 Jonathan Potter
6
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License
9 as published by the Free Software Foundation; either version 2
10 of the License, or (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20
21 All users of Directory Opus 4 (including versions distributed
22 under the GPL) are entitled to upgrade to the latest version of
23 Directory Opus version 5 at a reduced price. Please see
24 http://www.gpsoft.com.au for more information.
25
26 The release of Directory Opus 4 under the GPL in NO WAY affects
27 the existing commercial status of Directory Opus 5.
28
29 */
30
31 #include "config.h"
32
33 #define LIB_VER 22
34 #define LIB_REV 20
35
36 int CXBRK(void);
37 void chkabort(void);
38
39 int CXBRK(void) { return(0); } /* Disable Lattice CTRL/C handling */
40 void chkabort(void) { return; }
41
42 int onworkbench=0;
43
44 int main(argc,argv)
45 int argc;
46 char *argv[];
47 {
48 ULONG class;
49 UWORD gadgetid,code;
50 int num,a;
51 char portname[50],rportname[50],oldconfigname[256]/*,oldlanguage[30]*/;
52 struct WBStartup *wbmsg;
53 struct ConfigUndo *undo;
54
55 #ifdef DEBUG
56 if (sizeof(struct Config)!=CONFIG_STRUCTURE_SIZE) {
57 kprintf("invalid config size - %ld - should be %ld\n",sizeof(struct Config),CONFIG_STRUCTURE_SIZE);
58 // return(0);
59 }
60 #endif
61
62 if (!(DOpusBase=(struct DOpusBase *)OpenLibrary("dopus.library",LIB_VER)) &&
63 !(DOpusBase=(struct DOpusBase *)OpenLibrary("dopus:libs/dopus.library",LIB_VER)))
64 return(0);
65
66 if (DOpusBase->LibNode.lib_Revision < LIB_REV)
67 {
68 CloseLibrary((struct Library *)DOpusBase);
69 return(0);
70 }
71
72 GfxBase=DOpusBase->GfxBase;
73 LayersBase=(struct Library *)DOpusBase->LayersBase;
74 IntuitionBase=DOpusBase->IntuitionBase;
75
76 // WorkbenchBase=IconBase=NULL;
77
78 DiskfontBase=OpenLibrary("diskfont.library",0);
79 WorkbenchBase=OpenLibrary("workbench.library",37);
80 IconBase=OpenLibrary("icon.library",0);
81
82 network=0;
83
84 Forbid();
85 if (FindName(&SysBase->LibList,"services.library") || (FindName(&SysBase->LibList,"multiuser.library")))
86 {
87 network=1;
88 formatgads[8 /* HUX: was 7 */].NextGadget=&formatgads[9 /* HUX: was 8 */];
89 }
90 Permit();
91
92 if (SysBase->LibNode.lib_Version>=40) version2=OSVER_40;
93 else /*if (SysBase->LibNode.lib_Version==39)*/ version2=OSVER_39;
94 /* else if (SysBase->LibNode.lib_Version==38) version2=OSVER_38;
95 else if (SysBase->LibNode.lib_Version==37) version2=OSVER_37;
96 else version2=OSVER_34;
97
98 if (version2<OSVER_37) {
99 operationgadgets[OP_UPDATE][10].type=CTYPE_SKIP;
100 systemgadgets[SYS_CLOCK][18].type=CTYPE_SKIP;
101 scr_generalgadgets[7].type=CTYPE_SKIP;
102 }
103 if (version2<OSVER_39) {
104 scr_generalgadgets[6].type=CTYPE_SKIP;
105 systemgadgets[SYS_VIEWPLAY][4].type=CTYPE_SKIP;
106 systemgadgets[SYS_VIEWPLAY][5].type=CTYPE_SKIP;
107 }
108 else*/ if (!(GfxBase->ChipRevBits0&GFXF_AA_ALICE)) {
109 systemgadgets[SYS_VIEWPLAY][4].type=CTYPE_SKIP;
110 }
111
112 /* ExAll() */
113
114 if (version2<OSVER_40) {
115 systemgadgets[SYS_DIRECTORIES][11].type=CTYPE_SKIP;
116 }
117 /* Initialized in data.c */
118 /*
119 conport=cmdport=appport=NULL;
120 appobject=NULL;
121 mainkey=buttonkey=gadgetkey=tickkey=clipkey=fontkey=NULL;
122 firsttype=NULL; firstbank=curbank=NULL;
123 typekey=NULL; firsthotkey=NULL;
124 Screen=NULL; Window=NULL;
125 myproc=NULL;
126 tfont=NULL;
127 tickgad=maingad=gadgads=drivegads=menugads=NULL;
128 firstclip=NULL;
129 undoconfig=NULL; config=NULL;
130 changed=lchanged=clipcount=tickcount=0;
131 curoperation=-1;
132 fontdatabuf=NULL;
133 helpbuffer=NULL; helpkey=NULL;
134 cfg_string=NULL;
135 stringdata.string_table=NULL;
136 stringdata.string_buffer=NULL;
137 */
138 free_colour_table(NULL);
139
140 help_ok=1;
141
142 /*
143 clip_port=NULL; clip_io=NULL;
144 */
145 currenthelpname[0]=0;
146
147 if (!(FindSystemFile("DirectoryOpus.CFG",configname,256,SYSFILE_DATA))) {
148 if (CheckExist("DOpus:S",NULL)) strcpy(configname,"DOpus:S/DirectoryOpus.CFG");
149 else strcpy(configname,"s:DirectoryOpus.CFG");
150 }
151
152 if(!(FindSystemFile("DirectoryOpus.CLA",classname,256,SYSFILE_DATA))) classname[0]=0;
153
154 if (argc)
155 {
156 dropboxicon = GetDiskObject(argv[0]);
157 }
158 else {
159 wbmsg=(struct WBStartup *)argv;
160
161 dropboxicon = GetDiskObject(wbmsg->sm_ArgList->wa_Name);
162
163 if (wbmsg->sm_NumArgs>1) {
164 num=atoi(wbmsg->sm_ArgList[1].wa_Name);
165 lsprintf(portname,"dopus4_config_port%ld",(long int)num);
166 if (!(conport=LCreatePort(portname,20))) quit();
167 lsprintf(rportname,"dopus4_config_reply%ld",(long int)num);
168 Forbid();
169 if (!(cmdport=FindPort(rportname))) {
170 LDeletePort(conport);
171 conport=NULL;
172 }
173 Permit();
174 }
175 }
176 if (!dropboxicon) dropboxicon = &dropboxobj;
177
178 myproc=(struct Process *)FindTask(0);
179 wsave=myproc->pr_WindowPtr;
180 myproc->pr_WindowPtr=(APTR)-1;
181
182 for (a=0;a<13;a++)
183 if (!(functypelist[a]=LAllocRemember(&mainkey,40,MEMF_CLEAR))) quit();
184 functypelist[13]=NULL;
185
186 if (!cmdport && !(config=(struct Config *)AllocMem(sizeof(struct Config),MEMF_CLEAR)))
187 quit();
188 getconfig();
189 strcpy(oldconfigname,configname);
190
191 appport=LCreatePort(NULL,0);
192 /*
193 if (clip_port=LCreatePort(NULL,0))
194 clip_io=(struct IOClipReq *)LCreateExtIO(clip_port,sizeof(struct IOClipReq));
195 */
196
197 read_strings();
198 load_clips();
199 readhelp();
200
201 if (config->scrdepth<2) config->scrdepth+=2;
202
203 open_screen();
204
205 undo=makeundo(UNDO_ALL);
206 showconfigscreen(CFG_MAINMENU);
207 giveconfig();
208
209 FOREVER {
210 Wait(1<<Window->UserPort->mp_SigBit);
211 while (IMsg=getintuimsg()) {
212 class=IMsg->Class; code=IMsg->Code;
213 if (class==GADGETUP || class==GADGETDOWN)
214 gadgetid=((struct Gadget *)IMsg->IAddress)->GadgetID;
215 ReplyMsg((struct Message *)IMsg);
216 switch (class) {
217 case MENUPICK:
218 if (code==MENUNULL) break;
219 switch ((num=ITEMNUM(code))) {
220 case 0:
221 case 1:
222 if (lchanged && !request(cfg_string[STR_REALLY_DISCARD_CONFIG]))
223 break;
224 // strcpy(oldlanguage,config->language);
225 if (doload(CFG_MAINMENU,num)) {
226 // if (strcmp(config->language,oldlanguage)) {
227 busy();
228 // read_strings();
229 readhelp();
230 unbusy();
231 // }
232 close_screen();
233 open_screen();
234 configmsg(CONFIG_NEW_HOTKEY);
235 showconfigscreen(CFG_MAINMENU);
236 }
237 break;
238 }
239 break;
240 case GADGETUP:
241 curoperation=gadgetid;
242 switch (gadgetid) {
243 case CFG_DRIVE:
244 if (dodriveconfig()) lchanged=1;
245 showconfigscreen(CFG_MAINMENU);
246 break;
247 case CFG_FILETYPE:
248 if (dofiletypeconfig()) lchanged=1;
249 showconfigscreen(CFG_MAINMENU);
250 break;
251 case CFG_GADGET:
252 if (dogadgetconfig()) lchanged=1;
253 showconfigscreen(CFG_MAINMENU);
254 break;
255 case CFG_HOTKEYS:
256 if (dohotkeysconfig()) lchanged=1;
257 showconfigscreen(CFG_MAINMENU);
258 break;
259 case CFG_MENU:
260 if (domenuconfig()) lchanged=1;
261 showconfigscreen(CFG_MAINMENU);
262 break;
263 case CFG_OPERATION:
264 if (dooperationconfig()) lchanged=1;
265 showconfigscreen(CFG_MAINMENU);
266 break;
267 case CFG_SCREEN:
268 if (doscreenconfig()) lchanged=1;
269 showconfigscreen(CFG_MAINMENU);
270 break;
271 case CFG_SYSTEM:
272 if (dosystemconfig()) lchanged=1;
273 showconfigscreen(CFG_MAINMENU);
274 break;
275 case CFG_SAVE:
276 dosave(0);
277 lchanged=2;
278 quit();
279 break;
280 case CFG_OKAY:
281 case CFG_CANCEL:
282 if ((gadgetid==CFG_CANCEL || !cmdport) && lchanged &&
283 !do_request(cfg_string[STR_EXIT_WITHOUT_SAVING],
284 cfg_string[STR_OKAY_TO_QUIT],cfg_string[STR_CANCEL]))
285 break;
286 if (gadgetid==CFG_CANCEL) {
287 doundo(undo,UNDO_ALL);
288 strcpy(configname,oldconfigname);
289 lchanged=changed=0;
290 }
291 doundo(undo,0);
292 quit();
293 }
294 curoperation=-1;
295 }
296 }
297 }
298 return 0;
299 }
300
301 void quit()
302 {
303 if (Window) SetBusyPointer(Window);
304 if (cmdport) {
305 giveconfig();
306 configmsg(CONFIG_ALL_DONE);
307 }
308 else {
309 fixcstuff(&cstuff);
310 FreeConfig(&cstuff);
311 if (config) FreeMem(config,sizeof(struct Config));
312 }
313 if (myproc) myproc->pr_WindowPtr=wsave;
314 if (firstclip) save_clips();
315 if (Screen && !onworkbench) ScreenToBack(Screen);
316 close_screen();
317 FreeStringFile(&stringdata);
318 if (conport) LDeletePort(conport);
319 if (appport) LDeletePort(appport);
320 if (tfont) CloseFont(tfont);
321 if (dropboxicon != &dropboxobj) FreeDiskObject(dropboxicon);
322 /*
323 if (clip_io) LDeleteExtIO((struct IORequest *)clip_io);
324 if (clip_port) LDeletePort(clip_port);
325 */
326 LFreeRemember(&mainkey);
327 LFreeRemember(&clipkey);
328 LFreeRemember(&gadgetkey);
329 LFreeRemember(&tickkey);
330 LFreeRemember(&fontkey);
331 LFreeRemember(&helpkey);
332 LFreeRemember(&buttonkey);
333 if (DiskfontBase) CloseLibrary(DiskfontBase);
334 if (WorkbenchBase) CloseLibrary(WorkbenchBase);
335 if (IconBase) CloseLibrary(IconBase);
336 if (muBase) CloseLibrary((struct Library *)muBase);
337 CloseLibrary((struct Library *)DOpusBase);
338 _exit(0);
339 }
340
341 void getconfig()
342 {
343 struct configconfig *cfg;
344
345 if (cmdport) {
346 configmsg(CONFIG_GET_CONFIG);
347 cfg=(struct configconfig *)msg.buffer;
348 config=cfg->config;
349 firsttype=cfg->firsttype;
350 firstbank=cfg->firstbank;
351 firsthotkey=cfg->firsthotkey;
352 typekey=cfg->typekey;
353 changed=cfg->changed;
354 strcpy(configname,cfg->configname);
355 StrConcat(configname,".CFG",256);
356 strcpy(loadnamebuf,configname);
357 Screen=cfg->Screen;
358 D(bug("getconfig: Screen = %lx\n",Screen));
359 }
360 else readconfig();
361 }
362
363 void giveconfig()
364 {
365 struct configconfig cfg;
366 char *ptr;
367
368 if (cmdport) {
369 cfg.config=config;
370 cfg.firsttype=firsttype;
371 cfg.firstbank=firstbank;
372 cfg.firsthotkey=firsthotkey;
373 cfg.typekey=typekey;
374 cfg.changed=((lchanged || changed)?1:0);
375 if (lchanged==2) cfg.changed=2;
376 strcpy(cfg.configname,configname);
377 if (ptr=strstri(cfg.configname,".CFG")) *ptr=0;
378 cfg.Window=Window;
379 cfg.Screen=Screen;
380 msg.buffer=(char *)&cfg;
381 configmsg(CONFIG_HERES_CONFIG);
382 }
383 }
384
385 void readconfig()
386 {
387 fixcstuff(&cstuff);
388 if ((ReadConfig(configname,&cstuff))!=1) DefaultConfig(&cstuff);
389 strcpy(loadnamebuf,configname);
390 cstufffix(&cstuff);
391 }
392
393 void configmsg(command)
394 int command;
395 {
396 if (cmdport) {
397 msg.msg.mn_Node.ln_Type=NT_MESSAGE;
398 msg.msg.mn_ReplyPort=conport;
399 msg.msg.mn_Length=(UWORD)sizeof(struct dopusconfigmsg);
400 msg.command=command;
401 PutMsg(cmdport,(struct Message *)&msg);
402 WaitPort(conport);
403 GetMsg(conport);
404 }
405 }
406
407 void fixcstuff(cstuff)
408 struct ConfigStuff *cstuff;
409 {
410 cstuff->config=config;
411 cstuff->typekey=typekey;
412 cstuff->firsttype=firsttype;
413 cstuff->firstbank=firstbank; cstuff->curbank=curbank;
414 cstuff->firsthotkey=firsthotkey;
415 if (!Screen && Window) {
416 config->config_x=Window->LeftEdge;
417 config->config_y=Window->TopEdge;
418 }
419 }
420
421 void cstufffix(cstuff)
422 struct ConfigStuff *cstuff;
423 {
424 config=cstuff->config;
425 typekey=cstuff->typekey;
426 firsttype=cstuff->firsttype;
427 firstbank=cstuff->firstbank; curbank=cstuff->curbank;
428 firsthotkey=cstuff->firsthotkey;
429 }
430
431 void cleanconfigscreen()
432 {
433 struct Gadget *gad;
434 struct Message *msg;
435
436 FOREVER {
437 gad=Window->FirstGadget;
438 while (gad) {
439 if (!(gad->GadgetType&GTYP_SYSGADGET)) {
440 RemoveGList(Window,gad,1);
441 break;
442 }
443 gad=gad->NextGadget;
444 }
445 if (!gad) break;
446 }
447
448 SetDrMd(rp,JAM2);
449 SetAPen(rp,screen_pens[0].pen);
450 RectFill(rp,
451 x_off,y_off,
452 x_bot,y_bot);
453
454 SetBPen(rp,screen_pens[1].pen);
455 SetBPen(rp,screen_pens[0].pen);
456
457 LFreeRemember(&gadgetkey);
458 removetickgads();
459
460 while (msg=GetMsg(Window->UserPort))
461 ReplyMsg(msg);
462 }
463
464 void showconfigscreen(scr)
465 int scr;
466 {
467 cleanconfigscreen();
468
469 switch (scr) {
470 case CFG_MAINMENU:
471 doscreentitle(cfg_string[STR_CONFIGURATION_MAIN_SCREEN]);
472 initsidegads(mainmenugads,0,1);
473 break;
474
475 case CFG_OPERATION:
476 initsidegads(operationgads,1,1);
477 doscreentitle(cfg_string[STR_OPERATION_SCREEN]);
478 break;
479
480 case CFG_GADGET:
481 if (gadgads) {
482 AddGadgets(Window,
483 gadgads,
484 NULL,
485 84,
486 screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
487 }
488 initsidegads(gadgetgads,0,0);
489 maingad[GAD_COPYGADGET].Activation|=GACT_TOGGLESELECT;
490 maingad[GAD_SWAPGADGET].Activation|=GACT_TOGGLESELECT;
491 maingad[GAD_DELETEGADGET].Activation|=GACT_TOGGLESELECT;
492 SetAPen(rp,screen_pens[1].pen);
493 UScoreText(rp,cfg_string[STR_LEFT_MOUSE_BUTTON],x_off+38,y_off+71,-1);
494 BltTemplate((char *)uparrow_data,0,2,rp,x_off+179,y_off+66,12,6);
495 UScoreText(rp,cfg_string[STR_RIGHT_MOUSE_BUTTON],x_off+454,y_off+75,-1);
496 BltTemplate((char *)downarrow_data,0,2,rp,x_off+437,y_off+70,12,6);
497
498 case CFG_MENU:
499 if (scr==CFG_MENU) {
500 if (menugads) AddGList(Window,menugads,-1,MENUCOUNT+5-(HIDDENLINES*5),NULL);
501 initsidegads(menugadgets,1,0);
502 maingad[MENU_OKAY].Activation&=~GACT_TOGGLESELECT;
503 maingad[MENU_CANCEL].Activation&=~GACT_TOGGLESELECT;
504 AddGList(Window,menuslidergads,-1,3,NULL);
505 AddGadgets(Window,
506 &menuslidergads[1],
507 NULL,
508 2,
509 screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,0);
510 do3dbox(x_off+612,y_off+21,12,144-HIDDENLINES*8);
511 DoArrow(rp,
512 x_off+612,y_off+119,
513 12,6,
514 screen_pens[config->arrowfg].pen,screen_pens[config->arrowbg].pen,0);
515 DoArrow(rp,
516 x_off+612,
517 y_off+127,
518 12,6,
519 screen_pens[config->arrowfg].pen,screen_pens[config->arrowbg].pen,1);
520 menusliderimage.PlaneOnOff=config->slidercol;
521 FixSliderBody(Window,&menuslidergads[0],20,20-HIDDENLINES,0);
522 FixSliderPot(Window,&menuslidergads[0],0,20,20-HIDDENLINES,2);
523 do_menuscreen_title(STR_MENU_SCREEN);
524 }
525
526 case CFG_DRIVE:
527 if (scr==CFG_DRIVE) {
528 if (drivegads) AddGList(Window,drivegads,-1,DRIVECOUNT,NULL);
529 initsidegads(drivegadgets,1,0);
530 maingad[DRIVE_GETDRIVES].Activation&=~GACT_TOGGLESELECT;
531 maingad[DRIVE_OKAY].Activation&=~GACT_TOGGLESELECT;
532 maingad[DRIVE_CANCEL].Activation&=~GACT_TOGGLESELECT;
533 do_menuscreen_title(STR_DRIVE_SCREEN);
534 }
535 dogadgetinfo(NULL);
536 break;
537
538 case CFG_FILETYPE:
539 initsidegads(filetypeactiongadgets,1,0);
540 maingad[FILETYPE_NEW].Activation&=~GACT_TOGGLESELECT;
541 maingad[FILETYPE_OKAY].Activation&=~GACT_TOGGLESELECT;
542 maingad[FILETYPE_CANCEL].Activation&=~GACT_TOGGLESELECT;
543 doscreentitle(cfg_string[STR_FILETYPE_SCREEN]);
544 setuplist(&filetypeactionlist,12,14);
545 filetypeactionlist.itemselected=-1;
546 AddListView(&filetypeactionlist,1);
547 dogadgetinfo(NULL);
548 break;
549
550 case CFG_SCREEN:
551 initsidegads(screengadgets,1,1);
552 /* if ((config->screenmode==MODE_WORKBENCHUSE ||
553 config->screenmode==MODE_PUBLICSCREENUSE) &&
554 version2<OSVER_39)
555 DisableGadget(&maingad[SCREEN_PALETTE],rp,2,1);*/
556 doscreentitle(cfg_string[STR_SCREEN_SCREEN]);
557 break;
558
559 case CFG_SYSTEM:
560 initsidegads(systemgads,1,1);
561 doscreentitle(cfg_string[STR_SYSTEM_SCREEN]);
562 break;
563
564 case CFG_HOTKEYS:
565 initsidegads(hotkeysgadgets,1,0);
566 maingad[HOTKEYS_NEWHOTKEY].Activation&=~GACT_TOGGLESELECT;
567 maingad[HOTKEYS_OKAY].Activation&=~GACT_TOGGLESELECT;
568 maingad[HOTKEYS_CANCEL].Activation&=~GACT_TOGGLESELECT;
569 doscreentitle(cfg_string[STR_HOTKEYS_SCREEN]);
570 setuplist(&hotkeyslist,12,14);
571 hotkeyslist.itemselected=-1;
572 hotkeyslist.items=NULL;
573 hotkeyslist.topitem=0;
574 AddListView(&hotkeyslist,1);
575 dogadgetinfo(NULL);
576 break;
577 }
578 if (scr==CFG_MAINMENU) strcpy(currenthelpname,cfg_string[STR_MAIN_MENU]);
579 else strcpy(currenthelpname,mainmenugads[scr]);
580 }
581
582 void initsidegads(gads,toggle,vert)
583 char **gads;
584 int toggle,vert;
585 {
586 int num,a,x,y,x1,ac,dn,gnum,rnum,w,h;
587 struct Gadget *gadbuf;
588
589 if (!gads) return;
590
591 for (num=0,rnum=0;;rnum++) {
592 if (!gads[rnum]) break;
593 if (gads[rnum][0]) ++num;
594 }
595
596 if (!(gadbuf=LAllocRemember(&gadgetkey,sizeof(struct Gadget)*num,MEMF_CLEAR)))
597 quit();
598
599 h=12;
600 if (vert) {
601 x=x_off+8;
602 y=y_off+4;
603 w=112;
604 }
605 else {
606 dn=rnum/5;
607 if (dn*5==rnum) --dn;
608 ac=rnum-dn*5;
609 w=104;
610 x1=x=((Window->Width-(ac*(w+12)))/2)-2;
611 y=y_off+172-(dn*(h+2));
612 }
613 gnum=0;
614 for (a=0;a<rnum;a++) {
615 if (gads[a][0]) {
616 gadbuf[gnum].NextGadget=(gnum<num-1)?&gadbuf[gnum+1]:NULL;
617 gadbuf[gnum].LeftEdge=x; gadbuf[gnum].TopEdge=y;
618 gadbuf[gnum].Width=w; gadbuf[gnum].Height=h;
619 gadbuf[gnum].Flags=GFLG_GADGHCOMP;
620 gadbuf[gnum].Activation=GACT_RELVERIFY;
621 if (toggle) gadbuf[gnum].Activation|=GACT_TOGGLESELECT;
622 gadbuf[gnum].GadgetType=GTYP_BOOLGADGET;
623 gadbuf[gnum].GadgetID=gnum;
624 ++gnum;
625 }
626 if (vert) y+=(h+2);
627 else {
628 x+=(w+16);
629 if (x>(Window->Width-10-w)) {
630 x=x1;
631 y+=(h+2);
632 }
633 }
634 }
635 SetAPen(rp,screen_pens[1].pen);
636 AddGadgetBorders(&gadgetkey,
637 gadbuf,
638 gnum,
639 screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
640 AddGadgets(Window,
641 gadbuf,
642 gads,
643 num,
644 screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
645 maingad=gadbuf;
646 }
647
648 void inittickgads(gads,flag,flag2)
649 struct ConfigGadget *gads;
650 int flag,flag2;
651 {
652 int num,a,y,gad,last,lasty,dy,xp,yp,fl,b;
653 char **namearray;
654 struct StringInfo *sinfo;
655
656 removetickgads();
657 if (!gads) return;
658
659 num=0;
660 for (a=0;;a++) {
661 if (!gads[a].type) break;
662 if (gads[a].type!=CTYPE_TEXT && gads[a].type!=CTYPE_SKIP) ++num;
663 }
664
665 if (!num) return;
666
667 if (!(tickgad=LAllocRemember(&tickkey,sizeof(struct Gadget)*num,MEMF_CLEAR)) ||
668 !(namearray=LAllocRemember(&tickkey,num*sizeof(APTR),MEMF_CLEAR))) return;
669
670 y=y_off+46;
671 lasty=y;
672 gad=0;
673 dy=0;
674
675 SetAPen(rp,screen_pens[1].pen);
676
677 for (a=0;;a++) {
678 if (!gads[a].type) break;
679 if (gads[a].type==CTYPE_SKIP) continue;
680 switch (gads[a].type) {
681 case CTYPE_MOVE:
682 y=y_off+(gads[a].x-12); dy=0;
683 break;
684 case CTYPE_MOVEREL:
685 dy=gads[a].x;
686 break;
687 case CTYPE_TEXT:
688 if (gads[a].x<0) xp=x_off+158;
689 else xp=x_off+(gads[a].x-2);
690 if (gads[a].y<0) {
691 yp=y+8; dy=13;
692 }
693 else {
694 yp=y_off+(gads[a].y-12);
695 if (gads[a].value==1) {
696 y=yp-8;
697 dy=13;
698 }
699 else dy=0;
700 }
701 if (gads[a].nameentry>-1) UScoreText(rp,cfg_string[gads[a].nameentry],xp,yp,-1);
702 break;
703 case CTYPE_GAD:
704 case CTYPE_RAD:
705 case CTYPE_MRAD:
706 if (gads[a].nameentry>-1) namearray[gad]=cfg_string[gads[a].nameentry];
707 else namearray[gad]=(char *)-1;
708 tickgad[gad].NextGadget=(gad<num-1)?&tickgad[gad+1]:NULL;
709 if (gads[a].type==CTYPE_GAD) {
710 if (gads[a].w<0) tickgad[gad].Width=26;
711 else tickgad[gad].Width=gads[a].w;
712 if (gads[a].h<0) tickgad[gad].Height=11;
713 else tickgad[gad].Height=gads[a].h;
714 tickgad[gad].GadgetRender=checkoffimage;
715 tickgad[gad].SelectRender=checkonimage;
716 tickgad[gad].MutualExclude=GAD_CHECK;
717 if (gads[a].x<0) xp=x_off+156;
718 else xp=x_off+(gads[a].x-2);
719 if (gads[a].y<0) {
720 yp=y; dy=13;
721 }
722 else {
723 yp=y_off+(gads[a].y-12); dy=0;
724 }
725 tickgad[gad].Activation=RELVERIFY|TOGGLESELECT;
726 }
727 else {
728 if (gads[a].w<0) tickgad[gad].Width=15;
729 else tickgad[gad].Width=gads[a].w;
730 if (gads[a].h<0) tickgad[gad].Height=7;
731 else tickgad[gad].Height=gads[a].h;
732 tickgad[gad].GadgetRender=(APTR)buttonoffimage;
733 tickgad[gad].SelectRender=(APTR)buttononimage;
734 tickgad[gad].MutualExclude=GAD_RADIO;
735 if (gads[a].x<0) xp=x_off+158;
736 else xp=x_off+(gads[a].x-2);
737 if (gads[a].y<0) {
738 yp=y; dy=10;
739 }
740 else {
741 yp=y_off+(gads[a].y-12); dy=0;
742 }
743 tickgad[gad].Activation=GADGIMMEDIATE|TOGGLESELECT;
744 }
745 tickgad[gad].LeftEdge=xp; tickgad[gad].TopEdge=yp;
746 tickgad[gad].Flags=GADGIMAGE|GADGHIMAGE;
747 if (gads[a].value==0) fl=flag;
748 else if (gads[a].value==1) fl=flag2;
749 if (gads[a].type==CTYPE_MRAD) {
750 b=gads[a].mutualex&(~gads[a].bit);
751 if (!(fl&b)) tickgad[gad].Flags|=SELECTED;
752 }
753 else if (fl && fl&gads[a].bit) tickgad[gad].Flags|=SELECTED;
754 tickgad[gad].GadgetType=BOOLGADGET;
755 tickgad[gad].GadgetID=GAD_BASE+(gads[a].value*4000)+gads[a].bit;
756 tickgad[gad].UserData=(APTR)&gads[a];
757 gads[a].gad=&tickgad[gad];
758 last=gads[a].type; ++gad;
759 break;
760 case CTYPE_STR:
761 if (gads[a].y==-2) y=lasty;
762 else {
763 if (last==CTYPE_GAD || gads[a].type==CTYPE_RAD || gads[a].type==CTYPE_MRAD)
764 ++y;
765 ++y;
766 }
767 if (gads[a].bit&4 || gads[a].nameentry==-1) namearray[gad]=(char *)-1;
768 else namearray[gad]=cfg_string[gads[a].nameentry];
769 tickgad[gad].NextGadget=(gad<num-1)?&tickgad[gad+1]:NULL;
770 if (gads[a].bit&4) {
771 if (gads[a].x<0) xp=x_off+338;
772 else xp=x_off+(gads[a].x-2);
773 if (gads[a].y<0) {
774 yp=y; dy=13;
775 }
776 else {
777 yp=y_off+(gads[a].y-12); dy=0;
778 }
779 }
780 else {
781 if (gads[a].x<0) xp=x_off+306;
782 else xp=x_off+(gads[a].x-2);
783 if (gads[a].y<0) {
784 yp=y; dy=13;
785 }
786 else {
787 yp=y_off+(gads[a].y-12); dy=0;
788 }
789 }
790 if (gads[a].w<0) {
791 tickgad[gad].Width=Window->Width-xp-30;
792 if (gads[a].bit&4) tickgad[gad].Width-=2;
793 }
794 else tickgad[gad].Width=gads[a].w;
795 if (gads[a].h<0) tickgad[gad].Height=8;
796 else tickgad[gad].Height=gads[a].h;
797 tickgad[gad].LeftEdge=xp; tickgad[gad].TopEdge=yp;
798 tickgad[gad].Flags=GFLG_GADGHCOMP|GFLG_STRINGEXTEND|GFLG_TABCYCLE;
799 tickgad[gad].Activation=GACT_RELVERIFY|GACT_TOGGLESELECT;
800 if (gads[a].bit&1) tickgad[gad].Activation|=GACT_LONGINT;
801 if (gads[a].bit&4) {
802 tickgad[gad].MutualExclude=1;
803 ++y;
804 }
805 tickgad[gad].GadgetType=GTYP_STRGADGET;
806 if (sinfo=(struct StringInfo *)LAllocRemember(&tickkey,sizeof(struct StringInfo),MEMF_CLEAR)) {
807 sinfo->Buffer=(STRPTR)LAllocRemember(&tickkey,gads[a].mutualex,MEMF_CLEAR);
808 sinfo->MaxChars=gads[a].mutualex;
809 sinfo->Extension=&stringex;
810 }
811 tickgad[gad].SpecialInfo=(APTR)sinfo;
812 tickgad[gad].GadgetID=STRING_BASE+gad;
813 tickgad[gad].UserData=(APTR)&gads[a];
814 gads[a].gad=&tickgad[gad];
815 last=gads[a].type; ++gad;
816 break;
817 case CTYPE_REQ:
818 y=lasty;
819 if (gads[a].x<0) xp=x_off+302;
820 else xp=x_off+(gads[a].x-2);
821 if (gads[a].y<0) {
822 yp=y-4; dy=13;
823 }
824 else {
825 yp=y_off+(gads[a].y-12); dy=0;
826 }
827 if (gads[a].nameentry>-1) namearray[gad]=cfg_string[gads[a].nameentry];
828 else namearray[gad]=(char *)-1;
829 tickgad[gad].NextGadget=(gad<num-1)?&tickgad[gad+1]:NULL;
830 tickgad[gad].LeftEdge=xp; tickgad[gad].TopEdge=yp;
831 if (gads[a].w<0) tickgad[gad].Width=28;
832 else tickgad[gad].Width=gads[a].w;
833 if (gads[a].h<0) tickgad[gad].Height=14;
834 else tickgad[gad].Height=gads[a].h;
835 tickgad[gad].Flags=GADGHCOMP;
836 tickgad[gad].Activation=RELVERIFY;
837 tickgad[gad].GadgetType=BOOLGADGET;
838 tickgad[gad].GadgetID=REQ_BASE+gad;
839 tickgad[gad].MutualExclude=GAD_GLASS;
840 tickgad[gad].UserData=(APTR)&gads[a];
841 AddGadgetBorders(&tickkey,
842 &tickgad[gad],
843 1,
844 screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
845 doglassimage(&tickgad[gad]);
846 gads[a].gad=&tickgad[gad-1];
847 last=gads[a].type; ++gad;
848 break;
849 }
850 lasty=y; y+=dy;
851 }
852 AddGadgets(Window,
853 tickgad,
854 namearray,
855 num,
856 screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
857 tickcount=num;
858 }
859
860 void removetickgads()
861 {
862 if (tickgad && tickcount) {
863 RemoveGList(Window,tickgad,tickcount);
864 tickgad=NULL; tickcount=0;
865 }
866 LFreeRemember(&tickkey);
867 SetAPen(rp,screen_pens[0].pen);
868 RectFill(rp,
869 x_off+122,y_off+1,
870 x_bot,y_bot);
871 }
872
873 int processtickgad(gads,flag,sel,num)
874 struct ConfigGadget *gads;
875 int flag,sel,num;
876 {
877 int a,ref=0,hitgad=-1;
878 struct Gadget *gad;
879
880 for (a=0;;a++) {
881 if (!gads[a].type) break;
882 if (num==-1 || gads[a].value==num) {
883 if (gads[a].type==CTYPE_GAD || gads[a].type==CTYPE_RAD || gads[a].type==CTYPE_MRAD) {
884 if (gads[a].bit==sel) {
885 hitgad=a;
886 break;
887 }
888 }
889 }
890 }
891
892 flag=0;
893 for (a=0;;a++) {
894 if (!gads[a].type) break;
895 if (num==-1 || gads[a].value==num) {
896 gad=gads[a].gad;
897 if (gads[a].type==CTYPE_GAD || gads[a].type==CTYPE_RAD || gads[a].type==CTYPE_MRAD) {
898 if (a==hitgad) {
899 if (!(gad->Flags&SELECTED) && gads[a].mutualex&sel) {
900 gad->Flags|=SELECTED;
901 ref=1;
902 }
903 }
904 else {
905 if (gad->Flags&SELECTED) {
906 if (gads[a].type==CTYPE_MRAD) {
907 if (gads[a].mutualex&sel) {
908 gad->Flags&=~SELECTED;
909 ref=1;
910 }
911 }
912 else if (gads[hitgad].mutualex&gads[a].bit) {
913 gad->Flags&=~SELECTED;
914 ref=1;
915 }
916 }
917 }
918 if (gads[a].type!=CTYPE_MRAD && gad->Flags&SELECTED) flag|=gads[a].bit;
919 }
920 else if (gads[a].type==CTYPE_STR) {
921 if (gads[a].buffer) {
922 if (gads[a].bit&2) CheckHexGad(gad,Window,0,0xff);
923 strcpy(gads[a].buffer,(char *)((struct StringInfo *)gad->SpecialInfo)->Buffer);
924 }
925 }
926 }
927 }
928 if (ref) RefreshGList(tickgad,Window,NULL,tickcount);
929 return(flag);
930 }
931
932 struct ConfigUndo *makeundo(type)
933 int type;
934 {
935 struct ConfigUndo *undo;
936 struct DOpusRemember *key;
937 struct dopusgadgetbanks *bank,*newbank,*curbank;
938 struct dopushotkey *hotkey,*newhotkey,*curhotkey;
939 int a;
940
941 key=NULL;
942 if (!(undo=LAllocRemember(&key,sizeof(struct ConfigUndo),MEMF_CLEAR)))
943 return(0);
944 if (type&UNDO_MAIN)
945 undo->config=(struct Config *)getcopy((char *)config,sizeof(struct Config),&key);
946 if (type&UNDO_GADGET) {
947 bank=firstbank; curbank=NULL;
948 while (bank) {
949 if (newbank=(struct dopusgadgetbanks *)
950 getcopy((char *)bank,sizeof(struct dopusgadgetbanks),&key)) {
951 newbank->next=NULL;
952 copygadgets(bank,newbank,&key);
953 if (curbank) curbank->next=newbank;
954 else undo->firstbank=newbank;
955 curbank=newbank;
956 }
957 bank=bank->next;
958 }
959 }
960 if (type&UNDO_MENU &&
961 (undo->menu=(struct newdopusfunction *)
962 getcopy((char *)config->menu,sizeof(struct newdopusfunction)*MENUCOUNT,&key))) {
963 for (a=0;a<MENUCOUNT;a++) {
964 undo->menu[a].name=getcopy(config->menu[a].name,-1,&key);
965 undo->menu[a].function=getcopy(config->menu[a].function,-1,&key);
966 }
967 for (a=0;a<5;a++) strcpy(undo->menutit[a],config->menutit[a]);
968 }
969 if (type&UNDO_DRIVE &&
970 (undo->drive=(struct dopusfunction *)
971 getcopy((char *)config->drive,sizeof(struct dopusfunction)*DRIVECOUNT,&key))) {
972 for (a=0;a<DRIVECOUNT;a++)
973 undo->drive[a].function=getcopy(config->drive[a].function,-1,&key);
974 }
975 if (type&UNDO_FILETYPE)
976 copyfiletypes(firsttype,&undo->firsttype,&key);
977 if (type&UNDO_HOTKEYS) {
978 hotkey=firsthotkey; curhotkey=NULL;
979 while (hotkey) {
980 if (newhotkey=(struct dopushotkey *)
981 getcopy((char *)hotkey,sizeof(struct dopushotkey),&key)) {
982 newhotkey->func.function=getcopy(hotkey->func.function,-1,&key);
983 newhotkey->next=NULL;
984 if (curhotkey) curhotkey->next=newhotkey;
985 else undo->firsthotkey=newhotkey;
986 curhotkey=newhotkey;
987 }
988 hotkey=hotkey->next;
989 }
990 }
991 undo->key=key;
992 return(undo);
993 }
994
995 void copygadgets(bank1,bank2,key)
996 struct dopusgadgetbanks *bank1,*bank2;
997 struct DOpusRemember **key;
998 {
999 int a;
1000
1001 for (a=0;a<84;a++) {
1002 bank2->gadgets[a].name=getcopy(bank1->gadgets[a].name,-1,key);
1003 bank2->gadgets[a].function=getcopy(bank1->gadgets[a].function,-1,key);
1004 }
1005 }
1006
1007 void copyfiletypes(oldfirst,newfirst,key)
1008 struct dopusfiletype *oldfirst,**newfirst;
1009 struct DOpusRemember **key;
1010 {
1011 struct dopusfiletype *type,*newtype,*curtype=NULL;
1012 int a;
1013
1014 type=oldfirst;
1015 *newfirst=NULL;
1016 while (type) {
1017 if (newtype=(struct dopusfiletype *)
1018 getcopy((char *)type,sizeof(struct dopusfiletype),key)) {
1019 for (a=0;a<FILETYPE_FUNCNUM;a++)
1020 newtype->function[a]=getcopy(type->function[a],-1,key);
1021 newtype->recognition=getcopy(type->recognition,-1,key);
1022 newtype->iconpath=getcopy(type->iconpath,-1,key);
1023 if (curtype) curtype->next=newtype;
1024 else *newfirst=newtype;
1025 curtype=newtype;
1026 curtype->next=NULL;
1027 }
1028 type=type->next;
1029 }
1030 }
1031
1032 void doundo(undo,type)
1033 struct ConfigUndo *undo;
1034 int type;
1035 {
1036 struct DOpusRemember *key;
1037 struct dopusgadgetbanks *bank,*curbank,*newbank;
1038 struct dopushotkey *hotkey,*curhotkey,*newhotkey;
1039 int a;
1040
1041 if (!undo) return;
1042 if (!type) {
1043 key=undo->key;
1044 LFreeRemember(&key);
1045 }
1046 else {
1047 if (type&UNDO_MENU) {
1048 for (a=0;a<MENUCOUNT;a++) freenewfunction(&config->menu[a]);
1049 }
1050 if (type&UNDO_DRIVE) for (a=0;a<DRIVECOUNT;a++) freefunction(&config->drive[a]);
1051 if (type&UNDO_MAIN && undo->config)
1052 copyconfigonly(undo->config,config);
1053 if (type&UNDO_GADGET) {
1054 freegadgets(firstbank); firstbank=NULL;
1055 bank=undo->firstbank; curbank=NULL;
1056 while (bank) {
1057 if (newbank=(struct dopusgadgetbanks *)
1058 getcopy((char *)bank,sizeof(struct dopusgadgetbanks),NULL)) {
1059 newbank->next=NULL;
1060 copygadgets(bank,newbank,NULL);
1061 if (curbank) curbank->next=newbank;
1062 else firstbank=newbank;
1063 curbank=newbank;
1064 }
1065 bank=bank->next;
1066 }
1067 }
1068 if (type&UNDO_MENU && undo->menu) {
1069 CopyMem((char *)undo->menu,(char *)config->menu,sizeof(struct newdopusfunction)*MENUCOUNT);
1070 for (a=0;a<MENUCOUNT;a++) {
1071 config->menu[a].name=getcopy(undo->menu[a].name,-1,NULL);
1072 config->menu[a].function=getcopy(undo->menu[a].function,-1,NULL);
1073 }
1074 for (a=0;a<5;a++) strcpy(config->menutit[a],undo->menutit[a]);
1075 }
1076 if (type&UNDO_DRIVE && undo->drive) {
1077 CopyMem((char *)undo->drive,(char *)config->drive,sizeof(struct dopusfunction)*DRIVECOUNT);
1078 for (a=0;a<DRIVECOUNT;a++)
1079 config->drive[a].function=getcopy(undo->drive[a].function,-1,NULL);
1080 }
1081 if (type&UNDO_FILETYPE) {
1082 LFreeRemember(&typekey); firsttype=NULL;
1083 copyfiletypes(undo->firsttype,&firsttype,&typekey);
1084 }
1085 if (type&UNDO_HOTKEYS) {
1086 hotkey=firsthotkey;
1087 while (hotkey) {
1088 curhotkey=hotkey->next;
1089 freestring(hotkey->func.function);
1090 FreeMem(hotkey,sizeof(struct dopushotkey));
1091 hotkey=curhotkey;
1092 }
1093 firsthotkey=NULL; curhotkey=NULL;
1094 hotkey=undo->firsthotkey;
1095 while (hotkey) {
1096 if (newhotkey=(struct dopushotkey *)
1097 getcopy((char *)hotkey,sizeof(struct dopushotkey),NULL)) {
1098 newhotkey->func.function=getcopy(hotkey->func.function,-1,NULL);
1099 newhotkey->next=NULL;
1100 if (curhotkey) curhotkey->next=newhotkey;
1101 else firsthotkey=newhotkey;
1102 curhotkey=newhotkey;
1103 }
1104 hotkey=hotkey->next;
1105 }
1106 }
1107 }
1108 }
1109
1110 void freegadgets(first)
1111 struct dopusgadgetbanks *first;
1112 {
1113 struct dopusgadgetbanks *temp;
1114
1115 while (first) {
1116 temp=first->next;
1117 freegadgetbank(first,1);
1118 first=temp;
1119 }
1120 }
1121
1122 void freegadgetbank(bank,free)
1123 struct dopusgadgetbanks *bank;
1124 int free;
1125 {
1126 int a;
1127
1128 if (bank) {
1129 for (a=0;a<GADCOUNT;a++) {
1130 freestring(bank->gadgets[a].name);
1131 freestring(bank->gadgets[a].function);
1132 }
1133 if (free) FreeMem(bank,sizeof(struct dopusgadgetbanks));
1134 }
1135 }
1136
1137 void freefunction(func)
1138 struct dopusfunction *func;
1139 {
1140 freestring(func->function);
1141 func->function=NULL;
1142 }
1143
1144 void freenewfunction(func)
1145 struct newdopusfunction *func;
1146 {
1147 freestring(func->name); func->name=NULL;
1148 freestring(func->function); func->function=NULL;
1149 }
1150
1151 char *getcopy(object,size,key)
1152 char *object;
1153 int size;
1154 struct DOpusRemember **key;
1155 {
1156 char *newobject;
1157
1158 if (!object) return(NULL);
1159 if (size==-1) size=strlen(object)+1;
1160 if (key) newobject=(char *)LAllocRemember(key,size,MEMF_CLEAR);
1161 else newobject=AllocMem(size,MEMF_CLEAR);
1162 if (newobject) CopyMem((char *)object,(char *)newobject,size);
1163 return(newobject);
1164 }
1165
1166 void makestring(char *buf,...)
1167 {
1168 va_list ap;
1169 char *ptr;
1170 struct Gadget *gad,*first=NULL;
1171 struct ConfigGadget *cgad;
1172
1173 if (!tickgad) return;
1174 gad=tickgad;
1175
1176 va_start(ap,buf);
1177 while (buf && gad) {
1178 if (gad->GadgetType==STRGADGET) {
1179 cgad=(struct ConfigGadget *)gad->UserData;
1180 cgad->buffer=buf;
1181 ptr=(char *)((struct StringInfo *)gad->SpecialInfo)->Buffer;
1182 strcpy(ptr,buf);
1183 RefreshStrGad(gad,Window);
1184 if (!first) first=gad;
1185 buf=(char *)va_arg(ap,char *);
1186 }
1187 gad=gad->NextGadget;
1188 }
1189 if (first) ActivateStrGad(first,Window);
1190 }
1191
1192 int getstring(text,buf,len,num)
1193 char *text,*buf;
1194 int len,num;
1195 {
1196 struct DOpusSimpleRequest req;
1197 char *gads[3];
1198 static int rets[2]={1,0};
1199 int a;
1200
1201 gads[0]=cfg_string[STR_OKAY];
1202 gads[1]=cfg_string[STR_CANCEL];
1203 gads[2]=NULL;
1204
1205 req.text=text;
1206 req.gads=gads;
1207 req.rets=rets;
1208 req.hi=screen_pens[config->gadgettopcol].pen;
1209 req.lo=screen_pens[config->gadgetbotcol].pen;
1210 req.fg=screen_pens[config->requestfg].pen;
1211 req.bg=screen_pens[config->requestbg].pen;
1212 req.strbuf=buf;
1213 req.strlen=len;
1214 req.flags=num|SRF_BORDERS|SRF_RECESSHI|SRF_EXTEND;
1215 req.value=(long)&stringex;
1216 req.font=NULL;
1217 req.title="ConfigOpus";
1218 busy();
1219 a=DoSimpleRequest(Window,&req);
1220 unbusy();
1221 return(a);
1222 }
1223
1224 int request(text)
1225 char *text;
1226 {
1227 return(do_request(text,cfg_string[STR_OKAY],cfg_string[STR_CANCEL]));
1228 }
1229
1230 int do_request(text,pos,neg)
1231 char *text,*pos,*neg;
1232 {
1233 struct DOpusSimpleRequest req;
1234 char *gads[3];
1235 static int rets[2]={1,0};
1236 int a;
1237
1238 gads[0]=pos;
1239 gads[1]=neg;
1240 gads[2]=NULL;
1241
1242 req.text=text;
1243 req.gads=gads;
1244 req.rets=rets;
1245 req.hi=screen_pens[config->gadgettopcol].pen;
1246 req.lo=screen_pens[config->gadgetbotcol].pen;
1247 req.fg=screen_pens[config->requestfg].pen;
1248 req.bg=screen_pens[config->requestbg].pen;
1249 req.strbuf=NULL;
1250 req.flags=SRF_BORDERS|SRF_RECESSHI;
1251 req.font=NULL;
1252 req.title="ConfigOpus";
1253 busy();
1254 a=DoSimpleRequest(Window,&req);
1255 unbusy();
1256 return(a);
1257 }
1258
1259 void doglassimage(gad)
1260 struct Gadget *gad;
1261 {
1262 int a,o;
1263
1264 o=rp->FgPen;
1265 SetDrMd(rp,JAM1);
1266 SetAPen(rp,screen_pens[config->gadgetbotcol].pen);
1267 for (a=0;a<2;a++) {
1268 BltTemplate((char *)glass_data[a],0,4,rp,gad->LeftEdge+4,gad->TopEdge+2,20,9);
1269 SetAPen(rp,screen_pens[config->gadgettopcol].pen);
1270 }
1271 SetDrMd(rp,JAM2);
1272 SetAPen(rp,o);
1273 }
1274
1275 void freestring(str)
1276 char *str;
1277 {
1278 if (str) FreeMem(str,strlen(str)+1);
1279 }
1280
1281 static char lasttitle[80];
1282
1283 void doscreentitle(str)
1284 char *str;
1285 {
1286 if (str && str!=(char *)-1) strcpy(lasttitle,str);
1287 SetWindowTitles(Window,lasttitle,(char *)-1);
1288 }
1289
1290 struct IntuiMessage *getintuimsg()
1291 {
1292 struct IntuiMessage *msg;
1293 struct MenuItem *item;
1294 int a;
1295 char buf[10],c;
1296
1297 if (msg=(struct IntuiMessage *)GetMsg(Window->UserPort)) {
1298 if (msg->Class==IDCMP_RAWKEY) {
1299 D(bug("RAWKEY code: %lx\n",msg->Code));
1300 if (msg->Code==0x5f && help_ok) {
1301 doconfighelp();
1302 ReplyMsg((struct Message *)msg);
1303 msg=NULL;
1304 }
1305 else if (msg->Qualifier&IEQUALIFIER_RCOMMAND && Window->MenuStrip) {
1306 if (!(msg->Code&0x80)) {
1307 RawkeyToStr(msg->Code,0,NULL,buf,10); c=LToUpper(buf[0]);
1308 item=Window->MenuStrip->FirstItem;
1309 a=0;
1310 while (item) {
1311 if (item->Command && c==item->Command) {
1312 msg->Class=MENUPICK;
1313 msg->Code=a<<5;
1314 break;
1315 }
1316 item=item->NextItem;
1317 ++a;
1318 }
1319 }
1320 }
1321 }
1322 else if (msg->Class==IDCMP_MENUPICK) {
1323 doscreentitle((char *)-1);
1324 if (Window->MenuStrip==&projectmenu && MENUNUM(msg->Code)==0) {
1325 a=0;
1326 switch (ITEMNUM(msg->Code)) {
1327 case 3: dosave(0); a=1; break;
1328 case 4: dosave(1); a=1; break;
1329 }
1330 if (a) {
1331 ReplyMsg((struct Message *)msg);
1332 msg=NULL;
1333 }
1334 }
1335 }
1336 else if (msg->Class==IDCMP_MOUSEMOVE && Window->MenuStrip) {
1337 if (msg->MouseY>Window->BorderTop && msg->MouseY<Window->Height &&
1338 msg->MouseX>=0 && msg->MouseX<Window->Width) Window->Flags|=RMBTRAP;
1339 else Window->Flags&=~RMBTRAP;
1340 }
1341 }
1342 return(msg);
1343 }
1344
1345 struct TextFont *getfont(font,size,flags)
1346 char *font;
1347 int *size,flags;
1348 {
1349 BPTR lock;
1350 struct TextFont *tf;
1351 static struct TextAttr sfont={NULL,0,0,0};
1352
1353 sfont.ta_Name=(STRPTR)font; sfont.ta_YSize=*size;
1354 if ((tf=OpenFont(&sfont)) && tf->tf_YSize==sfont.ta_YSize &&
1355 (!(tf->tf_Flags&FPF_PROPORTIONAL) || flags!=FFLAG_NOPROP)) return(tf);
1356 if (tf) CloseFont(tf);
1357 if (!(lock=Lock("FONTS:",ACCESS_READ))) {
1358 strcpy(font,"topaz.font"); *size=8; sfont.ta_YSize=8;
1359 return((OpenFont(&sfont)));
1360 }
1361 UnLock(lock);
1362 if (!DiskfontBase || !(tf=OpenDiskFont(&sfont))) {
1363 if ((tf=OpenFont(&sfont))) *size=tf->tf_YSize;
1364 }
1365 if (!tf ||
1366 (!tf && flags!=FFLAG_8ONLY) ||
1367 (tf && flags==FFLAG_NOPROP && tf->tf_Flags&FPF_PROPORTIONAL)) {
1368 if (tf) CloseFont(tf);
1369 strcpy(font,"topaz.font"); *size=8; sfont.ta_YSize=8;
1370 tf=OpenFont(&sfont);
1371 }
1372 return(tf);
1373 }
1374
1375 void loadrgb4(scr,pal,num)
1376 struct Screen *scr;
1377 UWORD *pal;
1378 int num;
1379 {
1380 int a,b;
1381 ULONG *data;
1382
1383 if (data=AllocMem(num*3*sizeof(ULONG),0)) {
1384 for (a=0,b=0;a<num;a++) {
1385 data[b++]=(((pal[a]>>8)&0xf)<<28)|0x0fffffff;
1386 data[b++]=(((pal[a]>>4)&0xf)<<28)|0x0fffffff;
1387 data[b++]=((pal[a]&0xf)<<28)|0x0fffffff;
1388 }
1389 load_palette(scr,data,num);
1390 FreeMem(data,num*3*sizeof(ULONG));
1391 }
1392 }
1393
1394 void load_palette(screen,palette,numcols)
1395 struct Screen *screen;
1396 ULONG *palette;
1397 int numcols;
1398 {
1399 if (!screen) {
1400 /*if (version2>=OSVER_39)*/ {
1401 int a,b;
1402
1403 for (a=0,b=0;a<numcols;a++) {
1404 SetRGB32(&Window->WScreen->ViewPort,
1405 screen_pens[a].pen,
1406 palette[b],palette[b+1],palette[b+2]);
1407 b+=3;
1408 }
1409 }
1410 }
1411 else /*if (version2>=OSVER_39)*/ {
1412 ULONG *backup_palette;
1413
1414 if (backup_palette=AllocMem(((numcols*3)+2)*sizeof(ULONG),MEMF_CLEAR)) {
1415 CopyMem((char *)palette,(char *)&backup_palette[1],(numcols*3)*sizeof(ULONG));
1416 backup_palette[0]=numcols<<16;
1417 backup_palette[(numcols*3)+1]=0;
1418 LoadRGB32(&screen->ViewPort,backup_palette);
1419 FreeMem(backup_palette,((numcols*3)+2)*sizeof(ULONG));
1420 }
1421 }
1422 /* else {
1423 UWORD backup_palette[16];
1424 int a,b;
1425
1426 for (a=0,b=0;a<numcols*3;b++) {
1427 backup_palette[b]=0;
1428 backup_palette[b]|=(palette[a++]&0xf0000000)>>20;
1429 backup_palette[b]|=(palette[a++]&0xf0000000)>>24;
1430 backup_palette[b]|=(palette[a++]&0xf0000000)>>28;
1431 }
1432
1433 LoadRGB4(&screen->ViewPort,backup_palette,numcols);
1434 }*/
1435 }
1436
1437 void get_palette(screen,palette,numcols)
1438 struct Screen *screen;
1439 ULONG *palette;
1440 int numcols;
1441 {
1442 if (!screen) {
1443 /*if (version2>=OSVER_39)*/ {
1444 int a,b;
1445
1446 for (a=0,b=0;a<numcols;a++,b+=3) {
1447 GetRGB32(Window->WScreen->ViewPort.ColorMap,
1448 screen_pens[a].pen,
1449 1,
1450 &palette[b]);
1451 }
1452 }
1453 }
1454 else /*if (version2>=OSVER_39)*/ {
1455 GetRGB32(screen->ViewPort.ColorMap,0,numcols,palette);
1456 }
1457 /* else {
1458 int a,b;
1459 ULONG colour;
1460
1461 for (a=0,b=0;a<numcols;a++) {
1462 colour=GetRGB4(screen->ViewPort.ColorMap,a);
1463 palette[b++]=(((colour>>8)&0xf)<<28)|0x0fffffff;
1464 palette[b++]=(((colour>>4)&0xf)<<28)|0x0fffffff;
1465 palette[b++]=((colour&0xf)<<28)|0x0fffffff;
1466 }
1467 }*/
1468 }
1469
1470 void open_screen()
1471 {
1472 if (!Window) {
1473 int a;
1474 struct Screen *wbscreen=NULL,*usescreen;
1475 char *psname=NULL;
1476
1477 onworkbench = 0;
1478 if (tfont) CloseFont(tfont);
1479 a=8;
1480 tfont=getfont(config->fontbufs[0],&a,FFLAG_8ONLY);
1481 strcpy(sfont.ta_Name,tfont->tf_Message.mn_Node.ln_Name);
1482
1483 if (Screen)
1484 {
1485 struct List *psl;
1486 struct PubScreenNode *psn;
1487
1488 if (psl = LockPubScreenList())
1489 {
1490 for (psn = (struct PubScreenNode *)psl->lh_Head; psn->psn_Node.ln_Succ; psn = (struct PubScreenNode *)psn->psn_Node.ln_Succ)
1491 {
1492 D(bug("PubScreen name: %s\n",psn->psn_Node.ln_Name));
1493 if (psn->psn_Screen == Screen)
1494 {
1495 psname = psn->psn_Node.ln_Name;
1496 break;
1497 }
1498 }
1499 UnlockPubScreenList();
1500 }
1501 }
1502 /*if (version2>=OSVER_39)*/ {
1503 if (wbscreen=LockPubScreen(psname)) {
1504 if (wbscreen->Height>wbscreen->WBorTop+wbscreen->Font->ta_YSize+189) {
1505 int pen,num;
1506 struct ColorMap *cm;
1507
1508 cm=wbscreen->ViewPort.ColorMap;
1509 num=1<<((config->scrdepth > 4) ? 4 : config->scrdepth);
1510
1511 for (pen=0;pen<num;pen++) {
1512 screen_pens[pen].red=config->new_palette[(pen*3)];
1513 screen_pens[pen].green=config->new_palette[(pen*3)+1];
1514 screen_pens[pen].blue=config->new_palette[(pen*3)+2];
1515 if ((screen_pens[pen].pen=
1516 ObtainPen(cm,-1,
1517 screen_pens[pen].red,
1518 screen_pens[pen].green,
1519 screen_pens[pen].blue,
1520 PEN_EXCLUSIVE))==(unsigned char)-1) break;
1521 screen_pens[pen].alloc=1;
1522 }
1523
1524 if (pen<num) free_colour_table(cm);
1525 else onworkbench=1;
1526 }
1527 }
1528 }
1529
1530 configscr.Depth=config->scrdepth;
1531 if (!onworkbench) {
1532 /*if (version2 >= OSVER_39)*/ {
1533 scr_taglist[1].ti_Data = BestModeID(//BIDTAG_NominalWidth, configscr.Width,
1534 BIDTAG_DesiredWidth, configscr.Width,
1535 //BIDTAG_NominalHeight, configscr.Height,
1536 BIDTAG_DesiredHeight, configscr.Height,
1537 BIDTAG_Depth, configscr.Depth,
1538 wbscreen?BIDTAG_MonitorID:TAG_IGNORE, wbscreen?GetVPModeID(&wbscreen->ViewPort) & MONITOR_ID_MASK:0,
1539 TAG_END);
1540 D(bug("ConfigOpus wbscreen: %lx\tMonitorID: %lx\tModeID: %lx\n",wbscreen,wbscreen?GetVPModeID(&wbscreen->ViewPort) & MONITOR_ID_MASK:-1,scr_taglist[1].ti_Data));
1541 if (scr_taglist[1].ti_Data == INVALID_ID) scr_taglist[1].ti_Data = HIRES_KEY;
1542 }
1543 while (!(Screen=OpenScreen((struct NewScreen *)&configscr))) {
1544 if (configscr.Depth<=2) quit();
1545 --configscr.Depth;
1546 }
1547 ShowTitle(Screen,FALSE);
1548 usescreen=Screen;
1549 }
1550 else usescreen=wbscreen;
1551
1552 vp=&usescreen->ViewPort;
1553 config->scrdepth=configscr.Depth;
1554 screen_depth=configscr.Depth;
1555
1556 configwin.Screen=usescreen;
1557 configwin.Height=usescreen->WBorTop+usescreen->Font->ta_YSize+1+192+4;
1558
1559 configwin.LeftEdge=(usescreen->Width-configwin.Width)>>1;
1560 configwin.TopEdge=((usescreen->Height-configwin.Height-(usescreen->Font->ta_YSize+1))>>1)+usescreen->Font->ta_YSize+1;
1561
1562 if (!Screen) {
1563 if (config->config_x>-1) configwin.LeftEdge=config->config_x;
1564 if (config->config_y>-1) configwin.TopEdge=config->config_y;
1565 }
1566
1567 if (configwin.Width+configwin.LeftEdge>usescreen->Width)
1568 configwin.LeftEdge=usescreen->Width-configwin.Width;
1569
1570 if (configwin.Height+configwin.TopEdge>usescreen->Height)
1571 configwin.TopEdge=usescreen->Height-configwin.Height;
1572
1573 if (!(Window=OpenWindow(&configwin))) quit();
1574
1575 if (!Screen) SetWindowTitles(Window,(char *)-1,configscr.DefaultTitle);
1576
1577 rp=Window->RPort;
1578 FSSetMenuStrip(Window,&projectmenu);
1579
1580 x_off=Window->BorderLeft;
1581 y_off=Window->BorderTop;
1582 x_bot=Window->Width-Window->BorderRight-1;
1583 y_bot=Window->Height-Window->BorderBottom-1;
1584
1585 if (tfont) SetFont(rp,tfont);
1586 if (wbscreen) UnlockPubScreen(NULL,wbscreen);
1587 }
1588
1589 load_palette(Screen,config->new_palette,1<<((screen_depth > 4) ? 4 : screen_depth));
1590
1591 doradiobuttons();
1592 fix_gadget_positions();
1593 if (Screen || cmdport) ScreenToFront(Window->WScreen);
1594 }
1595
1596 void close_screen()
1597 {
1598 free_colour_table((Window)?Window->WScreen->ViewPort.ColorMap:NULL);
1599 if (Window) {
1600 if (Window->MenuStrip) ClearMenuStrip(Window);
1601 CloseWindow(Window);
1602 Window=NULL;
1603 }
1604 if (Screen) {
1605 CloseScreen(Screen);
1606 Screen=NULL;
1607 }
1608 onworkbench = 0;
1609 }
1610
1611 void free_colour_table(cm)
1612 struct ColorMap *cm;
1613 {
1614 int a;
1615
1616 if (/*version2>=OSVER_39 &&*/ cm) {
1617 for (a=0;a<16;a++) {
1618 if (screen_pens[a].alloc)
1619 ReleasePen(cm,screen_pens[a].pen);
1620 }
1621 }
1622
1623 for (a=0;a<16;a++) {
1624 screen_pens[a].pen=a;
1625 screen_pens[a].alloc=0;
1626 }
1627 }
1628
1629 unsigned char getkeyshortcut(const char *str)
1630 {
1631 char *c;
1632
1633 if (c = strchr(str,'_')) return LToLower(c[1]);
1634 else return 0;
1635 }
Mirror of AROS' Contrib svn.