dopus/Program/launchexternal.c

   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 "dopus.h"
  32 #include "view.h"
  33 #include <dos/dostags.h>
  34
  35 #ifdef __AROS__
  36 #define STACK_SIZE AROS_STACKSIZE
  37 #else
  38 #define STACK_SIZE 8192
  39 #endif
  40
  41 static ULONG data_window_refresh;              /* Windows that need refreshing */
  42
  43 int start_external(func)
  44 struct dopus_func_start *func;
  45 {
  46     int arg;
  47     char path[256],*ptr;
  48     ULONG stacksize = func->stack;
  49
  50     func->key=NULL;
  51     func->status=0;
  52     func->resseg=NULL;
  53
  54     if (!(func->replyport=LCreatePort(NULL,0))) return(0);
  55     if (!(func->startup.wbstartup.sm_ArgList=LAllocRemember(&func->key,
  56         sizeof(struct WBArg)*(func->argcount+1),MEMF_CLEAR|MEMF_PUBLIC)))
  57         return(0);
  58
  59     func->startup.wbstartup.sm_Message.mn_Node.ln_Type=NT_MESSAGE;
  60     func->startup.wbstartup.sm_Message.mn_ReplyPort=func->replyport;
  61     func->startup.wbstartup.sm_Message.mn_Length=(UWORD)sizeof(struct DOpusStartup);
  62
  63     func->startup.wbstartup.sm_NumArgs=func->argcount;
  64     for (arg=0;arg<func->argcount;arg++)
  65         func->startup.wbstartup.sm_ArgList[arg].wa_Name=func->args[arg];
  66
  67     strcpy(path,func->segname);
  68     if ((ptr=BaseName(path))) *ptr=0;
  69 D(bug("start_external: Lock(%s)\n",path));
  70     if (!(func->startup.wbstartup.sm_ArgList[0].wa_Lock=Lock(path,ACCESS_READ)))
  71         return(0);
  72
  73     func->startup.retcode=0;
  74
  75     func->status=FS_CURDIR;
  76     func->olddir=CurrentDir(func->startup.wbstartup.sm_ArgList[0].wa_Lock);
  77
  78     if (!func->segment) {
  79 //        if (system_version2) {
  80             Forbid();
  81             if ((func->resseg=FindSegment(func->segname,NULL,0))) {
  82 D(bug("Segment %s found\n",func->segname));
  83                 func->resseg->seg_UC++;
  84                 func->segment=func->resseg->seg_Seg;
  85             }
  86             Permit();
  87 //        }
  88         if (!func->segment &&
  89             !(func->segment=(BPTR)LoadSeg(func->segname)))
  90             return(0);
  91     }
  92
  93     func->status=FS_SEGMENT;
  94
  95     func->startup.wbstartup.sm_Segment=func->segment;
  96 D(bug("start_external: CreateProc(%s from %lx)\n",func->procname,func->startup.wbstartup.sm_Segment));
  97 //    if (!(func->startup.wbstartup.sm_Process=CreateProc(func->procname,
  98 //        main_proc->pr_Task.tc_Node.ln_Pri,func->startup.wbstartup.sm_Segment,func->stack)))
  99 // JRZ: begin
 100     if (stacksize < STACK_SIZE) stacksize = STACK_SIZE;
 101     if (!(func->startup.wbstartup.sm_Process=&CreateNewProcTags(NP_Name,        (IPTR)func->procname,
 102                                                                 NP_Priority,    main_proc->pr_Task.tc_Node.ln_Pri,
 103                                                                 NP_Seglist,     func->startup.wbstartup.sm_Segment,
 104                                                                 NP_StackSize,  stacksize,
 105                                                                 NP_FreeSeglist, FALSE,
 106                                                                 NP_CloseInput,  FALSE,
 107                                                                 NP_CloseOutput, FALSE,
 108                                                                 TAG_END)->pr_MsgPort))
 109 // JRZ: end
 110      return(0);
 111
 112     func->startup.wbstartup.sm_ToolWindow=NULL;
 113     PutMsg(func->startup.wbstartup.sm_Process,(struct Message *)&func->startup);
 114
 115     func->status=FS_LAUNCHED;
 116     return(1);
 117 }
 118
 119 int close_external(func,wait)
 120 struct dopus_func_start *func;
 121 int wait;
 122 {
 123     if (func->status>=FS_LAUNCHED && wait) {
 124         WaitPort(func->replyport);
 125         GetMsg(func->replyport);
 126     }
 127     if (func->status>=FS_SEGMENT) {
 128         Forbid();
 129         if (func->resseg) {
 130             func->resseg->seg_UC--;
 131             func->segment=0;
 132         }
 133         else if (!func->flags&FF_SAVESEG && func->segment) {
 134             UnLoadSeg(func->segment);
 135             func->segment=0;
 136         }
 137         Permit();
 138     }
 139     if (func->status>=FS_CURDIR) {
 140         CurrentDir(func->olddir);
 141         UnLock(func->startup.wbstartup.sm_ArgList[0].wa_Lock);
 142     }
 143     if (func->replyport) LDeletePort(func->replyport);
 144     LFreeRemember(&func->key);
 145     return(func->startup.retcode);
 146 }
 147
 148 void doconfig()
 149 {
 150     char buf[100],buf1[20],replyname[50],portname[50],funcpath[80];
 151     int old_bufcount,a;
 152     struct MsgPort *conport,*cmdport;
 153     struct dopusconfigmsg *repmsg;
 154     struct configconfig cfg,*rcfg;
 155     struct ConfigStuff cstuff;
 156     struct dopus_func_start config_func;
 157     char *func_args[2];
 158     char *old_name;
 159     char old_language[30];
 160
 161     if (!(checkwindowquit())) return;
 162
 163     lsprintf(replyname,"%s%ld",config_replyport_basename,(long int)system_dopus_runcount);
 164     if (!(conport=LCreatePort(replyname,20))) return;
 165
 166     lsprintf(buf,"%ld",(long int)system_dopus_runcount);
 167     lsprintf(buf1,"dopus4_config%ld",(long int)system_dopus_runcount);
 168
 169     strcpy(funcpath,"ConfigOpus");
 170
 171     if (!configopus_segment) {
 172         dostatustext(globstring[STR_LOADING_CONFIG]);
 173         FindSystemFile("ConfigOpus",funcpath,80,SYSFILE_MODULE);
 174     }
 175
 176     func_args[0]=funcpath;
 177     func_args[1]=buf;
 178
 179     config_func.segment=configopus_segment;
 180     config_func.procname="ConfigOpus";
 181
 182     config_func.segname=funcpath;
 183     config_func.argcount=2;
 184     config_func.args=func_args;
 185     config_func.stack=STACK_SIZE;
 186     config_func.flags=(config->loadexternal&LOAD_CONFIG)?FF_SAVESEG:0;
 187
 188     if (!(start_external(&config_func))) {
 189         close_external(&config_func,0);
 190         dostatustext(globstring[STR_CONFIG_NOT_FOUND]);
 191         LDeletePort(conport);
 192         return;
 193     }
 194
 195     dostatustext(globstring[STR_WAITING_FOR_PORT]);
 196     lsprintf(portname,"dopus4_config_port%ld",(long int)system_dopus_runcount);
 197     cmdport=NULL;
 198
 199     for (a=0;a<100;a++) {
 200         Forbid();
 201         cmdport=FindPort(portname);
 202         Permit();
 203         if (cmdport) break;
 204         Delay(5);
 205     }
 206
 207     if (!cmdport) {
 208         close_external(&config_func,0);
 209         dostatustext(globstring[STR_CONFIG_NOT_FOUND]);
 210         LDeletePort(conport);
 211         return;
 212     }
 213     status_configuring=-1;
 214     shutthingsdown(1);
 215     old_bufcount=config->bufcount;
 216     strcpy(old_language,config->language);
 217     dotaskmsg(hotkeymsg_port,HOTKEY_KILLHOTKEYS,0,0,NULL,0);
 218
 219     endnotifies();
 220
 221     Forbid();
 222     old_name=arexx_port->mp_Node.ln_Name;
 223     arexx_port->mp_Node.ln_Name="foo";
 224     Permit();
 225
 226     FOREVER {
 227         while ((repmsg=(struct dopusconfigmsg *)GetMsg(conport))) {
 228             switch (repmsg->command) {
 229                 case CONFIG_ALL_DONE:
 230                     ReplyMsg((struct Message *)repmsg);
 231                     goto configdone;
 232                 case CONFIG_GET_CONFIG:
 233                     cfg.config=config;
 234                     cfg.firsttype=dopus_firsttype;
 235                     cfg.typekey=filetype_key;
 236                     cfg.firstbank=dopus_firstgadbank;
 237                     cfg.changed=config_changed;
 238                     cfg.firsthotkey=dopus_firsthotkey;
 239                     strcpy(cfg.configname,str_config_basename);
 240 D(bug("launchexternal: MainScreen = %lx\n",MainScreen));
 241                     cfg.Screen=MainScreen;
 242                     repmsg->buffer=(char *)&cfg;
 243                     break;
 244                 case CONFIG_HERES_CONFIG:
 245                     rcfg=(struct configconfig *)repmsg->buffer;
 246                     dopus_firsttype=rcfg->firsttype;
 247                     dopus_firstgadbank=rcfg->firstbank;
 248                     dopus_firsthotkey=rcfg->firsthotkey;
 249                     filetype_key=rcfg->typekey;
 250                     config_changed=rcfg->changed;
 251                     StrCombine(str_config_file,rcfg->configname,".CFG",256);
 252                     strcpy(str_config_basename,rcfg->configname);
 253 //                    Window=rcfg->Window; MainScreen=rcfg->Screen;
 254                     status_configuring=1;
 255                     break;
 256                 case CONFIG_NEW_HOTKEY:
 257                     dotaskmsg(hotkeymsg_port,HOTKEY_HOTKEYCHANGE,0,0,NULL,0);
 258                     break;
 259             }
 260             ReplyMsg((struct Message *)repmsg);
 261         }
 262
 263         Wait(1<<conport->mp_SigBit);
 264     }
 265
 266 configdone:
 267     config_func.flags=(config->loadexternal&LOAD_CONFIG)?FF_SAVESEG:0;
 268     close_external(&config_func,1);
 269     configopus_segment=config_func.segment;
 270
 271     dopus_curgadbank=dopus_firstgadbank;
 272     data_gadgetrow_offset=data_drive_offset=0;
 273     if (config_changed)
 274      {
 275       if (config_changed==2) config_changed=0;
 276       closedisplay();
 277       status_configuring=-1;
 278   //    Window=NULL; MainScreen=NULL;
 279       dotaskmsg(hotkeymsg_port,HOTKEY_HOTKEYCHANGE,0,0,NULL,0);
 280       dotaskmsg(hotkeymsg_port,HOTKEY_NEWHOTKEYS,0,0,NULL,0);
 281       if (config->bufcount!=old_bufcount) {
 282           allocdirbuffers(config->bufcount);
 283           for (a=0;a<2;a++) strcpy(str_pathbuffer[a],dopus_curwin[a]->directory);
 284       }
 285       if (strcmp(old_language,config->language)) read_data_files(0);
 286
 287       for (a=0;a<3;a++) {
 288           if (!(config->loadexternal&(1<<a)) && external_mod_segment[a]) {
 289               UnLoadSeg(external_mod_segment[a]);
 290               external_mod_segment[a]=0;
 291           }
 292       }
 293
 294       fixcstuff(&cstuff);
 295       CheckConfig(&cstuff);
 296       SetUp(2);
 297 //      config_changed=1;
 298      }
 299     else
 300      {
 301       initclock();
 302       fixcstuff(&cstuff);
 303       setupdisplay(1);
 304       dostatustext(globstring[STR_WELCOME_BACK_TO_DOPUS]);
 305       dopustofront();
 306      }
 307
 308     LDeletePort(conport);
 309
 310     Forbid();
 311     arexx_port->mp_Node.ln_Name=old_name;
 312     Permit();
 313
 314     rexx_command(config->configreturnscript,NULL);
 315
 316     startnotifies();
 317     status_configuring=0;
 318 }
 319
 320 static char *external_modules[3]={
 321     "DOpus_Disk",
 322     "DOpus_Print",
 323     "DOpus_Icon"};
 324
 325 struct DiskData {
 326     int function;
 327     char funcpath[80];
 328     char *args[16];
 329     int argcount;
 330     int background;
 331 };
 332
 333 void dopus_diskop(function,rexx,bg)
 334 int function,rexx,bg;
 335 {
 336     struct ArbiterLaunch launch;
 337     struct DiskData *disk_data;
 338     struct DOpusRemember *memkey=NULL;
 339     int a,fail=1;
 340
 341     if ((disk_data=LAllocRemember(&memkey,sizeof(struct DiskData),MEMF_CLEAR))) {
 342         dostatustext(globstring[STR_STARTING_DISK_MODULE]);
 343
 344         disk_data->function=function;
 345         disk_data->background=bg;
 346
 347         strcpy(disk_data->funcpath,external_modules[SEG_DISK]);
 348         if (external_mod_segment[SEG_DISK] ||
 349            (FindSystemFile(external_modules[SEG_DISK],disk_data->funcpath,80,SYSFILE_MODULE)))
 350         {
 351 D(bug("dopus_diskop: funcpath = %s\n",disk_data->funcpath));
 352             disk_data->args[0]=disk_data->funcpath;
 353
 354             switch (function) {
 355                 case FUNC_FORMAT:
 356                 case FUNC_BGFORMAT:
 357                     disk_data->args[1]="f";
 358                     break;
 359                 case FUNC_DISKCOPY:
 360                 case FUNC_BGDISKCOPY:
 361                     disk_data->args[1]="d";
 362                     break;
 363                 case FUNC_INSTALL:
 364                 case FUNC_BGINSTALL:
 365                     disk_data->args[1]="i";
 366                     break;
 367                 default:
 368                     return;
 369             }
 370
 371             disk_data->argcount=3;
 372
 373             if (rexx) {
 374                 if ((disk_data->argcount+=rexx_argcount)>16) disk_data->argcount=16;
 375                 for (a=3;a<disk_data->argcount;a++) {
 376                     if ((disk_data->args[a]=LAllocRemember(&memkey,strlen(rexx_args[a-3])+1,0)))
 377                         strcpy(disk_data->args[a],rexx_args[a-3]);
 378                 }
 379             }
 380
 381             for (a=disk_data->argcount;a<16;a++) disk_data->args[a]="";
 382
 383             launch.launch_code=(void *)launch_diskop;
 384             launch.launch_name="dopus_disk_launch";
 385             launch.launch_memory=memkey;
 386             launch.data=(APTR)disk_data;
 387
 388             if (!bg) data_window_refresh=0;
 389
 390             arbiter_command(ARBITER_LAUNCH,(APTR)&launch,(bg)?0:ARB_WAIT);
 391
 392             if (!bg) {
 393                 for (a=0;a<2;a++) {
 394                     if (data_window_refresh&(1<<a)) {
 395                         strcpy(str_pathbuffer[a],dopus_curwin[a]->realdevice);
 396                         startgetdir(a,1);
 397                     }
 398                 }
 399             }
 400
 401             okay();
 402             fail=0;
 403         }
 404     }
 405     if (fail) dostatustext(globstring[STR_UNABLE_TO_LOAD_MODULE]);
 406 }
 407
 408 void __saveds launch_diskop()
 409 {
 410     struct Process *my_process;
 411     struct ArbiterMessage *my_startup_message;
 412     struct DiskData *disk_data;
 413     struct MsgPort *control_port;
 414     struct dopus_func_start disk_func;
 415     struct DOpusMessage *dopusmsg;
 416     struct Screen *screen;
 417     char portname[22],portbuf[22];
 418     int retcode=-1;
 419
 420     my_process=(struct Process *)FindTask(NULL);
 421     my_process->pr_WindowPtr=(APTR)-1;
 422     WaitPort(&my_process->pr_MsgPort);
 423     my_startup_message=(struct ArbiterMessage *)GetMsg(&my_process->pr_MsgPort);
 424
 425     disk_data=(struct DiskData *)(my_startup_message->data);
 426
 427     if ((control_port=CreateUniquePort("DOPUS_DISK",portbuf,NULL))) {
 428         disk_func.segment=external_mod_segment[SEG_DISK];
 429         disk_func.procname=external_modules[SEG_DISK];
 430         disk_func.segname=disk_data->funcpath;
 431
 432         StrCombine(portname,"&",portbuf,20);
 433         disk_data->args[2]=portname;
 434
 435         disk_func.argcount=disk_data->argcount;
 436         disk_func.args=disk_data->args;
 437         disk_func.stack=STACK_SIZE;
 438         disk_func.flags=(config->loadexternal&LOAD_DISK)?FF_SAVESEG:0;
 439
 440         if (start_external(&disk_func)) {
 441             struct DOpusRemember *memory=NULL;
 442 //            int newscreen=0;
 443
 444             screen=NULL;
 445 /*
 446             if (disk_data->background && MainScreen &&
 447                 (screen=open_subprocess_screen(globstring[STR_DISK_OP_TITLE],
 448                     scr_font[FONT_REQUEST],&memory,NULL))) newscreen=1;
 449 */
 450             FOREVER {
 451                 if (GetMsg(disk_func.replyport)) break;
 452                 while ((dopusmsg=(struct DOpusMessage *)GetMsg(control_port))) {
 453                     switch (dopusmsg->command) {
 454                         case DOPUSMSG_GETVIS:
 455                             fill_out_visinfo((struct VisInfo *)dopusmsg->data,screen);
 456                             break;
 457                         case DOPUSMSG_UPDATEDRIVE:
 458                             if (!disk_data->background) {
 459                                 BPTR lock,testlock;
 460                                 int win,ret;
 461                                 char *drive;
 462
 463                                 drive=(char *)dopusmsg->data;
 464                                 if (drive && drive[0]) {
 465                                     if ((lock=Lock(drive,ACCESS_READ))) {
 466                                         for (win=0;win<2;win++) {
 467                                             if (dopus_curwin[win]->realdevice[0] &&
 468                                                 (testlock=Lock(dopus_curwin[win]->realdevice,ACCESS_READ))) {
 469                                                 ret=CompareLock(lock,testlock);
 470                                                 if (ret!=LOCK_DIFFERENT) data_window_refresh|=1<<win;
 471                                                 UnLock(testlock);
 472                                             }
 473                                         }
 474                                         UnLock(lock);
 475                                     }
 476                                 }
 477                             }
 478                             break;
 479                     }
 480                     ReplyMsg((struct Message *)dopusmsg);
 481                 }
 482                 Wait(1<<disk_func.replyport->mp_SigBit|1<<control_port->mp_SigBit);
 483             }
 484 //            if (newscreen) CloseScreen(screen);
 485             LFreeRemember(&memory);
 486         }
 487
 488         close_external(&disk_func,0);
 489         external_mod_segment[SEG_DISK]=disk_func.segment;
 490         LDeletePort(control_port);
 491         retcode=0;
 492     }
 493
 494     my_startup_message->command=retcode;
 495     Forbid();
 496     ReplyMsg((struct Message *)my_startup_message);
 497     return;
 498 }
 499
 500 void dopus_print(rexx,arglist,printdir,port,vdata)
 501 int rexx;
 502 struct DOpusArgsList *arglist;
 503 int printdir;
 504 char *port;
 505 struct ViewData *vdata;
 506 {
 507     char *args[16],portname[21],arglistbuf[20],funcpath[80];
 508     struct dopus_func_start print_func;
 509     int a,argcount,waitbits,abase=3;
 510
 511     if (!vdata) dostatustext(globstring[STR_STARTING_PRINT_MODULE]);
 512
 513     print_func.segment=external_mod_segment[SEG_PRINT];
 514     print_func.procname=external_modules[SEG_PRINT];
 515
 516     strcpy(funcpath,external_modules[SEG_PRINT]);
 517
 518     if (!print_func.segment)
 519       FindSystemFile(external_modules[SEG_PRINT],funcpath,80,SYSFILE_MODULE);
 520
 521     print_func.segname=funcpath;
 522
 523     args[0]=print_func.segname;
 524
 525     StrCombine(portname,"&",port,20);
 526     args[1]=portname;
 527
 528     if (printdir) {
 529         int win;
 530
 531         if (!rexx || rexx_argcount<1 ||
 532             (win=atoi(rexx_args[0]))<0 || win>1) win=data_active_window;
 533         lsprintf(arglistbuf,"@%ld",(long int)win);
 534         abase=2;
 535         --rexx_argcount;
 536     }
 537     else lsprintf(arglistbuf,"!%ld",(long int)arglist);
 538
 539     args[2]=arglistbuf;
 540     argcount=3;
 541
 542     if (rexx && rexx_argcount>0) {
 543         if ((argcount+=rexx_argcount)>16) argcount=16;
 544         for (a=3;a<argcount;a++) args[a]=rexx_args[a-abase];
 545     }
 546
 547     for (a=argcount;a<16;a++) args[a]="";
 548
 549     print_func.argcount=argcount;
 550     print_func.args=args;
 551     print_func.stack=STACK_SIZE;
 552     print_func.flags=(config->loadexternal&LOAD_PRINT)?FF_SAVESEG:0;
 553
 554     if (!(start_external(&print_func))) {
 555         close_external(&print_func,0);
 556         if (!vdata) dostatustext(globstring[STR_UNABLE_TO_LOAD_MODULE]);
 557         return;
 558     }
 559
 560     waitbits=1<<print_func.replyport->mp_SigBit;
 561     if (vdata) waitbits|=1<<vdata->view_port->mp_SigBit;
 562     else waitbits|=rexx_signalbit;
 563
 564     FOREVER {
 565         if ((Wait(waitbits))&rexx_signalbit && !vdata) {
 566             rexx_dispatch(0);
 567             continue;
 568         }
 569         if (vdata) {
 570             struct DOpusMessage *dmsg;
 571             struct DOpusArgsList *arg;
 572
 573             while ((dmsg=(struct DOpusMessage *)GetMsg(vdata->view_port))) {
 574                 switch (dmsg->command) {
 575                     case DOPUSMSG_GETVIS:
 576                         CopyMem((char *)&vdata->view_vis_info,(char *)dmsg->data,
 577                             sizeof(struct VisInfo));
 578                         break;
 579                     case DOPUSMSG_GETNEXTFILE:
 580                         arg=(struct DOpusArgsList *)dmsg->data;
 581                         if (arg->single_file) {
 582                             strcpy(arg->file_data,arg->single_file);
 583                             arg->single_file=NULL;
 584                         }
 585                         else arg->file_data[0]=0;
 586                         break;
 587                 }
 588                 ReplyMsg((struct Message *)dmsg);
 589             }
 590         }
 591         if (GetMsg(print_func.replyport)) break;
 592     }
 593
 594     close_external(&print_func,0);
 595     external_mod_segment[SEG_PRINT]=print_func.segment;
 596
 597     if (!vdata) okay();
 598 }
 599
 600 int dopus_iconinfo(filename)
 601 char *filename;
 602 {
 603     char *args[3],portname[14],funcpath[80];
 604     struct dopus_func_start icon_func;
 605     int a;
 606
 607     icon_func.segment=external_mod_segment[SEG_ICON];
 608     icon_func.procname=external_modules[SEG_ICON];
 609
 610     strcpy(funcpath,external_modules[SEG_ICON]);
 611
 612     if (!icon_func.segment)
 613         FindSystemFile(external_modules[SEG_ICON],funcpath,80,SYSFILE_MODULE);
 614
 615     icon_func.segname=funcpath;
 616
 617     StrCombine(portname,"&",str_arexx_portname,13);
 618
 619     args[0]=icon_func.segname;
 620     args[1]=portname;
 621     args[2]=filename;
 622
 623     icon_func.argcount=3;
 624     icon_func.args=args;
 625     icon_func.stack=STACK_SIZE;
 626     icon_func.flags=(config->loadexternal&LOAD_ICON)?FF_SAVESEG:0;
 627
 628     if (!(start_external(&icon_func))) {
 629         close_external(&icon_func,0);
 630         dostatustext(globstring[STR_UNABLE_TO_LOAD_MODULE]);
 631         return(-4);
 632     }
 633
 634     FOREVER {
 635         if ((Wait(1<<icon_func.replyport->mp_SigBit|rexx_signalbit))&rexx_signalbit) {
 636             rexx_dispatch(0);
 637             continue;
 638         }
 639         if (GetMsg(icon_func.replyport)) break;
 640     }
 641
 642     a=close_external(&icon_func,0);
 643     external_mod_segment[SEG_ICON]=icon_func.segment;
 644     return(a);
 645 }
 646
 647 void setup_externals()
 648 {
 649     int a;
 650     char funcbuf[256];
 651     APTR wsave;
 652
 653     wsave=main_proc->pr_WindowPtr;
 654     main_proc->pr_WindowPtr=(APTR)-1;
 655
 656     if (config->loadexternal&LOAD_CONFIG) {
 657         FindSystemFile("ConfigOpus",funcbuf,256,SYSFILE_MODULE);
 658         configopus_segment=LoadSeg(funcbuf);
 659     }
 660     else configopus_segment=NULL;
 661
 662     for (a=0;a<3;a++) {
 663         if (config->loadexternal&(1<<a)) {
 664             FindSystemFile(external_modules[a],funcbuf,256,SYSFILE_MODULE);
 665             external_mod_segment[a]=LoadSeg(funcbuf);
 666         }
 667         else external_mod_segment[a]=NULL;
 668     }
 669
 670     main_proc->pr_WindowPtr=wsave;
 671 }
 672
 673 void fill_out_visinfo(vis,scr)
 674 struct VisInfo *vis;
 675 struct Screen *scr;
 676 {
 677     if (scr && (!Window || Window->WScreen!=scr)) {
 678         vis->vi_flags&=~VISF_WINDOW;
 679         vis->vi_screen=scr;
 680
 681         vis->vi_fg=config->requestfg;
 682         vis->vi_bg=config->requestbg;
 683         vis->vi_shine=config->gadgettopcol;
 684         vis->vi_shadow=config->gadgetbotcol;
 685         vis->vi_stringcol[0]=config->stringfgcol;
 686         vis->vi_stringcol[1]=config->stringbgcol;
 687         vis->vi_activestringcol[0]=config->stringselfgcol;
 688         vis->vi_activestringcol[1]=config->stringselbgcol;
 689     }
 690     else {
 691         if (vis->vi_flags&VISF_WINDOW) vis->vi_screen=(struct Screen *)Window;
 692         else if (Window) vis->vi_screen=Window->WScreen;
 693         else vis->vi_screen=NULL;
 694
 695         vis->vi_fg=screen_pens[config->requestfg].pen;
 696         vis->vi_bg=screen_pens[config->requestbg].pen;
 697         vis->vi_shine=screen_pens[config->gadgettopcol].pen;
 698         vis->vi_shadow=screen_pens[config->gadgetbotcol].pen;
 699         vis->vi_stringcol[0]=screen_pens[config->stringfgcol].pen;
 700         vis->vi_stringcol[1]=screen_pens[config->stringbgcol].pen;
 701         vis->vi_activestringcol[0]=screen_pens[config->stringselfgcol].pen;
 702         vis->vi_activestringcol[1]=screen_pens[config->stringselbgcol].pen;
 703     }
 704
 705     if (vis->vi_flags&VISF_8POINTFONT) vis->vi_font=scr_font[FONT_GENERAL];
 706     else vis->vi_font=scr_font[FONT_REQUEST];
 707
 708     if (config->generalscreenflags&SCR_GENERAL_REQDRAG)
 709         vis->vi_flags|=VISF_BORDERS;
 710     else vis->vi_flags&=~VISF_BORDERS;
 711
 712     vis->vi_language=config->language;
 713 }