home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / DOpus4-GPL / Program / main.c < prev    next >
C/C++ Source or Header  |  2000-01-27  |  42KB  |  1,430 lines
  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.  
  33. int CXBRK(void);
  34. void chkabort(void);
  35.  
  36. int  CXBRK(void) { return(0); }  /* Disable Lattice CTRL/C handling */
  37. void chkabort(void) { return; } 
  38.  
  39. void main(argc,argv)
  40. int argc;
  41. char *argv[];
  42. {
  43.     int a,in,iconstart,sup,ck,nsee;
  44.     struct WBStartup *WBmsg;
  45.     struct WBArg *p;
  46.     struct DiskObject *dobj;
  47.     char **toolarray,*s;
  48.     BPTR lock;
  49.  
  50.  
  51.     /* Work out what version of the Operating System we're running.
  52.        Anything less than v37 (2.04) is counted as being v34 (1.3) */
  53.  
  54.     if (SysBase->LibNode.lib_Version>=40) system_version2=OSVER_40;
  55.     else if (SysBase->LibNode.lib_Version==39) system_version2=OSVER_39;
  56.     else if (SysBase->LibNode.lib_Version==38) system_version2=OSVER_38;
  57.     else if (SysBase->LibNode.lib_Version==37) system_version2=OSVER_37;
  58.     else system_version2=OSVER_34;
  59.  
  60.  
  61.     /* Get pointer to our Process structure and set our WindowPtr for
  62.        errors to -1 (no errors appear). */
  63.  
  64.     main_proc=(struct Process *) FindTask(NULL);
  65.  
  66.  
  67.     /* status_flags contains various flags; initialise it to 0 to start with */
  68.  
  69.     status_flags=0;
  70.  
  71.  
  72.     /* Attempt to open the DOPUS.LIBRARY. Look first in default search path, and
  73.        then look for it on the distribution disk. If we can't find it, or
  74.        if our stack size is too low (must be >=16384 bytes), display an
  75.        appropriate alert and exit */
  76.  
  77.     if (!(DOpusBase=(struct DOpusBase *)OpenLibrary("dopus.library",DOPUSLIB_VERSION)))
  78.         DOpusBase=(struct DOpusBase *)OpenLibrary("dopus:libs/dopus.library",DOPUSLIB_VERSION);
  79.  
  80.     if (!DOpusBase || main_proc->pr_StackSize<16384) {
  81.         IntuitionBase=(struct IntuitionBase *) OpenLibrary("intuition.library",0);
  82.         if (!DOpusBase) {
  83.             char buf[80];
  84.  
  85.             lsprintf(&buf[2],"\xf                You need dopus.library v%ld+ to use Directory Opus!",DOPUSLIB_VERSION);
  86.             buf[0]=0;
  87.             buf[1]=0;
  88.             buf[(strlen(buf)+1)]=0;
  89.             DisplayAlert(RECOVERY_ALERT,buf,26);
  90.         }
  91.         else DisplayAlert(RECOVERY_ALERT,"\x00\x00\xf                       Stack must be at least 16384 bytes!\x00\x00",26);
  92.         CloseLibrary((struct Library *) IntuitionBase);
  93. #ifdef __SASC_60
  94.         __exit(0);
  95. #else
  96.         _exit(0);
  97. #endif
  98.     }
  99.  
  100.  
  101.     windowptr_save=main_proc->pr_WindowPtr;
  102.     main_proc->pr_WindowPtr=(APTR)-1;
  103.  
  104.     /* Initialise and open the other libraries that we need or want */
  105.  
  106.     GfxBase=DOpusBase->GfxBase;
  107.     IntuitionBase=DOpusBase->IntuitionBase;
  108.     LayersBase=(struct Library *)DOpusBase->LayersBase;
  109.  
  110.     DiskfontBase=OpenLibrary("diskfont.library",0);
  111.     IconBase=OpenLibrary("icon.library",0);
  112.     WorkbenchBase=OpenLibrary("workbench.library",37);
  113.     CxBase=OpenLibrary("commodities.library",37);
  114.     RexxSysBase=OpenLibrary("rexxsyslib.library",0);
  115.     UtilityBase=OpenLibrary("utility.library",37);
  116.  
  117.     AccountsBase=NULL;
  118.  
  119.     Forbid();
  120.     if (FindName(&SysBase->LibList,"services.library")) {
  121.         if (AccountsBase=OpenLibrary("accounts.library",0)) {
  122.             user_info=AllocUserInfo();
  123.             group_info=AllocGroupInfo();
  124.         }
  125.     }
  126.     Permit();
  127.  
  128.     PPBase=open_dopus_library("powerpacker.library",0);
  129.     MUSICBase=open_dopus_library("inovamusic.library",0);
  130.  
  131.  
  132.     /* Restore window pointer now that we've got our libraries */
  133.  
  134.     main_proc->pr_WindowPtr=windowptr_save;
  135.  
  136.  
  137.     /* Construct the version string from the #defined version numbers */
  138.  
  139. #ifdef DOPUS_SECRET_VERSION
  140.     lsprintf(str_version_string,"%ld.%s",DOPUS_VERSION,DOPUS_SECRET_VERSION);
  141. #else
  142.     lsprintf(str_version_string,"%ld.%s",DOPUS_VERSION,DOPUS_REVISION);
  143. #endif
  144. #ifdef DOPUS_LETTERREV
  145.     strcat(str_version_string,DOPUS_LETTERREV);
  146. #endif
  147.  
  148.  
  149.     /* Initialise various data */
  150.  
  151.     str_hunt_name[0]=0;
  152.     str_search_string[0]=0;
  153.     str_filter[0]=0;
  154.     str_filter_parsed[0]=0;
  155.     str_last_rexx_result[0]=0;
  156.  
  157.     func_single_file[0]=0;
  158.     func_external_file[0]=0;
  159.  
  160.     for (a=0;a<NUMFONTS;a++) scr_font[a]=NULL;
  161.     for (a=0;a<3;a++) external_mod_segment[a]=0;
  162.  
  163.     for (a=0;a<2;a++) {
  164.         dos_notify_req[a]=NULL;
  165.         dos_notify_names[a][0]=0;
  166.         dopus_curwin[a]=dopus_firstwin[a]=NULL;
  167.         data_buffer_count[a]=0;
  168.         completion[a].memory=NULL;
  169.         completion[a].firstentry=NULL;
  170.         completion[a].currententry=NULL;
  171.         completion[a].path[0]=0;
  172.     }
  173.  
  174.     for (a=0;a<16;a++) screen_pens[a].alloc=0;
  175.  
  176.     func_reselection.reselection_list=NULL;
  177.  
  178.     old_pr_cis=main_proc->pr_CIS;
  179.     old_pr_cos=main_proc->pr_COS;
  180.     old_pr_consoletask=main_proc->pr_ConsoleTask;
  181.  
  182.     nil_file_handle=Open("NIL:",MODE_NEWFILE);
  183.     main_proc->pr_CIS=nil_file_handle;
  184.     main_proc->pr_COS=nil_file_handle;
  185.     main_proc->pr_ConsoleTask=(APTR)((struct FileHandle *)BADDR(nil_file_handle))->fh_Type;
  186.  
  187.     scrdata_is_pal=getpal();
  188.  
  189.     iconstart=in=0;
  190.     strcpy(str_config_basename,"DirectoryOpus");
  191.     ck=1;
  192.  
  193.     if (argc>1) {
  194.         for (a=1;a<argc;a++) {
  195.             if (argv[a][0]=='-') {
  196.                 switch (argv[a][1]) {
  197.                     case 'i': iconstart=1; break;
  198.                     case 'b': iconstart=2; break;
  199.                     case 'c': LStrnCpy(str_config_basename,&argv[a][2],256); break;
  200.                     case 'g': ck=0; break;
  201.                     case 'q': status_flags|=STATUS_IANSCRAP; break;
  202.                     case 'Q': status_flags|=STATUS_IANSCRAP2; break;
  203.                 }
  204.             }
  205.         }
  206.     }
  207.     else if (argc==0 && IconBase) {
  208.         WBmsg=(struct WBStartup *)argv;
  209.         p=WBmsg->sm_ArgList;
  210.         if ((dobj=GetDiskObject(p->wa_Name))) {
  211.             toolarray=(char **)dobj->do_ToolTypes;
  212.             if ((s=(char *)FindToolType(toolarray,"ICONSTART")))
  213.                 iconstart=atoi(s);
  214.             if ((s=(char *)FindToolType(toolarray,"BUTTONSTART")))
  215.                 iconstart=atoi(s)?2:iconstart;
  216.             if ((s=(char *)FindToolType(toolarray,"CONFIGFILE")))
  217.                 LStrnCpy(str_config_basename,s,256);
  218.             if ((s=(char *)FindToolType(toolarray,"CHECK")))
  219.                 ck=atoi(s);
  220.             FreeDiskObject(dobj);
  221.         }
  222.     }
  223.  
  224.     if ((s=strstri(BaseName(str_config_basename),".CFG"))) *s=0;
  225.  
  226.     allocstrings();
  227.     if (system_version2>=OSVER_39) nullpalette=(UWORD *)astring(3072);
  228.     else nullpalette=(UWORD *)astring(64);
  229.  
  230.     scrdata_norm_width=GfxBase->NormalDisplayColumns;
  231.     scrdata_norm_height=GfxBase->NormalDisplayRows;
  232.  
  233.     main_proc->pr_WindowPtr=(APTR)-1;
  234.  
  235.     FindSystemFile("DOpusRT",str_dopusrt_path,256,SYSFILE_COMMAND);
  236.  
  237.     config=(struct Config *)astring(sizeof(struct Config));
  238.     filetype_key=NULL;
  239.     dopus_firsttype=NULL;
  240.     dopus_firstgadbank=NULL;
  241.     dopus_curgadbank=NULL;
  242.     dopus_firsthotkey=NULL;
  243.  
  244.     read_configuration(0);
  245.  
  246.     if (!(lock=Lock("ENV:",ACCESS_READ))) Assign("ENV:","RAM:");
  247.     else UnLock(lock);
  248.  
  249.     if (!(arexx_port=CreateUniquePort("DOPUS",str_arexx_portname,&system_dopus_runcount)))
  250.         quit();
  251.  
  252.     rexx_signalbit=1<<arexx_port->mp_SigBit;
  253.  
  254.     if (!(install_arbiter()) ||
  255.         !(count_port=LCreatePort(NULL,0)) ||
  256.         !(general_port=LCreatePort(0,0))) quit();
  257.  
  258.     if (system_version2) {
  259.         if (WorkbenchBase) {
  260.             if (!(appmsg_port=LCreatePort(0,0))) quit();
  261.         }
  262.         for (a=0;a<2;a++) {
  263.             if (dos_notify_req[a]=LAllocRemember(&general_key,
  264.                 sizeof(struct NotifyRequest),
  265.                 MEMF_CLEAR))
  266.                 dos_notify_req[a]->nr_Name=dos_notify_names[a];
  267.         }
  268.     }
  269.  
  270.     if (!(keyboard_req=(struct IOStdReq *)
  271.         LCreateExtIO(general_port,sizeof(struct IOStdReq)))) quit();
  272.     if ((OpenDevice("keyboard.device",0,(struct IORequest *)keyboard_req,0))!=0) {
  273.         LDeleteExtIO((struct IORequest *)keyboard_req); keyboard_req=NULL;
  274.         quit();
  275.     }
  276.     if (!(input_req=(struct IOStdReq *)
  277.         LCreateExtIO(general_port,sizeof(struct IOStdReq)))) quit();
  278.     if ((OpenDevice("input.device",0,(struct IORequest *)input_req,0))!=0) {
  279.         LDeleteExtIO((struct IORequest *)input_req); input_req=NULL;
  280.         quit();
  281.     }
  282.  
  283.     ramdisk_lock=Lock("RAM:",ACCESS_READ);
  284.  
  285.     strcpy(str_select_pattern[0],"*");
  286.  
  287.     init_menus();
  288.  
  289.     if (ck && (FindTask("dopus_hotkeez"))) {
  290.         status_iconified=1;
  291.         if (!(simplerequest(globstring[STR_DOPUS_ALREADY_RUNNING],
  292.             globstring[STR_RUN],str_cancelstring,NULL)))
  293.             quit();
  294.         status_iconified=0;
  295.     }
  296.  
  297.     if (scrdata_is_pal) data_colorclock=3546895;
  298.     else data_colorclock=3579545;
  299.  
  300.     setup_externals();
  301.     setupchangestate();
  302.     do_remember_config(remember_data);
  303.  
  304.     if (!(dir_memory_pool=LibCreatePool(MEMF_ANY|MEMF_CLEAR,16384,1024)))
  305.         quit();
  306.  
  307.     allocdirbuffers(config->bufcount);
  308.  
  309.     for (a=0;a<2;a++) horiz_propimage[a].Width=65;
  310.  
  311.     hotkey_task=(struct Task *) CreateTask("dopus_hotkeez",config->priority+1,hotkeytaskcode,2048);
  312.  
  313.     if (iconstart) SetUp(-1);
  314.  
  315.     sup=nsee=0;
  316.     if (config->autodirs[0][0] || config->autodirs[1][0]) {
  317.         if (!iconstart) {
  318.             sup=1;
  319.             SetUp(1);
  320.             busy();
  321.         }
  322.         nsee=1;
  323.         for (a=0;a<2;a++) {
  324.             if (config->autodirs[a][0]) {
  325.                 strcpy(str_pathbuffer[a],config->autodirs[a]);
  326.                 checkdir(str_pathbuffer[a],(sup)?&path_strgadget[a]:NULL);
  327.                 strcpy(dopus_curwin[a]->directory,str_pathbuffer[a]);
  328.                 getdir(dopus_curwin[a],a,0);
  329.             }
  330.         }
  331.     }
  332.     if (iconstart) {
  333.         status_configuring=0;
  334.         iconify(sup+1,iconstart-1,0);
  335.     }
  336.     else if (!sup) SetUp(1);
  337.     if (nsee) {
  338.         for (a=0;a<2;a++) {
  339.             seename(a);
  340.             checkdir(str_pathbuffer[a],&path_strgadget[a]);
  341.             fixhorizprop(a);
  342.         }
  343.     }
  344.     if (!iconstart) unbusy();
  345.     doidcmp();
  346. }
  347.  
  348. SetUp(tit)
  349. int tit;
  350. {
  351.     int y,a,b,c,count=0,lim=48,num,other_offset;
  352.     struct Screen scrbuf,*pubscr=NULL;
  353.     struct DimensionInfo dims;
  354.     DisplayInfoHandle *handle;
  355.     struct dopusgadgetbanks *bank;
  356.     struct RastPort testrastport;
  357.  
  358.     removewindowgadgets(Window);
  359.  
  360.     SetTaskPri((struct Task *)main_proc,config->priority);
  361.     if (hotkey_task) SetTaskPri(hotkey_task,config->priority+1);
  362.     status_configuring=-1; status_iconified=0;
  363.  
  364.     main_scr.ViewModes=HIRES;
  365.     config->screenmode=checkscreenmode(config->screenmode);
  366.  
  367.     main_win.Flags=WFLG_NW_EXTENDED;
  368.     mainwindow_tags[0].ti_Tag=TAG_SKIP;
  369.     mainwindow_tags[0].ti_Data=0;
  370.     if (status_flags&STATUS_IANSCRAP2) {
  371.         mainwindow_tags[2].ti_Tag=TAG_SKIP;
  372.         mainwindow_tags[2].ti_Data=0;
  373.     }
  374.  
  375.     if (config->screenmode==MODE_PUBLICSCREEN && system_version2 &&
  376.         (pubscr=LockPubScreen(config->pubscreen_name))) {
  377.         CopyMem((char *)pubscr,(char *)&scrbuf,sizeof(struct Screen));
  378.     }
  379.     else {
  380.         GetWBScreen(&scrbuf);
  381.         if (config->screenmode==MODE_PUBLICSCREEN) config->screenmode=MODE_WORKBENCHUSE;
  382.     }
  383.  
  384.     setup_draw_info();
  385.  
  386.     if (config->screenmode==MODE_WORKBENCHUSE || config->screenmode==MODE_PUBLICSCREEN)
  387.         status_publicscreen=1;
  388.     else {
  389.         status_publicscreen=0;
  390.         if (config->screenmode==MODE_WORKBENCHCLONE) {
  391.             mainscreen_tags[SCREENTAGS_DISPLAYID].ti_Data=clone_screen(NULL,&main_scr);
  392.         }
  393.         else if (!system_version2) {
  394.             if (config->screenflags&SCRFLAGS_DEFWIDTH)
  395.                 main_scr.Width=GfxBase->NormalDisplayColumns;
  396.             else main_scr.Width=config->scrw;
  397.             if (config->screenflags&SCRFLAGS_DEFHEIGHT) {
  398.                 if (config->screenmode==HIRESLACE_KEY)
  399.                     main_scr.Height=GfxBase->NormalDisplayRows*2;
  400.                 else main_scr.Height=GfxBase->NormalDisplayRows;
  401.             }
  402.             else main_scr.Height=config->scrh;
  403.             if (config->screenmode==HIRESLACE_KEY) main_scr.ViewModes|=LACE;
  404.         }
  405.         else {
  406.             if ((handle=FindDisplayInfo(config->screenmode)) &&
  407.                 (GetDisplayInfoData(handle,(UBYTE *)&dims,sizeof(struct DimensionInfo),
  408.                 DTAG_DIMS,0))) {
  409.                 mainscreen_tags[SCREENTAGS_DISPLAYID].ti_Data=(ULONG)config->screenmode;
  410.                 if (config->screenflags&SCRFLAGS_DEFWIDTH)
  411.                     main_scr.Width=(dims.TxtOScan.MaxX-dims.TxtOScan.MinX)+1;
  412.                 else main_scr.Width=config->scrw;
  413.                 if (config->screenflags&SCRFLAGS_DEFHEIGHT)
  414.                     main_scr.Height=(dims.TxtOScan.MaxY-dims.TxtOScan.MinY)+1;
  415.                 else main_scr.Height=config->scrh;
  416.             }
  417.             else {
  418.                 main_scr.Width=scrbuf.Width;
  419.                 main_scr.Height=scrbuf.Height;
  420.                 main_scr.ViewModes=scrbuf.ViewPort.Modes;
  421.             }
  422.         }
  423.     }
  424.  
  425.     if (config->scrdepth<2) config->scrdepth=2;
  426.     main_scr.Depth=config->scrdepth;
  427.  
  428.     if (config->gadgetrows<0 || config->gadgetrows>6) config->gadgetrows=6;
  429.     scr_gadget_rows=config->gadgetrows;
  430.     if (data_gadgetrow_offset+scr_gadget_rows>6) data_gadgetrow_offset=0;
  431.  
  432. tryfonts:
  433.     if (count==5) {
  434.         status_iconified=1;
  435.         simplerequest(globstring[STR_UNABLE_TO_OPEN_WINDOW],globstring[STR_CONTINUE],NULL);
  436.         status_iconified=0;
  437.         quit();
  438.     }
  439.     else if (count==4) {
  440.         for (a=0;a<NUMFONTS;a++) {
  441.             if (config->fontsizes[a]>8) {
  442.                 strcpy(config->fontbufs[a],"topaz.font");
  443.                 config->fontsizes[a]=8;    
  444.             }
  445.         }
  446.     }
  447.     else if (count) {
  448.         if (Window) busy();
  449.         for (a=0;a<NUMFONTS;a++) {
  450.             if (config->fontsizes[a]>lim) config->fontsizes[a]/=2;
  451.         }
  452.         lim/=2;
  453.     }
  454.  
  455.     config->fontsizes[0]=8;
  456.     for (a=0;a<FONT_LAST;a++) {
  457.         freefont(a);
  458.         b=config->fontsizes[a];
  459.         scr_font[a]=getfont(config->fontbufs[a],&b,(a<3));
  460.         config->fontsizes[a]=b;
  461.     }
  462.  
  463.     if (Window && count) unbusy();
  464.  
  465.     scrdata_font_xsize=scr_font[FONT_DIRS]->tf_XSize;
  466.     scrdata_font_ysize=scr_font[FONT_DIRS]->tf_YSize;
  467.     scrdata_font_baseline=scr_font[FONT_DIRS]->tf_Baseline;
  468.  
  469.     screen_attr.ta_Name=(STRPTR)config->fontbufs[FONT_GENERAL];
  470.     menu_attr.ta_Name=(STRPTR)config->fontbufs[FONT_MENUS];
  471.     menu_attr.ta_YSize=config->fontsizes[FONT_MENUS];
  472.     main_screen_attr.ta_Name=(STRPTR)config->fontbufs[FONT_SCREEN];
  473.     main_screen_attr.ta_YSize=config->fontsizes[FONT_SCREEN];
  474.  
  475.     if (tit>-1) {
  476.         if (config->screenmode==MODE_WORKBENCHUSE) main_win.Type=WBENCHSCREEN;
  477.         else if (pubscr) {
  478.             main_win.Type=PUBLICSCREEN;
  479.             mainwindow_tags[0].ti_Tag=WA_PubScreen;
  480.             mainwindow_tags[0].ti_Data=(ULONG)pubscr;
  481.         }
  482.         else {
  483.             main_win.Type=CUSTOMSCREEN;
  484.  
  485.             if (system_version2) {
  486.                 main_scr.LeftEdge=(GfxBase->NormalDisplayColumns-main_scr.Width)/2;
  487.                 if (main_scr.LeftEdge<0) main_scr.LeftEdge=0;
  488.             }
  489.             else main_scr.LeftEdge=0;
  490.  
  491.             main_scr.TopEdge=0;
  492.             if (config->screenflags&SCRFLAGS_HALFHEIGHT) {
  493.                 if (main_scr.Height<400) config->screenflags&=~SCRFLAGS_HALFHEIGHT;
  494.                 else {
  495.                     main_scr.Height/=2;
  496.                     main_scr.TopEdge=main_scr.Height;
  497.                 }
  498.             }
  499.  
  500.             if (!MainScreen) {
  501.                 if (!(MainScreen=(struct Screen *) OpenScreen((struct NewScreen *)&main_scr))) {
  502.                     status_iconified=1;
  503.                     simplerequest(globstring[STR_UNABLE_TO_OPEN_WINDOW],globstring[STR_CONTINUE],NULL);
  504.                     status_iconified=0;
  505.                     if (config->screenmode==HIRES_KEY && config->scrw==640 &&
  506.                         config->scrh==200+(scrdata_is_pal*56) && config->screenflags==0 &&
  507.                         config->scrdepth==2) quit();
  508.                     config->screenmode=HIRES_KEY;
  509.                     config->scrw=640;    
  510.                     config->scrh=200+(scrdata_is_pal*56);
  511.                     config->scrdepth=2;
  512.                     config->screenflags=0;
  513.                     if (pubscr) UnlockPubScreen(NULL,pubscr);
  514.                     return(SetUp(tit));
  515.                 }
  516.                 main_vp=&(MainScreen->ViewPort);
  517.                 load_palette(MainScreen,config->new_palette);
  518.  
  519.                 main_win.Screen=MainScreen;
  520.                 if (system_version2) PubScreenStatus(MainScreen,0);
  521.                 if (status_flags&STATUS_IANSCRAP2) ShowTitle(MainScreen,FALSE);
  522.                 CopyMem((char *)MainScreen,(char *)&scrbuf,sizeof(struct Screen));
  523.             }
  524.         }
  525.     }
  526.  
  527.     if (config->generalscreenflags&SCR_GENERAL_WINBORDERS && MainScreen)
  528.         status_publicscreen=1;
  529.  
  530.     /* Screen clock bar */
  531.  
  532.     scrdata_clock_height=scr_font[FONT_CLOCK]->tf_YSize+2;
  533.     if (scrdata_clock_height<10) scrdata_clock_height=10;
  534.  
  535.     /* Status bar */
  536.  
  537.     if (config->generalscreenflags&SCR_GENERAL_TITLESTATUS)
  538.         scrdata_status_height=0;
  539.     else scrdata_status_height=scr_font[FONT_STATUS]->tf_YSize+3;
  540.  
  541.     /* Disk name bars */
  542.  
  543.     scrdata_diskname_height=scr_font[FONT_NAMES]->tf_YSize+2;
  544.  
  545.     /* String gadgets */
  546.  
  547.     scrdata_string_height=config->stringheight;
  548.     if (scrdata_string_height<scr_font[FONT_STRING]->tf_YSize)
  549.         scrdata_string_height=scr_font[FONT_STRING]->tf_YSize;
  550.  
  551.     /* Calculate window borders */
  552.  
  553.     if (status_publicscreen) {
  554.         if (MainScreen) {
  555.             scrdata_xoffset=MainScreen->WBorLeft;    
  556.             scrdata_yoffset=MainScreen->WBorTop+scr_font[FONT_SCREEN]->tf_YSize+1;
  557.         }
  558.         else {
  559.             scrdata_xoffset=scrbuf.WBorLeft;
  560.             scrdata_yoffset=scrbuf.WBorTop+scrbuf.Font->ta_YSize+1;
  561.         }
  562.     }
  563.     else {
  564.         scrdata_xoffset=0;
  565.         if (status_flags&STATUS_IANSCRAP2) scrdata_yoffset=0;
  566.         else if (MainScreen) scrdata_yoffset=MainScreen->BarHeight+1;
  567.         else scrdata_yoffset=GfxBase->DefaultFont->tf_YSize+3;
  568.     }
  569.  
  570.     /* Calculcate minimum window width and height */
  571.  
  572.     scr_min_width=(config->sliderwidth+8)*2+(config->arrowsize[1]+config->arrowsize[2])*4;
  573.     if (scr_gadget_rows) scr_min_width+=8*(scr_font[FONT_GADGETS]->tf_XSize*2);
  574.     scr_min_width+=scrdata_font_xsize*8;
  575.  
  576.     scr_min_height=
  577.         ((status_publicscreen)?scrdata_yoffset:0)+
  578.         scrdata_status_height+
  579.         scrdata_diskname_height+
  580.         (config->arrowsize[0]*3)+
  581.         config->sliderheight+
  582.         scrdata_string_height+
  583.         scrdata_clock_height+
  584.         (scr_font[FONT_GADGETS]->tf_YSize*2)+
  585.         20;
  586.  
  587.     if (main_scr.Width<scr_min_width) main_scr.Width=scr_min_width;
  588.     if (main_scr.Height<scr_min_height) main_scr.Height=scr_min_height;
  589.     if (Window) WindowLimits(Window,scr_min_width,scr_min_height,-1,-1);
  590.     else {
  591.         main_win.MinWidth=scr_min_width;
  592.         main_win.MinHeight=scr_min_height;
  593.     }
  594.  
  595.     /* Get window size */
  596.  
  597.     if (status_publicscreen) main_win.Width=config->scr_winw;
  598.     else main_win.Width=config->scrw;
  599.     if (config->screenflags&SCRFLAGS_DEFWIDTH || main_win.Width<0)
  600.         main_win.Width=scrbuf.Width;
  601.     if (main_win.Width>scrbuf.Width) main_win.Width=scrbuf.Width;
  602.  
  603.     if (status_publicscreen) main_win.Height=config->scr_winh;
  604.     else main_win.Height=main_scr.Height;
  605.     if (config->screenflags&SCRFLAGS_DEFHEIGHT || main_win.Height<0) {
  606.         main_win.Height=scrbuf.Height;
  607.         if (status_publicscreen) {
  608.             config->scr_winy=scrbuf.BarHeight+1;
  609.             main_win.Height-=config->scr_winy;
  610.         }
  611.     }
  612.     if (main_win.Height>scrbuf.Height) main_win.Height=scrbuf.Height;
  613.  
  614.     /* If window is already open use it's dimensions (this is a mess actually) */
  615.     if (Window) {
  616.         main_win.Width=Window->Width;
  617.         main_win.Height=Window->Height;
  618.     }
  619.  
  620.     /* Adjust for window borders */
  621.  
  622.     if (status_publicscreen) {
  623.         scrdata_width=main_win.Width-scrdata_xoffset-scrbuf.WBorRight;
  624.         scrdata_height=main_win.Height-scrdata_yoffset-scrbuf.WBorBottom;
  625.     }
  626.     else {
  627.         scrdata_width=main_scr.Width-scrdata_xoffset;
  628.         scrdata_height=main_scr.Height-scrdata_yoffset;
  629.     }
  630.  
  631.     /* Screen clock bar */
  632.  
  633.     scrdata_clock_width=scrdata_width-((config->generalscreenflags&SCR_GENERAL_TINYGADS)?115:1);
  634.     scrdata_clock_xpos=scrdata_xoffset+2;
  635.     scrdata_clock_ypos=(scrdata_yoffset+scrdata_height+1)-scrdata_clock_height+1;
  636.  
  637.     /* Disk name bars */
  638.  
  639.     scrdata_diskname_ypos=scrdata_status_height+1+scrdata_yoffset;
  640.  
  641.     /* Fuck knows */
  642.  
  643.     scrdata_scr_height=scrdata_height;
  644.     scrdata_gadget_height=scr_font[FONT_GADGETS]->tf_YSize+2;
  645.  
  646.     FOREVER {
  647.         other_offset=
  648.             (scrdata_diskname_ypos-scrdata_yoffset)+
  649.             scrdata_diskname_height+
  650.             scrdata_string_height+
  651.             config->sliderheight+
  652.             (scr_gadget_rows*scrdata_gadget_height)+
  653.             scrdata_clock_height+9;
  654.  
  655.         scrdata_dispwin_ypos=scrdata_diskname_ypos+scrdata_diskname_height;
  656.  
  657.         scrdata_dispwin_height=scrdata_scr_height-other_offset;/*+scrdata_yoffset;*/
  658.  
  659.         if (((config->arrowsize[0]*2)+8+scrdata_font_ysize)>scrdata_dispwin_height ||
  660.             (other_offset>scrdata_scr_height-(config->sliderheight+32))) {
  661.  
  662.             if (scr_gadget_rows==6) scr_gadget_rows=3;
  663.             else if (scr_gadget_rows>0) --scr_gadget_rows;
  664.             else {
  665.                 ++count;
  666.                 goto tryfonts;
  667.             }
  668.             continue;
  669.         }
  670.         else break;
  671.     }
  672.  
  673.     scrdata_dispwin_lines=scrdata_dispwin_height/scrdata_font_ysize;
  674.     scrdata_dirwin_height=scrdata_dispwin_lines*scrdata_font_ysize;
  675.     scrdata_dirwin_bottom=
  676.         scrdata_yoffset+
  677.         (scrdata_scr_height-
  678.         scrdata_string_height-
  679.         config->sliderheight-
  680.         (scr_gadget_rows*scrdata_gadget_height)-
  681.         scrdata_clock_height-32);
  682.  
  683.     scrdata_gadget_ypos=scrdata_dirwin_bottom+33+scrdata_string_height+config->sliderheight;
  684.  
  685.     scrdata_prop_height=scrdata_dispwin_height-((config->arrowsize[0]+2)*2);
  686.  
  687.     scrdata_gadget_width=scrdata_width/8;
  688.     scrdata_drive_width=0;
  689.     InitRastPort(&testrastport);
  690.     SetFont(&testrastport,scr_font[FONT_GADGETS]);
  691.     for (a=0;a<USEDRIVECOUNT;a++) {
  692.         if ((b=TextLength(&testrastport,config->drive[a].name,
  693.             strlen(config->drive[a].name)))>scrdata_drive_width) scrdata_drive_width=b;
  694.     }
  695.     if (scrdata_drive_width>0) {
  696.         scrdata_drive_width+=4;
  697.         if (scrdata_drive_width<=scrdata_gadget_width)
  698.             scrdata_gadget_width=((scrdata_width-scrdata_drive_width)/7);
  699.         scrdata_drive_width=scrdata_width-(scrdata_gadget_width*7);
  700.     }
  701.     else {
  702.         scrdata_drive_width=0;
  703.         scrdata_gadget_width=scrdata_width/7;
  704.     }
  705.  
  706.     string_extend.Font=scr_font[FONT_STRING];
  707.     if (config->stringfgcol==config->stringbgcol)
  708.         ++config->stringfgcol;
  709.     if (config->stringselfgcol==config->stringselbgcol)
  710.         ++config->stringselfgcol;
  711.     path_stringinfo[0].Extension=&string_extend;
  712.     path_stringinfo[1].Extension=&string_extend;
  713.  
  714.     if (scr_gadget_rows) {
  715.         bank=dopus_firstgadbank;
  716.         for (num=0;bank;num++) bank=bank->next;
  717.         scr_gadget_bank_count=(num*6)/scr_gadget_rows;
  718.     }
  719.     else scr_gadget_bank_count=0;
  720.  
  721.     if (config->generalscreenflags&SCR_GENERAL_GADSLIDERS && scr_gadget_rows) {
  722.         int slider_width=0;
  723.  
  724.         if (scrdata_drive_width) slider_width+=16;
  725.         if (scr_gadget_bank_count>1) slider_width+=16;
  726.  
  727.         scrdata_gadget_width=((scrdata_width-slider_width-scrdata_drive_width)/7);
  728.         a=scrdata_width-((scrdata_gadget_width*7)+scrdata_drive_width);
  729.  
  730.         if (scrdata_drive_width) {
  731.             if (scr_gadget_bank_count>1) {
  732.                 drive_propgad.Width=gadget_propgad.Width=(a/2)-8;
  733.                 if (a%2) ++gadget_propgad.Width;
  734.             }
  735.             else {
  736.                 drive_propgad.Width=a-8;
  737.                 if (drive_propgad.Width>8) {
  738.                     scrdata_drive_width+=drive_propgad.Width-8;
  739.                     drive_propgad.Width=8;
  740.                 }
  741.             }
  742.         }
  743.         else gadget_propgad.Width=a-8;
  744.     }
  745.  
  746.     scrdata_gadget_offset=(scrdata_width-((scrdata_gadget_width*7)+scrdata_drive_width))/2;
  747.     if (config->generalscreenflags&SCR_GENERAL_GADSLIDERS && scr_gadget_rows) {
  748.         if (scr_gadget_bank_count>1) scrdata_gadget_offset-=gadget_propgad.Width+8;
  749.         else if (scrdata_drive_width) scrdata_gadget_offset-=drive_propgad.Width+8;
  750.     }
  751.     if (scrdata_gadget_offset>scrdata_width) scrdata_gadget_offset=0;
  752.  
  753.     scrdata_gadget_offset+=scrdata_xoffset;
  754.     scrdata_gadget_xpos=scrdata_gadget_offset+scrdata_drive_width;
  755.  
  756.     if (config->generalscreenflags&SCR_GENERAL_NEWLOOKPROP && system_version2) {
  757.         status_flags|=STATUS_NEWLOOK;
  758.         for (a=0;a<2;a++) {
  759.             vert_propinfo[a].Flags=AUTOKNOB|PROPNEWLOOK|FREEVERT|PROPBORDERLESS;
  760.             horiz_propinfo[a].Flags=AUTOKNOB|PROPNEWLOOK|FREEHORIZ|PROPBORDERLESS;
  761.         }
  762.         drive_propinfo.Flags|=AUTOKNOB|PROPNEWLOOK|FREEVERT|PROPBORDERLESS;
  763.         gadget_propinfo.Flags|=AUTOKNOB|PROPNEWLOOK|FREEVERT|PROPBORDERLESS;
  764.     }
  765.     else {
  766.         status_flags&=~STATUS_NEWLOOK;
  767.         for (a=0;a<2;a++) {
  768.             vert_propinfo[a].Flags=FREEVERT|PROPBORDERLESS;
  769.             horiz_propinfo[a].Flags=FREEHORIZ|PROPBORDERLESS;
  770.         }
  771.         drive_propinfo.Flags=FREEVERT|PROPBORDERLESS;
  772.         gadget_propinfo.Flags=FREEVERT|PROPBORDERLESS;
  773.     }
  774.  
  775.     if (config->generalscreenflags&SCR_GENERAL_GADSLIDERS && scr_gadget_rows) {
  776.  
  777.         if (scrdata_drive_width>0) {
  778.             scrdata_gadget_xpos+=drive_propgad.Width+8;
  779.  
  780.             drive_propgad.LeftEdge=scrdata_gadget_offset+scrdata_drive_width+4;
  781.             drive_propgad.TopEdge=scrdata_gadget_ypos+1;
  782.             drive_propgad.Height=scr_gadget_rows*scrdata_gadget_height-4;
  783.             drive_propimage.Width=drive_propgad.Width;
  784.             drive_propimage.Height=drive_propgad.Height;
  785.             FixSliderBody(NULL,&drive_propgad,USEDRIVECOUNT,scr_gadget_rows,0);
  786.         }
  787.  
  788.         if (scr_gadget_bank_count>1) {
  789.             gadget_propgad.LeftEdge=scrdata_gadget_xpos+(scrdata_gadget_width*7)+4;
  790.             gadget_propgad.TopEdge=scrdata_gadget_ypos+1;
  791.             gadget_propgad.Height=scr_gadget_rows*scrdata_gadget_height-4;
  792.             gadget_propimage.Width=gadget_propgad.Width;
  793.             gadget_propimage.Height=gadget_propgad.Height;
  794.             FixSliderBody(NULL,&gadget_propgad,scr_gadget_bank_count,1,0);
  795.         }
  796.  
  797.         if (status_flags&STATUS_NEWLOOK) gadget_propimage.Height=0;
  798.     }
  799.  
  800.     if (tit>-1) {
  801.         layoutcenter(config->windowdelta);
  802.  
  803.         if (config->generalscreenflags&SCR_GENERAL_TINYGADS) {
  804.             for (a=0;a<6;a++) {
  805.                 screen_gadgets[SCRGAD_TINYHELP+a].LeftEdge=
  806.                     scrdata_clock_xpos+scrdata_clock_width+(a*19)-1;
  807.                 screen_gadgets[SCRGAD_TINYHELP+a].TopEdge=
  808.                     scrdata_clock_ypos-2;
  809.                 screen_gadgets[SCRGAD_TINYHELP+a].Height=scrdata_clock_height;
  810.             }
  811.             screen_gadgets[SCRGAD_TINYHELP].Flags&=~GFLG_SELECTED;
  812.             screen_gadgets[SCRGAD_TINYAREXX].NextGadget=&screen_gadgets[SCRGAD_TINYHELP];
  813.         }
  814.         else screen_gadgets[SCRGAD_TINYAREXX].NextGadget=&screen_gadgets[SCRGAD_MOVELEFT1];
  815.  
  816.         for (y=0;y<2;y++) {
  817.             fixhlen(y);
  818.             vert_propimage[y].LeftEdge=horiz_propimage[y].LeftEdge=0;
  819.             vert_propimage[y].TopEdge=horiz_propimage[y].TopEdge=0;
  820.             vert_propimage[y].Width=config->sliderwidth;
  821.             vert_propimage[y].Height=0;
  822.             horiz_propimage[y].Height=config->sliderheight;
  823.             vert_propimage[y].ImageData=horiz_propimage[y].ImageData=NULL;
  824.             vert_propimage[y].PlanePick=horiz_propimage[y].PlanePick=0;
  825.             vert_propimage[y].NextImage=horiz_propimage[y].NextImage=NULL;
  826.             FixSliderBody(NULL,&horiz_propgad[y],dopus_curwin[y]->hlen,scrdata_dispwin_nchars[y],0);
  827.         }
  828.  
  829.         if (status_publicscreen) {
  830.             if (MainScreen) {
  831.                 main_win.LeftEdge=config->scr_winx;
  832.                 main_win.TopEdge=config->scr_winy;
  833.             }
  834.             else {
  835.                 main_win.LeftEdge=config->wbwinx;
  836.                 main_win.TopEdge=config->wbwiny;
  837.             }
  838.             if (main_win.LeftEdge+main_win.Width>scrbuf.Width)
  839.                 main_win.LeftEdge=scrbuf.Width-main_win.Width;
  840.             if (main_win.TopEdge+main_win.Height>scrbuf.Height)
  841.                 main_win.TopEdge=scrbuf.Height-main_win.Height;
  842.             if (main_win.LeftEdge<0) main_win.LeftEdge=0;
  843.             if (main_win.TopEdge<0) main_win.TopEdge=0;
  844.             main_win.Flags|=WFLG_ACTIVATE|WFLG_RMBTRAP|WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET;
  845.             main_win.Title=str_arexx_portname;
  846.         }
  847.         else {
  848.             main_win.LeftEdge=0;
  849.             main_win.TopEdge=0;
  850.             main_win.Flags|=WFLG_ACTIVATE|WFLG_BACKDROP|WFLG_RMBTRAP|WFLG_BORDERLESS;
  851.             main_win.Title=NULL;
  852.         }
  853.  
  854.         if (config->generalscreenflags&SCR_GENERAL_NEWLOOKMENU)
  855.             main_win.Flags|=WFLG_NEWLOOKMENUS;
  856.  
  857.         if (!Window) {
  858.             if (!(Window=OpenWindow((struct NewWindow *)&main_win))) {
  859.                 if (MainScreen) ScreenToFront(MainScreen);
  860.                 simplerequest(globstring[STR_UNABLE_TO_OPEN_WINDOW],globstring[STR_CONTINUE],NULL);
  861.                 if (config->screenmode==HIRES_KEY && config->scr_winw==640 &&
  862.                     config->scr_winh==200+(scrdata_is_pal*56) && config->scrdepth==2 &&
  863.                     config->screenflags==0) quit();
  864.                 config->screenmode=HIRES_KEY;
  865.                 config->scr_winw=640;
  866.                 config->scr_winh=200+(scrdata_is_pal*56);
  867.                 config->scrdepth=2;
  868.                 config->screenflags=0;
  869.                 if (MainScreen) CloseScreen(MainScreen);
  870.                 MainScreen=NULL;
  871.                 if (pubscr) UnlockPubScreen(NULL,pubscr);
  872.                 return(SetUp(tit));
  873.             }
  874.             main_win.Width=Window->Width;
  875.             main_win.Height=Window->Height;
  876.             if (pubscr) ScreenToFront(pubscr);
  877.             get_colour_table();
  878.         }
  879.         else {
  880.             RefreshWindowFrame(Window);
  881.             SetAPen(main_rp,0);
  882.             rectfill(main_rp,
  883.                 scrdata_xoffset,
  884.                 scrdata_yoffset,
  885.                 scrdata_width,
  886.                 scrdata_height);
  887.         }
  888.  
  889.         main_rp=Window->RPort;
  890.         main_rp->GelsInfo=&drag_gelsinfo;
  891.         InitGels(&drag_dummy_sprite1,&drag_dummy_sprite2,&drag_gelsinfo);
  892.  
  893.         string_extend.Pens[0]=screen_pens[config->stringfgcol].pen;
  894.         string_extend.Pens[1]=screen_pens[config->stringbgcol].pen;
  895.         string_extend.ActivePens[0]=screen_pens[config->stringselfgcol].pen;
  896.         string_extend.ActivePens[1]=screen_pens[config->stringselbgcol].pen;
  897.  
  898.         drive_propimage.PlaneOnOff=screen_pens[config->slidercol].pen;
  899.         gadget_propimage.PlaneOnOff=screen_pens[config->slidercol].pen;
  900.         drive_propgad.MutualExclude=screen_pens[config->sliderbgcol].pen;
  901.         gadget_propgad.MutualExclude=screen_pens[config->sliderbgcol].pen;
  902.  
  903.         for (y=0;y<2;y++) {
  904.             vert_propimage[y].PlaneOnOff=screen_pens[config->slidercol].pen;
  905.             horiz_propimage[y].PlaneOnOff=screen_pens[config->slidercol].pen;
  906.             vert_propimage[y].NextImage=horiz_propimage[y].NextImage=NULL;
  907.             vert_propgad[y].MutualExclude=screen_pens[config->sliderbgcol].pen;
  908.             horiz_propgad[y].MutualExclude=screen_pens[config->sliderbgcol].pen;
  909.         }
  910.  
  911.         if (status_publicscreen) {
  912.             if (WorkbenchBase && !dopus_appwindow)
  913.                 dopus_appwindow=AddAppWindowA(APPWINID,0,Window,appmsg_port,NULL);
  914.  
  915.             SetWindowTitles(Window,(char *)-1,str_arexx_portname);
  916.             screen_gadgets[SCRGAD_LEFTPARENT].Width=Window->BorderLeft+2;
  917.             screen_gadgets[SCRGAD_RIGHTPARENT].Width=Window->BorderRight+2;
  918.  
  919.             size_gadgets[0].LeftEdge=Window->Width-Window->BorderRight-1;
  920.             size_gadgets[0].TopEdge=Window->Height-16;
  921.             size_gadgets[0].Width=Window->BorderRight+1;
  922.             size_gadgets[0].Height=17;
  923.  
  924.             size_gadgets[1].LeftEdge=Window->Width-32;
  925.             size_gadgets[1].TopEdge=Window->Height-Window->BorderBottom-1;
  926.             size_gadgets[1].Width=33;
  927.             size_gadgets[1].Height=Window->BorderBottom+1;
  928.         }
  929.         else {
  930.             screen_gadgets[SCRGAD_LEFTPARENT].Width=2;
  931.             screen_gadgets[SCRGAD_RIGHTPARENT].Width=2;
  932.         }
  933.  
  934.         if (Window->WScreen->ViewPort.Modes&LACE) status_flags|=STATUS_SQUAREPIXEL;
  935.         else status_flags&=~STATUS_SQUAREPIXEL;
  936.  
  937.         if (config->generalflags&GENERAL_DRAG) allocdragbuffers();
  938.  
  939.         b=(scrdata_dispwin_height-scrdata_dirwin_height)/2;
  940.         if (b<0) b=0;
  941.  
  942.         if (scrdata_dispwin_lines<5) c=scrdata_font_ysize/2;
  943.         else if (scrdata_dispwin_lines<9) c=scrdata_font_ysize*2;
  944.         else c=scrdata_font_ysize*3;
  945.  
  946.         for (a=0;a<2;a++) {
  947.             scrdata_dirwin_ypos[a]=scrdata_dispwin_ypos+b;
  948.             CopyMem((char *)main_rp,(char *)&dir_rp[a],sizeof(struct RastPort));
  949.             SetFont(&dir_rp[a],scr_font[FONT_DIRS]);
  950.             SetDrMd(&dir_rp[a],JAM2);
  951.  
  952.             scr_scroll_borders[a].MinX=
  953.                 scrdata_dirwin_xpos[a]+(((scrdata_dispwin_nchars[a]/2)-6)*scrdata_font_xsize);
  954.             scr_scroll_borders[a].MaxX=
  955.                 scrdata_dirwin_xpos[a]+(((scrdata_dispwin_nchars[a]/2)+6)*scrdata_font_xsize);
  956.             scr_scroll_borders[a].MinY=
  957.                 scrdata_dirwin_ypos[a]+(((scrdata_dispwin_lines/2)*scrdata_font_ysize)-c);
  958.             scr_scroll_borders[a].MaxY=
  959.                 scrdata_dirwin_ypos[a]+(((scrdata_dispwin_lines/2)*scrdata_font_ysize)+c);
  960.         }
  961.  
  962.         if (scrdata_status_height>0) scrdata_status_width=scrdata_width-4;
  963.         else {
  964.             struct Gadget *gad;
  965.             int min=0,max=0;
  966.  
  967.             if (status_publicscreen) {
  968.                 gad=Window->FirstGadget;
  969.  
  970.                 while (gad) {
  971.                     if (gad->GadgetType>YP_SYSGADGET && gad->TopEdge==0) {
  972.                         if (gad->LeftEdge<0) {
  973.                             if (gad->LeftEdge<min) min=gad->LeftEdge;
  974.                         }
  975.                         else if (gad->LeftEdge+gad->Width>max) max=gad->LeftEdge+gad->Width;
  976.                     }
  977.                     gad=gad->NextGadget;
  978.                 }
  979.  
  980.                 scrdata_status_width=Window->Width-max+min-8-Window->WScreen->BarHBorder;
  981.             }
  982.             else {
  983.                 gad=MainScreen->FirstGadget;
  984.  
  985.                 while (gad) {
  986.                     if (gad->LeftEdge<min) min=gad->LeftEdge;
  987.                     gad=gad->NextGadget;
  988.                 }
  989.  
  990.                 scrdata_status_width=MainScreen->Width+min-8-MainScreen->BarHBorder;
  991.             }
  992.         }
  993.  
  994.         scrdata_status_xpos=2+scrdata_xoffset;
  995.         scrdata_status_ypos=1+scrdata_yoffset;
  996.  
  997.         if (MainScreen) ScreenToFront(MainScreen);
  998.         if (config->errorflags&ERROR_ENABLE_DOS)
  999.             main_proc->pr_WindowPtr=(APTR)Window;
  1000.         else
  1001.             main_proc->pr_WindowPtr=(APTR)-1;
  1002.  
  1003.         layout_menus();
  1004.  
  1005.         setupdisplay(1);
  1006.  
  1007.         initclock();
  1008.     }
  1009.  
  1010.     status_iconified=0;
  1011.     if (tit==1) dostatustext(globstring[STR_WELCOME_TO_DOPUS]);
  1012.     else if (tit==2) dostatustext(globstring[STR_WELCOME_BACK_TO_DOPUS]);
  1013.     if (tit>-1 && !(status_flags&STATUS_DONEREXX)) {
  1014.         status_flags|=STATUS_DONEREXX;
  1015.         rexx_command(config->startupscript,NULL);
  1016.     }
  1017.     status_configuring=0;
  1018.  
  1019.     if (pubscr) UnlockPubScreen(NULL,pubscr);
  1020.     return(1);
  1021. }
  1022.  
  1023. void setupdisplay(all)
  1024. int all;
  1025. {
  1026.     int a;
  1027.  
  1028.     drawscreen();
  1029.     for (a=0;a<2;a++) {
  1030.         if (config->generalscreenflags&SCR_GENERAL_NEWLOOKPROP && system_version2)
  1031.             RefreshGList(horiz_propgad,Window,NULL,2);
  1032.         fixhorizprop(a);
  1033.         if (!all) doposhprop(a);
  1034.     }
  1035.     setupgadgets();
  1036.     drawgadgets((all)?1:-1,0);
  1037.     fix_rmb_gadgets();
  1038.     if (config->generalscreenflags&SCR_GENERAL_TINYGADS)
  1039.         dolittlegads(&screen_gadgets[SCRGAD_TINYFILTER],&globstring[STR_TINY_BUTTONS][6],1);
  1040.  
  1041.     if (scr_gadget_rows) {
  1042.         if (config->generalscreenflags&SCR_GENERAL_GADSLIDERS) {
  1043.             if (scrdata_drive_width) {
  1044.                 FixSliderPot(NULL,&drive_propgad,data_drive_offset,
  1045.                     USEDRIVECOUNT,scr_gadget_rows,0);
  1046.                 ShowSlider(Window,&drive_propgad);
  1047.             }
  1048.             if (scr_gadget_bank_count>1) {
  1049.                 fixgadgetprop();
  1050.                 ShowSlider(Window,&gadget_propgad);
  1051.             }
  1052.         }
  1053.         data_drive_offset-=scr_gadget_rows;
  1054.         nextdrives();
  1055.     }
  1056.  
  1057.     for (a=0;a<2;a++) {
  1058.         refreshwindow(a,3);
  1059.         doposprop(a);
  1060.     }
  1061. }
  1062.  
  1063. void drawscreen()
  1064. {
  1065.     int a;
  1066.  
  1067.     SetDrMd(main_rp,JAM1);
  1068.  
  1069.     dolittlegads(&screen_gadgets[SCRGAD_TINYBUFFERLIST],globstring[STR_TINY_BUTTONS],
  1070.         config->generalscreenflags&SCR_GENERAL_TINYGADS?10:4);
  1071.  
  1072.     /* Directory Windows */
  1073.  
  1074.     for (a=0;a<2;a++) {
  1075.         SetAPen(main_rp,screen_pens[config->filesbg].pen);
  1076.         rectfill(main_rp,
  1077.             scrdata_dispwin_xpos[a]+2,
  1078.             scrdata_dispwin_ypos,
  1079.             scrdata_dispwin_width[a],
  1080.             scrdata_dispwin_height);
  1081.         do3dbox(main_rp,
  1082.             scrdata_dispwin_xpos[a]+2,
  1083.             scrdata_dispwin_ypos,
  1084.             scrdata_dispwin_width[a],
  1085.             scrdata_dispwin_height);
  1086.         do3dbox(main_rp,
  1087.             scrdata_diskname_xpos[a]+2,
  1088.             scrdata_diskname_ypos,
  1089.             scrdata_diskname_width[a],
  1090.             scrdata_diskname_height-2);
  1091.     }
  1092.  
  1093.     /* Sliders/String gadgets */
  1094.  
  1095.     for (a=0;a<2;a++) {
  1096.         do3dbox(main_rp,
  1097.             vert_propgad[a].LeftEdge-2,
  1098.             vert_propgad[a].TopEdge-1,
  1099.             config->sliderwidth+4,
  1100.             scrdata_prop_height+2);
  1101.         do3dbox(main_rp,
  1102.             horiz_propgad[a].LeftEdge-2,
  1103.             horiz_propgad[a].TopEdge-1,
  1104.             horiz_propgad[a].Width+4,
  1105.             config->sliderheight+2);
  1106.         Do3DStringBox(main_rp,
  1107.             path_strgadget[a].LeftEdge,
  1108.             path_strgadget[a].TopEdge,
  1109.             path_strgadget[a].Width,
  1110.             scrdata_string_height,
  1111.             screen_pens[config->gadgettopcol].pen,
  1112.             screen_pens[config->gadgetbotcol].pen);
  1113.     }
  1114.  
  1115.     /* Arrows */
  1116.  
  1117.     doarrowgadgets(&screen_gadgets[SCRGAD_MOVEUP1],0);
  1118.     doarrowgadgets(&screen_gadgets[SCRGAD_MOVEDOWN1],1);
  1119.     doarrowgadgets(&screen_gadgets[SCRGAD_MOVELEFT1],3);
  1120.     doarrowgadgets(&screen_gadgets[SCRGAD_MOVERIGHT1],2);
  1121.     doarrowgadgets(&screen_gadgets[SCRGAD_BUFFERLEFT1],3);
  1122.     doarrowgadgets(&screen_gadgets[SCRGAD_BUFFERRIGHT1],2);
  1123.  
  1124.     /* Status bar */
  1125.  
  1126.     if (scrdata_status_height>0) {
  1127.         do3dbox(main_rp,
  1128.             scrdata_status_xpos,
  1129.             scrdata_status_ypos,
  1130.             scrdata_status_width,
  1131.             scrdata_status_height-2);
  1132.         SetAPen(main_rp,screen_pens[config->statusbg].pen);
  1133.         rectfill(main_rp,
  1134.             scrdata_status_xpos,
  1135.             scrdata_status_ypos,
  1136.             scrdata_status_width,
  1137.             scrdata_status_height-2);
  1138.     }
  1139.  
  1140.     /* Clock bar */
  1141.  
  1142.     if (!clock_task) {
  1143.         SetAPen(main_rp,screen_pens[config->clockbg].pen);
  1144.         rectfill(main_rp,
  1145.             scrdata_clock_xpos,
  1146.             scrdata_clock_ypos,
  1147.             scrdata_clock_width-3,
  1148.             scrdata_clock_height-2);
  1149.         do3dbox(main_rp,
  1150.             scrdata_clock_xpos,
  1151.             scrdata_clock_ypos-1,
  1152.             scrdata_clock_width-3,
  1153.             scrdata_clock_height-2);
  1154.     }
  1155.  
  1156.     doactive(0,0);
  1157.  
  1158.     SetAPen(main_rp,screen_pens[1].pen);
  1159. }
  1160.  
  1161. struct TextFont *getfont(font,size,noprop)
  1162. char *font;
  1163. int *size,noprop;
  1164. {
  1165.     BPTR lock;
  1166.     struct TextFont *tf;
  1167.     static struct TextAttr sfont={NULL,0,0,0};
  1168.  
  1169.     sfont.ta_Name=(STRPTR)font; sfont.ta_YSize=*size;
  1170.     if ((tf=OpenFont(&sfont)) && tf->tf_YSize==sfont.ta_YSize &&
  1171.         (!(tf->tf_Flags&FPF_PROPORTIONAL) || !noprop)) return(tf);
  1172.     if (tf) CloseFont(tf);
  1173.     main_proc->pr_WindowPtr=(APTR)-1;
  1174.     if (!(lock=Lock("FONTS:",ACCESS_READ))) {
  1175.         if (config->errorflags&ERROR_ENABLE_DOS) main_proc->pr_WindowPtr=(APTR)Window;
  1176.         strcpy(font,"topaz.font");
  1177.         *size=8;
  1178.         sfont.ta_YSize=8;
  1179.         tf=OpenFont(&sfont);
  1180.     }
  1181.     else {
  1182.         UnLock(lock);
  1183.         if (!DiskfontBase || !(tf=OpenDiskFont(&sfont))) {
  1184.             if ((tf=OpenFont(&sfont))) *size=tf->tf_YSize;
  1185.         }
  1186.         if (!tf || (tf->tf_Flags&FPF_PROPORTIONAL && noprop)) {
  1187.             if (tf) CloseFont(tf);
  1188.             strcpy(font,"topaz.font");
  1189.             *size=8;
  1190.             sfont.ta_YSize=8;
  1191.             tf=OpenFont(&sfont);
  1192.         }
  1193.     }
  1194.     if (config->errorflags&ERROR_ENABLE_DOS) main_proc->pr_WindowPtr=(APTR)Window;
  1195.     return(tf);
  1196. }
  1197.  
  1198. void allocstrings()
  1199. {
  1200.     int a;
  1201.  
  1202.     for (a=0;a<16;a++) rexx_args[a]=astring(256);
  1203.     str_arexx_command=astring(256);
  1204.     for (a=0;a<3;a++) str_select_pattern[a]=astring(80);
  1205.     for (a=0;a<2;a++) {
  1206.         rexx_pathbuffer[a]=astring(256);
  1207.         dopus_specialwin[a]=(struct DirectoryWindow *)astring(sizeof(struct DirectoryWindow));
  1208.     }
  1209.     menu_menuitem=(struct MenuItem *)astring(MENUCOUNT*sizeof(struct MenuItem));
  1210.     menu_itemnames=astring(MENUCOUNT*MAXMENULENGTH);
  1211.     menu_intuitext=(struct IntuiText *)astring(MENUCOUNT*2*sizeof(struct IntuiText));
  1212.     main_gadgets=(struct Gadget *)astring((GADCOUNT/2)*sizeof(struct Gadget));
  1213.     drive_gadgets=(struct Gadget *)astring(6*sizeof(struct Gadget));
  1214.     str_space_string=astring(MAXDISPLAYLENGTH);
  1215.     for (a=0;a<MAXDISPLAYLENGTH-1;a++) str_space_string[a]=' ';
  1216.     str_last_statustext=astring(512);
  1217.     remember_data=(struct RememberData *)astring(sizeof(struct RememberData));
  1218. }
  1219.  
  1220. char *astring(len)
  1221. int len;
  1222. {
  1223.     char *foo;
  1224.  
  1225.     if (!(foo=LAllocRemember(&general_key,len,MEMF_CLEAR))) quit();
  1226.     return(foo);
  1227. }
  1228.  
  1229. void allocdragbuffers()
  1230. {
  1231.     int a,w;
  1232.  
  1233.     freedragbuffers();
  1234.     drag_sprite.Depth=Window->WScreen->RastPort.BitMap->Depth;
  1235.  
  1236.     a=35;
  1237.     w=(gettextlength(scr_font[FONT_DIRS],str_space_string,&a,0)+15);
  1238.     a=(scrdata_dispwin_width[0]>scrdata_dispwin_width[1])?scrdata_dispwin_width[0]:scrdata_dispwin_width[1];
  1239.     if (w>a) w=a;
  1240.     drag_sprite.Width=w/16;
  1241.     drag_sprite.Height=scr_font[FONT_DIRS]->tf_YSize;
  1242.  
  1243.     if (!(drag_bob_buffer=AllocRaster(drag_sprite.Width*16,drag_sprite.Height*drag_sprite.Depth)))
  1244.         return;
  1245.     if (!(drag_bob_savebuffer=AllocRaster(drag_sprite.Width*16,drag_sprite.Height*drag_sprite.Depth))) {
  1246.         freedragbuffers();
  1247.         return;
  1248.     }
  1249.  
  1250.     InitBitMap(&drag_bob_bitmap,drag_sprite.Depth,drag_sprite.Width*16,drag_sprite.Height);
  1251.     for (a=0;a<drag_sprite.Depth;a++) {
  1252.         drag_bob_bitmap.Planes[a]=
  1253.             drag_bob_buffer+(RASSIZE(drag_sprite.Width*16,drag_sprite.Height)*a);
  1254.     }
  1255.     for (;a<8;a++) drag_bob_bitmap.Planes[a]=NULL;
  1256.  
  1257.     InitRastPort(&drag_bob_rastport);
  1258.     drag_bob_rastport.BitMap=&drag_bob_bitmap;
  1259.     SetFont(&drag_bob_rastport,scr_font[FONT_DIRS]);
  1260.     SetDrMd(&drag_bob_rastport,JAM1);
  1261.     drag_sprite.ImageData=(WORD *)drag_bob_buffer;
  1262.     drag_sprite.PlanePick=(1<<drag_sprite.Depth)-1;
  1263.     drag_bob.SaveBuffer=(WORD *)drag_bob_savebuffer;
  1264. }
  1265.  
  1266. void freedragbuffers()
  1267. {
  1268.     if (drag_bob_buffer)
  1269.         FreeRaster(drag_bob_buffer,drag_sprite.Width*16,drag_sprite.Height*drag_sprite.Depth);
  1270.     if (drag_bob_savebuffer)
  1271.         FreeRaster(drag_bob_savebuffer,drag_sprite.Width*16,drag_sprite.Height*drag_sprite.Depth);
  1272.     drag_bob_buffer=drag_bob_savebuffer=NULL;
  1273. }
  1274.  
  1275. void load_palette(screen,palette)
  1276. struct Screen *screen;
  1277. ULONG *palette;
  1278. {
  1279.     int numcols;
  1280.  
  1281.     numcols=1<<screen->RastPort.BitMap->Depth;
  1282.     if (numcols>32) numcols=32;
  1283.  
  1284.     if (system_version2>=OSVER_39) {
  1285.         ULONG backup_palette[98];
  1286.  
  1287.         CopyMem((char *)palette,(char *)&backup_palette[1],numcols*3*sizeof(ULONG));
  1288.         backup_palette[0]=numcols<<16;
  1289.         backup_palette[(numcols*3)+1]=0;
  1290.  
  1291.         LoadRGB32(&screen->ViewPort,backup_palette);
  1292.     }
  1293.     else {
  1294.         UWORD backup_palette[32];
  1295.         int a,b;
  1296.  
  1297.         for (a=0,b=0;a<numcols*3;b++) {
  1298.             backup_palette[b]=0;
  1299.             backup_palette[b]|=(palette[a++]&0xf0000000)>>20;
  1300.             backup_palette[b]|=(palette[a++]&0xf0000000)>>24;
  1301.             backup_palette[b]|=(palette[a++]&0xf0000000)>>28;
  1302.         }
  1303.  
  1304.         LoadRGB4(&screen->ViewPort,backup_palette,numcols);
  1305.     }
  1306. }
  1307.  
  1308. void get_palette(screen,palette)
  1309. struct Screen *screen;
  1310. ULONG *palette;
  1311. {
  1312.     int numcols;
  1313.  
  1314.     numcols=1<<screen->RastPort.BitMap->Depth;
  1315.  
  1316.     if (system_version2>=OSVER_39) {
  1317.         GetRGB32(screen->ViewPort.ColorMap,0,numcols,palette);
  1318.     }
  1319.     else {
  1320.         int a,b;
  1321.         ULONG colour;
  1322.  
  1323.         for (a=0,b=0;a<numcols;a++) {
  1324.             colour=GetRGB4(screen->ViewPort.ColorMap,a);
  1325.             palette[b++]=(((colour>>8)&0xf)<<28)|0x0fffffff;
  1326.             palette[b++]=(((colour>>4)&0xf)<<28)|0x0fffffff;
  1327.             palette[b++]=((colour&0xf)<<28)|0x0fffffff;
  1328.         }
  1329.     }
  1330. }
  1331.  
  1332. struct Library *open_dopus_library(name,ver)
  1333. char *name;
  1334. int ver;
  1335. {
  1336.     char buf[80];
  1337.     struct Library *lib;
  1338.  
  1339.     if (lib=OpenLibrary(name,ver)) return(lib);
  1340.     FindSystemFile(name,buf,80,SYSFILE_LIBRARY);
  1341.     return(OpenLibrary(buf,ver));
  1342. }
  1343.  
  1344. void read_configuration(def)
  1345. int def;
  1346. {
  1347.     char buf[256];
  1348.  
  1349.     freedynamiccfg();
  1350.     get_config_file(buf,".CFG");
  1351.     if (def || !(readsetup(buf))) getdefaultconfig();
  1352.  
  1353.     read_data_files(1);
  1354. }
  1355.  
  1356. void read_data_files(fb)
  1357. int fb;
  1358. {
  1359.     char buf[256];
  1360.  
  1361.     if (get_data_file(buf,"HLP",fb))
  1362.         readhelp(buf);
  1363.  
  1364.     get_data_file(buf,"STR",fb);
  1365.     readstrings(buf);
  1366. }
  1367.  
  1368. get_data_file(buf,suff,fb)
  1369. char *buf,*suff;
  1370. int fb;
  1371. {
  1372.     char temp[40];
  1373.  
  1374.     lsprintf(temp,"DO_%s.%s",config->language,suff);
  1375.     if (!config->language[0] || !(FindSystemFile(temp,buf,256,SYSFILE_DATA))) {
  1376.         if (!fb) {
  1377.             buf[0]=0;
  1378.             return(0);
  1379.         }
  1380.         lsprintf(temp,"DirectoryOpus.%s",suff);
  1381.         FindSystemFile(temp,buf,256,SYSFILE_DATA);
  1382.     }
  1383.     return(1);
  1384. }
  1385.  
  1386. void get_config_file(buf,suff)
  1387. char *buf,*suff;
  1388. {
  1389.     char temp[256];
  1390.  
  1391.     StrCombine(temp,str_config_basename,suff,256);
  1392.     if (CheckExist(temp,NULL)<0) {
  1393.         strcpy(buf,temp);
  1394.         return;
  1395.     }
  1396.     if (BaseName(str_config_basename))
  1397.         StrCombine(temp,BaseName(str_config_basename),suff,256);
  1398.     if (!(FindSystemFile(temp,buf,256,SYSFILE_DATA))) {
  1399.         StrCombine(temp,"DirectoryOpus",suff,256);
  1400.         if (!(FindSystemFile(temp,buf,256,SYSFILE_DATA))) {
  1401.             if (CheckExist("DOpus:S",NULL)) StrCombine(buf,"DOpus:S/DirectoryOpus",suff,256);
  1402.             else StrCombine(buf,"S:DirectoryOpus",suff,256);
  1403.         }
  1404.     }
  1405. }
  1406.  
  1407. void setup_draw_info()
  1408. {
  1409.     int a,b;
  1410.     struct DrawInfo *drinfo;
  1411.     struct Screen *wbscreen;
  1412.  
  1413.     if (system_version2) {
  1414.         mainscreen_tags[SCREENTAGS_DISPLAYID].ti_Data=0;
  1415.         if (wbscreen=LockPubScreen("Workbench")) {
  1416.             drinfo=GetScreenDrawInfo(wbscreen);
  1417.             b=drinfo->dri_NumPens;
  1418.             if (b>NUMDRIPENS) b=NUMDRIPENS;
  1419.             for (a=0;a<b;a++) scr_drawinfo[a]=drinfo->dri_Pens[a];
  1420.             FreeScreenDrawInfo(wbscreen,drinfo);
  1421.             UnlockPubScreen(NULL,wbscreen);
  1422.         }
  1423.     }
  1424.     else for (a=0;a<NUMDRIPENS;a++) scr_drawinfo[a]=(USHORT)~0;
  1425.  
  1426.     scr_drawinfo[SHINEPEN]=config->gadgettopcol;
  1427.     scr_drawinfo[SHADOWPEN]=config->gadgetbotcol;
  1428.     scr_drawinfo[NUMDRIPENS]=(USHORT)~0;
  1429. }
  1430.