home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 3 / CD_Magazyn_EXEC_nr_3.iso / Internet / Strony_WWW / Opus4.x / DOpus414JRsrc.lha / DirectoryOpus4 / Program / main21.c < prev    next >
C/C++ Source or Header  |  2000-03-21  |  26KB  |  756 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. void fixdrivegadgets()
  34. {
  35.     int i,b,l,len,ty;
  36.  
  37.     if (!scrdata_drive_width || !scr_gadget_rows) return;
  38.     SetFont(main_rp,scr_font[FONT_GADGETS]);
  39.  
  40.     ty=scrdata_gadget_ypos+scr_font[FONT_GADGETS]->tf_Baseline+
  41.         ((scrdata_gadget_height-2-scr_font[FONT_GADGETS]->tf_YSize)/2);
  42.  
  43.     for (i=0;i<scr_gadget_rows;i++) {
  44.         b=i+data_drive_offset;
  45.         SetAPen(main_rp,screen_pens[config->drive[b].bpen].pen);
  46.         rectfill(main_rp,
  47.             scrdata_gadget_offset+2,
  48.             (i*scrdata_gadget_height)+scrdata_gadget_ypos,
  49.             scrdata_drive_width-4,
  50.             scrdata_gadget_height-2);
  51.         SetAPen(main_rp,screen_pens[config->drive[b].fpen].pen);
  52.         SetBPen(main_rp,screen_pens[config->drive[b].bpen].pen);
  53.         if (config->drive[b].name && config->drive[b].name[0]) {
  54.             len=0;
  55.             l=dotextlength(main_rp,config->drive[b].name,&len,scrdata_drive_width-4);
  56.             Move(main_rp,scrdata_gadget_offset+((scrdata_drive_width-l)/2),(i*scrdata_gadget_height)+ty);
  57.             Text(main_rp,config->drive[b].name,len);
  58.         }
  59.         drive_gadgets[i].Flags=
  60.             (config->drive[b].name && config->drive[b].name[0] &&
  61.             config->drive[b].function && config->drive[b].function[0])?
  62.                 ((drive_unsel_border)?GFLG_GADGHIMAGE:GFLG_GADGHCOMP):GFLG_GADGHNONE;
  63.     }
  64.     SetFont(main_rp,scr_font[FONT_GENERAL]);
  65. }
  66.  
  67. void nextdrives()
  68. {
  69.     int old,a,b;
  70.  
  71.     if (scrdata_drive_width && scr_gadget_rows) {
  72.         old=data_drive_offset;
  73.         FOREVER {
  74.             if (data_drive_offset%scr_gadget_rows)
  75.                 data_drive_offset+=scr_gadget_rows-(data_drive_offset%scr_gadget_rows);
  76.             else data_drive_offset+=scr_gadget_rows;
  77.             if (data_drive_offset>=USEDRIVECOUNT || data_drive_offset<0)
  78.                 data_drive_offset=0;
  79.             a=data_drive_offset+scr_gadget_rows;
  80.             for (b=data_drive_offset;b<a;b++)
  81.                 if (config->drive[b].name[0] && config->drive[b].function &&
  82.                     config->drive[b].function[0]) break;
  83.             if (b<a || data_drive_offset==old) break;
  84.         }
  85.         if (config->generalscreenflags&SCR_GENERAL_GADSLIDERS) {
  86.             FixSliderPot(Window,&drive_propgad,data_drive_offset,
  87.                 USEDRIVECOUNT,scr_gadget_rows,!status_iconified);
  88.         }
  89.         if (!status_iconified) fixdrivegadgets();
  90.     }
  91. }
  92.  
  93. void setupgadgets()
  94. {
  95.     int a;
  96.  
  97.     AddGList(Window,&path_strgadget[0],-1,2,NULL);
  98.     AddGList(Window,&vert_propgad[0],-1,2,NULL);
  99.     AddGList(Window,&horiz_propgad[0],-1,2,NULL);
  100.     AddGList(Window,screen_gadgets,-1,(config->generalscreenflags&SCR_GENERAL_TINYGADS)?24:18,NULL);
  101.     if (status_publicscreen) AddGList(Window,size_gadgets,-1,2,NULL);
  102.     RefreshGList(&path_strgadget[0],Window,NULL,2);
  103.     for (a=0;a<2;a++) {
  104.         ShowSlider(Window,&vert_propgad[a]);
  105.         ShowSlider(Window,&horiz_propgad[a]);
  106.     }
  107.     if (config->generalscreenflags&SCR_GENERAL_GADSLIDERS && scr_gadget_rows) {
  108.         if (scrdata_drive_width>0) {
  109.             AddGadgets(Window,
  110.                 &drive_propgad,
  111.                 NULL,
  112.                 1,
  113.                 screen_pens[config->gadgettopcol].pen,
  114.                 screen_pens[config->gadgetbotcol].pen,1);
  115.         }
  116.         if (scr_gadget_bank_count>1) {
  117.             AddGadgets(Window,
  118.                 &gadget_propgad,
  119.                 NULL,
  120.                 1,
  121.                 screen_pens[config->gadgettopcol].pen,
  122.                 screen_pens[config->gadgetbotcol].pen,1);
  123.         }
  124.     }
  125. }
  126.  
  127. void allocate_borders()
  128. {
  129.     int a,b;
  130.  
  131.     LFreeRemember(&border_key);
  132.  
  133.     CreateGadgetBorders(&border_key,
  134.         scrdata_gadget_width,scrdata_gadget_height,
  135.         &gadget_sel_border,&gadget_unsel_border,
  136.         0,
  137.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  138.  
  139.     if (config->generalscreenflags&SCR_GENERAL_INDICATERMB)
  140.         CreateGadgetBorders(&border_key,
  141.             scrdata_gadget_width,scrdata_gadget_height,
  142.             &gadget_dog_sel_border,&gadget_dog_unsel_border,
  143.             1,
  144.             screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  145.  
  146.     if (scrdata_drive_width && scr_gadget_rows) {
  147.         CreateGadgetBorders(&border_key,
  148.             scrdata_drive_width,scrdata_gadget_height,
  149.             &drive_sel_border,&drive_unsel_border,
  150.             0,
  151.             screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  152.  
  153.         if ((drive_bank_sel_border=
  154.             LAllocRemember(&border_key,sizeof(struct Border)*2*scr_gadget_rows,0)) &&
  155.             (drive_bank_unsel_border=
  156.             LAllocRemember(&border_key,sizeof(struct Border)*2*scr_gadget_rows,0))) {
  157.             for (a=0;a<scr_gadget_rows;a++) {
  158.                 b=a*2;
  159.                 CopyMem((char *)drive_sel_border,(char *)&drive_bank_sel_border[b],
  160.                     sizeof(struct Border)*2);
  161.                 CopyMem((char *)drive_unsel_border,(char *)&drive_bank_unsel_border[b],
  162.                     sizeof(struct Border)*2);
  163.                 drive_bank_sel_border[b].NextBorder=&drive_bank_sel_border[b+1];
  164.                 drive_bank_sel_border[b+1].NextBorder=(a<scr_gadget_rows-1)?
  165.                     &drive_bank_sel_border[b+2]:NULL;
  166.                 drive_bank_unsel_border[b].NextBorder=&drive_bank_unsel_border[b+1];
  167.                 drive_bank_unsel_border[b+1].NextBorder=(a<scr_gadget_rows-1)?
  168.                     &drive_bank_unsel_border[b+2]:NULL;
  169.                 drive_bank_sel_border[b].TopEdge=a*scrdata_gadget_height;
  170.                 drive_bank_sel_border[b+1].TopEdge=a*scrdata_gadget_height;
  171.                 drive_bank_unsel_border[b].TopEdge=a*scrdata_gadget_height;
  172.                 drive_bank_unsel_border[b+1].TopEdge=a*scrdata_gadget_height;
  173.             }
  174.         }
  175.     }
  176.     else {
  177.         drive_sel_border=NULL;
  178.         drive_unsel_border=NULL;
  179.         drive_bank_sel_border=NULL;
  180.         drive_bank_unsel_border=NULL;
  181.     }
  182.  
  183.     AddGadgetBorders(&border_key,
  184.         &screen_gadgets[SCRGAD_TINYBUFFERLIST],2,
  185.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  186.  
  187.     AddGadgetBorders(&border_key,
  188.         &screen_gadgets[SCRGAD_TINYSELECT],2,
  189.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  190.  
  191.     if (config->generalscreenflags&SCR_GENERAL_TINYGADS)
  192.         AddGadgetBorders(&border_key,
  193.             &screen_gadgets[SCRGAD_TINYHELP],6,
  194.             screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  195.  
  196.     AddGadgetBorders(&border_key,
  197.         &screen_gadgets[SCRGAD_MOVELEFT1],4,
  198.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  199.  
  200.     AddGadgetBorders(&border_key,
  201.         &screen_gadgets[SCRGAD_MOVEUP1],4,
  202.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  203.  
  204.     AddGadgetBorders(&border_key,
  205.         &screen_gadgets[SCRGAD_BUFFERLEFT1],4,
  206.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  207. }
  208.  
  209. void drawgadgets(addgads,bankoffset)
  210. int addgads,bankoffset;
  211. {
  212.     int x,y,yoff,a,b,len,l,ty,num,uspos,x1,y1;
  213.     char buf[256];
  214.  
  215. #ifdef DEBUG
  216. KPrintF("pageflip_data1 %lx, pageflip_data2 at %lx\n",pageflip_data1,pageflip_data2);
  217. #endif
  218.     if (addgads) allocate_borders();
  219.  
  220.     if (!scr_gadget_rows) return;
  221.     if (status_iconified>0) yoff=Window->BorderTop+1;
  222.     else {
  223.         yoff=scrdata_gadget_ypos;
  224.         SetFont(main_rp,scr_font[FONT_GADGETS]);
  225.     }
  226.  
  227.     if (addgads!=-1) {
  228.         if (scrdata_drive_width) {
  229.             for (y=0;y<scr_gadget_rows;y++)
  230.                 do3dbox(main_rp,
  231.                     scrdata_gadget_offset+2,(y*scrdata_gadget_height)+yoff,
  232.                     scrdata_drive_width-4,scrdata_gadget_height-2);
  233.         }
  234.  
  235.         for (x=0;x<7;x++) {
  236.             for (y=0;y<scr_gadget_rows;y++) {
  237.                 do3dbox(main_rp,
  238.                     (x*scrdata_gadget_width)+scrdata_gadget_xpos+2,(y*scrdata_gadget_height)+yoff,
  239.                     scrdata_gadget_width-4,scrdata_gadget_height-2);
  240.             }
  241.         }
  242.     }
  243.  
  244.     if (status_iconified>0) ty=Window->BorderTop+main_rp->Font->tf_Baseline+1;
  245.     else ty=yoff+scr_font[FONT_GADGETS]->tf_Baseline+((scrdata_gadget_height-2-scr_font[FONT_GADGETS]->tf_YSize)/2);
  246.  
  247.     num=0;
  248.     if (addgads!=-1) {
  249.         for (y=0;y<scr_gadget_rows;y++) {
  250.             a=((data_gadgetrow_offset+y)*7)+bankoffset;
  251.             for (x=0;x<7;x++,a++) {
  252.                 main_gadgets[num].Flags=GFLG_GADGHNONE;
  253.                 if (dopus_curgadbank) {
  254.                     SetAPen(main_rp,screen_pens[dopus_curgadbank->gadgets[a].bpen].pen);
  255.                     rectfill(main_rp,
  256.                         (x1=((x*scrdata_gadget_width)+scrdata_gadget_xpos+2)),
  257.                         (y1=((y*scrdata_gadget_height)+yoff)),
  258.                         scrdata_gadget_width-4,
  259.                         scrdata_gadget_height-2);
  260.                     if (dopus_curgadbank->gadgets[a].name &&
  261.                         dopus_curgadbank->gadgets[a].name[0]) {
  262.                         SetAPen(main_rp,screen_pens[dopus_curgadbank->gadgets[a].fpen].pen);
  263.                         SetBPen(main_rp,screen_pens[dopus_curgadbank->gadgets[a].bpen].pen);
  264.                         len=makeusstring(dopus_curgadbank->gadgets[a].name,buf,&uspos);
  265.                         l=dotextlength(main_rp,buf,&len,scrdata_gadget_width-4); buf[len]=0;
  266.                         UScoreText(main_rp,buf,(x*scrdata_gadget_width)+scrdata_gadget_xpos+((scrdata_gadget_width-l)/2),(y*scrdata_gadget_height)+ty,uspos);
  267.                     }
  268.                     main_gadgets[num].Activation&=~GACT_BOOLEXTEND;
  269.                     main_gadgets[num].SpecialInfo=NULL;
  270.                     if (config->generalscreenflags&SCR_GENERAL_INDICATERMB &&
  271.                         !bankoffset && isvalidgad(&dopus_curgadbank->gadgets[a+(GADCOUNT/2)])) {
  272.                         drawgadgetcorner(main_rp,x1,y1);
  273.                         fix_gadget_highlight(&dopus_curgadbank->gadgets[a],&main_gadgets[num],1);
  274.                     }
  275.                     else fix_gadget_highlight(&dopus_curgadbank->gadgets[a],&main_gadgets[num],0);
  276.                 }
  277.                 ++num;
  278.             }
  279.         }
  280.     }
  281.  
  282.     if (addgads) {
  283.         num=0;
  284.         for (y=0;y<scr_gadget_rows;y++) {
  285.             b=((data_gadgetrow_offset+y)*7)+bankoffset;
  286.             for (x=0;x<7;x++,b++,num++) {
  287.                 main_gadgets[num].Activation|=GACT_RELVERIFY;
  288.                 main_gadgets[num].LeftEdge=(x*scrdata_gadget_width)+scrdata_gadget_xpos;
  289.                 main_gadgets[num].TopEdge=(y*scrdata_gadget_height)+scrdata_gadget_ypos-1;
  290.                 main_gadgets[num].Width=scrdata_gadget_width;
  291.                 main_gadgets[num].Height=scrdata_gadget_height;
  292.                 main_gadgets[num].GadgetType=GTYP_BOOLGADGET;
  293.                 main_gadgets[num].GadgetID=MAIN_GAD_BASE+b;
  294.                 main_gadgets[num].NextGadget=(b<41)?&main_gadgets[num+1]:NULL;
  295.  
  296.                 if (dopus_curgadbank) {
  297.                     if (config->generalscreenflags&SCR_GENERAL_INDICATERMB &&
  298.                         !bankoffset && isvalidgad(&dopus_curgadbank->gadgets[b+(GADCOUNT/2)])) {
  299.                         fix_gadget_highlight(&dopus_curgadbank->gadgets[b],&main_gadgets[num],1);
  300.                     }
  301.                     else fix_gadget_highlight(&dopus_curgadbank->gadgets[b],&main_gadgets[num],0);
  302.                 }
  303.                 else main_gadgets[num].Flags=GFLG_GADGHNONE;
  304.             }
  305.         }
  306.         AddGList(Window,main_gadgets,-1,num,NULL);
  307.         if (scrdata_drive_width) {
  308.             for (y=0;y<scr_gadget_rows;y++) {
  309.                 drive_gadgets[y].Flags=(config->drive[y+data_drive_offset].name[0] &&
  310.                     config->drive[y+data_drive_offset].function &&
  311.                     config->drive[y+data_drive_offset].function[0])?
  312.                         ((drive_unsel_border)?GFLG_GADGHIMAGE:GFLG_GADGHCOMP):GFLG_GADGHNONE;
  313.                 drive_gadgets[y].LeftEdge=scrdata_gadget_offset;
  314.                 drive_gadgets[y].Width=scrdata_drive_width;
  315.                 drive_gadgets[y].TopEdge=(y*scrdata_gadget_height)+scrdata_gadget_ypos-1;
  316.                 drive_gadgets[y].Height=scrdata_gadget_height;
  317.                 drive_gadgets[y].Activation=GACT_RELVERIFY;
  318.                 drive_gadgets[y].GadgetType=GTYP_BOOLGADGET;
  319.                 drive_gadgets[y].GadgetRender=drive_unsel_border;
  320.                 drive_gadgets[y].SelectRender=drive_sel_border;
  321.                 drive_gadgets[y].GadgetID=200+y;
  322.                 drive_gadgets[y].NextGadget=(y<scr_gadget_rows-1)?&drive_gadgets[y+1]:NULL;
  323.             }
  324.             AddGList(Window,drive_gadgets,-1,scr_gadget_rows,NULL);
  325.         }
  326.     }
  327.     if (status_iconified<1) SetFont(main_rp,scr_font[FONT_GENERAL]);
  328. }
  329.  
  330. void fix_gadget_highlight(func,gad,rmb)
  331. struct newdopusfunction *func;
  332. struct Gadget *gad;
  333. int rmb;
  334. {
  335.     struct Border *selborder,*unselborder;
  336.  
  337.     if (rmb) {
  338.         selborder=gadget_dog_sel_border;
  339.         unselborder=gadget_dog_unsel_border;
  340.     }
  341.     else {
  342.         selborder=gadget_sel_border;
  343.         unselborder=gadget_unsel_border;
  344.     }
  345.  
  346.     gad->GadgetRender=NULL;
  347.     gad->SelectRender=NULL;
  348.  
  349.     if (isvalidgad(func)) {
  350.         if (unselborder) {
  351.             gad->Flags=GFLG_GADGHIMAGE;
  352.             gad->GadgetRender=unselborder;
  353.             gad->SelectRender=selborder;
  354.         }
  355.         else gad->Flags=GFLG_GADGHCOMP;
  356.     }
  357.     else gad->Flags=GFLG_GADGHNONE;
  358. }
  359.  
  360. void init_menus()
  361. {
  362.     int a;
  363.  
  364.     for (a=0;a<5;a++) {
  365.         menu_menus[a].MenuName=config->menutit[a];
  366.         menu_menus[a].TopEdge=0;
  367.         menu_menus[a].Flags=MENUENABLED;
  368.     }
  369.     for (a=0;a<MENUCOUNT;a++) {
  370.         menu_intuitext[a*2].DrawMode=JAM2;
  371.         menu_intuitext[a*2].ITextFont=&menu_attr;
  372.         menu_intuitext[a*2].IText=(UBYTE *)menu_spaceitemnames[a/20];
  373.         menu_intuitext[a*2].NextText=&menu_intuitext[(a*2)+1];
  374.         menu_intuitext[(a*2)+1].DrawMode=JAM2;
  375.         menu_intuitext[(a*2)+1].ITextFont=&menu_attr;
  376.         menu_intuitext[(a*2)+1].IText=(UBYTE *)&menu_itemnames[a*MAXMENULENGTH];
  377.         menu_menuitem[a].Flags=ITEMTEXT|ITEMENABLED|HIGHCOMP;
  378.         menu_menuitem[a].ItemFill=(APTR)&menu_intuitext[a*2];
  379.     }
  380. }
  381.  
  382. void layout_menus()
  383. {
  384.     int a,b,c,d,e,w,f,x=0,l,rn=0,iwid[20],spacew,numspace,snum,fpen,bpen,barflag,t,top;
  385.     struct Menu *firstmenu=NULL,*lastmenu=NULL;
  386.     struct TextFont *title_font;
  387.     struct DrawInfo *drinfo=NULL;
  388.     struct Image *barimage;
  389.     int menu_fpen,menu_bpen;
  390.     char *name;
  391.     int spacewidth;
  392.  
  393.     if (Window->MenuStrip) ClearMenuStrip(Window);
  394.     LFreeRemember(&menu_key);
  395.  
  396.     title_font=Window->WScreen->RastPort.Font;
  397.     if (system_version2>=OSVER_39 && !MainScreen) drinfo=GetScreenDrawInfo(Window->WScreen);
  398.  
  399.     spacew=gettextlength(scr_font[FONT_MENUS]," ",NULL,0);
  400.  
  401.     if (system_version2>=OSVER_39 && Window->Flags&WFLG_NEWLOOKMENUS) {
  402.         if (drinfo) {
  403.             menu_fpen=drinfo->dri_Pens[BARDETAILPEN];
  404.             menu_bpen=drinfo->dri_Pens[BARBLOCKPEN];
  405.         }
  406.         else {
  407.             menu_fpen=screen_pens[1].pen;
  408.             menu_bpen=screen_pens[2].pen;
  409.         }
  410.     }
  411.     else {
  412.         menu_fpen=screen_pens[0].pen;
  413.         menu_bpen=screen_pens[1].pen;
  414.     }
  415.  
  416.     for (a=0;a<MENUCOUNT;a++) {
  417.         if (system_version2>=OSVER_39 &&
  418.             Window->Flags&WFLG_NEWLOOKMENUS &&
  419.             config->menu[a].fpen==0 && config->menu[a].bpen==1) {
  420.             fpen=menu_fpen;
  421.             bpen=menu_bpen;
  422.         }
  423.         else {
  424.             fpen=screen_pens[config->menu[a].fpen].pen;
  425.             bpen=screen_pens[config->menu[a].bpen].pen;
  426.         }
  427.         menu_intuitext[a*2].BackPen=(UBYTE)bpen;
  428.         menu_intuitext[(a*2)+1].FrontPen=(UBYTE)fpen;
  429.         menu_intuitext[(a*2)+1].BackPen=(UBYTE)bpen;
  430.     }
  431.  
  432.     for (a=0;a<5;a++) {
  433.         c=0; d=a*20; l=0;
  434.         menu_menus[a].Width=
  435.             gettextlength(title_font,config->menutit[a],&l,0)+
  436.             title_font->tf_XSize;
  437.         menu_menus[a].LeftEdge=x;
  438.  
  439.         for (b=19;b>=0;b--) {
  440.             if (config->menu[d+b].name && config->menu[d+b].name[0]) {
  441.                 c=1;
  442.                 break;
  443.             }
  444.         }
  445.  
  446.         if (c) {
  447.             menu_real_number[rn++]=a;
  448.             x+=menu_menus[a].Width+(title_font->tf_XSize-1);
  449.             f=a*20;
  450.             w=menu_menus[a].Width;
  451.             for (e=0;e<20;e++) {
  452.                 menu_menuitem[f].NextItem=NULL;
  453.                 if (config->menu[f].name)
  454.                     iwid[e]=gettextlength(scr_font[FONT_MENUS],config->menu[f].name,NULL,0);
  455.                 else iwid[e]=0;
  456.                 if (iwid[e]>w) w=iwid[e];
  457.                 ++f;
  458.             }
  459.  
  460.             f=a*20;
  461.  
  462.             numspace=w/spacew;
  463.             CopyMem(str_space_string,menu_spaceitemnames[a],numspace);
  464.             menu_spaceitemnames[a][numspace]=0;
  465.             snum=(numspace>15)?15:numspace;
  466.             spacewidth=gettextlength(scr_font[FONT_MENUS],menu_spaceitemnames[a],NULL,0);
  467.  
  468.             top=0;
  469.             barimage=NULL;
  470.  
  471.             for (e=0;e<20;e++) {
  472.                 menu_menuitem[f].TopEdge=top;
  473.                 menu_menuitem[f].Width=w;
  474.                 menu_menuitem[f].Height=scr_font[FONT_MENUS]->tf_YSize;
  475.                 menu_menuitem[f].Flags=
  476.                     ITEMTEXT|ITEMENABLED|((isvalidgad(&config->menu[f]))?HIGHCOMP:HIGHNONE);
  477.  
  478.                 menu_intuitext[f*2].LeftEdge=(menu_menuitem[f].LeftEdge+w)-spacewidth;
  479.  
  480.                 name=&menu_itemnames[f*MAXMENULENGTH];
  481.                 barflag=0;
  482.                 if (config->menu[f].name && config->menu[f].name[0]) {
  483.                     LStrnCpy(name,config->menu[f].name,MAXMENULENGTH-1);
  484.                     if (name[(t=(strlen(name)-1))]=='~') {
  485.                         barflag=1;
  486.                         name[t]=0;
  487.                     }
  488.                 }
  489.                 else {
  490.                     CopyMem(str_space_string,name,snum);
  491.                     name[snum]=0;
  492.                 }
  493.                 top+=scr_font[FONT_MENUS]->tf_YSize;
  494.                 if (barflag) {
  495.                     top+=6;
  496.                     menu_menuitem[f].MutualExclude=1;
  497.                     if (!barimage) barimage=get_bar_image(menu_fpen,menu_bpen,w-1);
  498.                 }
  499.                 ++f;
  500.             }
  501.             menu_menus[a].Flags=MENUENABLED;
  502.             menu_menus[a].FirstItem=&menu_menuitem[d];
  503.             for (c=0,t=d;c<b;c++,t++)
  504.                 get_bar_item(&menu_menuitem[t],&menu_menuitem[t+1],barimage);
  505.             menu_menuitem[t].MutualExclude=1;
  506.             get_bar_item(&menu_menuitem[t],NULL,NULL);
  507.             if (firstmenu) lastmenu->NextMenu=&menu_menus[a];
  508.             else firstmenu=&menu_menus[a];
  509.             lastmenu=&menu_menus[a];
  510.             lastmenu->NextMenu=NULL;
  511.         }
  512.     }
  513.     if (firstmenu) SetMenuStrip(Window,firstmenu);
  514.     if (drinfo) FreeScreenDrawInfo(Window->WScreen,drinfo);
  515. }
  516.  
  517. maxgadwidth(font,gads,num)
  518. struct TextFont *font;
  519. char **gads;
  520. int num;
  521. {
  522.     int a,mw=0,w,len;
  523.  
  524.     for (a=0;a<num;a++) {
  525.         len=0;
  526.         if ((w=gettextlength(font,gads[a],&len,-1))>mw) mw=w;
  527.     }
  528.     return(mw);
  529. }
  530.  
  531. gettextlength(font,text,len,width)
  532. struct TextFont *font;
  533. char *text;
  534. int *len,width;
  535. {
  536.     struct RastPort testrast;
  537.  
  538.     InitRastPort(&testrast);
  539.     if (font) SetFont(&testrast,font);
  540.     return(dotextlength(&testrast,text,len,width));
  541. }
  542.  
  543. dotextlength(r,text,len,width)
  544. struct RastPort *r;
  545. char *text;
  546. int *len,width;
  547. {
  548.     int l,x=0;
  549.     struct TextExtent ext;
  550.  
  551.     if (!len || !(l=*len)) l=strlen(text);
  552.     if (l) {
  553.         if (system_version2 && width>0) {
  554.             if (system_version2<OSVER_39 && r->Font->tf_Flags&FPF_PROPORTIONAL) ++width;
  555.             l=TextFit(r,text,l,&ext,NULL,1,width,r->Font->tf_YSize+1);
  556.             x=ext.te_Width;
  557.         }
  558.         else {
  559.             while ((x=TextLength(r,text,l))>width && width>0) {
  560.                 if (!(--l)) break;
  561.             }
  562.         }
  563.     }
  564.     if (len) *len=l;
  565.     return(x);
  566. }
  567.  
  568. void doposdriveprop()
  569. {
  570.     int off,old;
  571.  
  572.     if (scr_gadget_rows) {
  573.         ShowSlider(Window,&drive_propgad);
  574.         old=data_drive_offset;
  575.         off=GetSliderPos(&drive_propgad,USEDRIVECOUNT,scr_gadget_rows);
  576.         if (old!=off) {
  577.             data_drive_offset=off;
  578.             fixdrivegadgets();
  579.         }
  580.     }
  581. }
  582.  
  583. void doposgadgetprop(ref)
  584. int ref;
  585. {
  586.     struct dopusgadgetbanks *bank,*oldbank;
  587.     int a,bankcount,bankstep,oldoff,num;
  588.  
  589.     if (scr_gadget_rows) {
  590.         ShowSlider(Window,&gadget_propgad);
  591.         oldbank=dopus_curgadbank; oldoff=data_gadgetrow_offset;
  592.         bank=dopus_firstgadbank;
  593.         for (bankcount=0;;bankcount++) {
  594.             if (!bank) break;
  595.             bank=bank->next;
  596.         }
  597.         bankstep=6/scr_gadget_rows;
  598.         data_gadgetrow_offset=GetSliderPos(&gadget_propgad,(bankcount*6)/scr_gadget_rows,1);
  599.         a=data_gadgetrow_offset/bankstep;
  600.         data_gadgetrow_offset%=bankstep; data_gadgetrow_offset*=scr_gadget_rows;
  601.         dopus_curgadbank=dopus_firstgadbank; num=a;
  602.         while ((num--) && dopus_curgadbank->next) dopus_curgadbank=dopus_curgadbank->next;
  603.         if (dopus_curgadbank!=oldbank || data_gadgetrow_offset!=oldoff) drawgadgets(0,0);
  604.         if (ref) {
  605.             FixSliderPot(Window,
  606.                 &gadget_propgad,
  607.                 (a*bankstep)+(data_gadgetrow_offset/scr_gadget_rows),
  608.                 (bankcount*6)/scr_gadget_rows,1,1);
  609.         }
  610.     }
  611. }
  612.  
  613. void fixgadgetprop()
  614. {
  615.     struct dopusgadgetbanks *bank;
  616.     int a,bankcount,num;
  617.  
  618.     if (scr_gadget_rows &&
  619.         ((status_iconified && status_flags&STATUS_ISINBUTTONS) ||
  620.             (scr_gadget_bank_count>1 && config->generalscreenflags&SCR_GENERAL_GADSLIDERS))) {
  621.         bank=dopus_firstgadbank;
  622.         num=bankcount=0;
  623.         a=1;
  624.         while (bank) {
  625.             if (bank==dopus_curgadbank) a=0;
  626.             else if (a) ++num;
  627.             ++bankcount;
  628.             bank=bank->next;
  629.         }
  630.         if (!a) {
  631.             FixSliderPot(Window,
  632.                 (status_iconified && status_flags&STATUS_ISINBUTTONS)?&iconbutpropgad:&gadget_propgad,
  633.                 (num*(6/scr_gadget_rows))+(data_gadgetrow_offset/scr_gadget_rows),
  634.                 (bankcount*6)/scr_gadget_rows,
  635.                 1,1);
  636.         }
  637.     }
  638. }
  639.  
  640. makeusstring(from,to,uspos)
  641. char *from,*to;
  642. int *uspos;
  643. {
  644.     int len,c;
  645.  
  646.     *uspos=-1;
  647.     for (c=0,len=0;;c++) {
  648.         if (!from[c]) break;
  649.         else if (from[c]=='_' && *uspos==-1) *uspos=len;
  650.         else to[len++]=from[c];
  651.     }
  652.     to[len]=0;
  653.     return(len);
  654. }
  655.  
  656. void drawgadgetcorner(r,x1,y1)
  657. struct RastPort *r;
  658. int x1,y1;
  659. {
  660.     x1+=scrdata_gadget_width-2;
  661.     drawcornerimage(r,
  662.         x1,y1,
  663.         screen_pens[0].pen,
  664.         screen_pens[config->gadgetbotcol].pen,
  665.         screen_pens[config->gadgettopcol].pen);
  666. }
  667.  
  668. void drawcornerimage(r,x1,y1,bg,bc,tc)
  669. struct RastPort *r;
  670. int x1,y1,bg,bc,tc;
  671. {
  672.     SetAPen(r,bg);
  673.     rectfill(r,x1-5,y1-1,5,4);
  674.     SetDrMd(r,JAM1);
  675.     SetAPen(r,bc);
  676.     BltTemplate((char *)pageflip_data1,0,2,r,x1-6,y1-1,6,5);
  677.     SetAPen(r,tc);
  678.     BltTemplate((char *)pageflip_data2,0,2,r,x1-6,y1,6,3);
  679.     SetDrMd(r,JAM2);
  680. }
  681.  
  682. void get_bar_item(item,nextitem,image)
  683. struct MenuItem *item,*nextitem;
  684. struct Image *image;
  685. {
  686.     struct MenuItem *baritem;
  687.  
  688.     if (item->MutualExclude==1 &&
  689.         (baritem=LAllocRemember(&menu_key,sizeof(struct MenuItem),MEMF_CLEAR))) {
  690.  
  691.         if (nextitem) {
  692.             baritem->NextItem=nextitem;
  693.             baritem->TopEdge=item->TopEdge+item->Height+2;
  694.             baritem->Width=item->Width;
  695.             baritem->Height=2;
  696.             baritem->Flags=HIGHNONE;
  697.             baritem->ItemFill=image;
  698.         }
  699.         else {
  700.             baritem->TopEdge=item->TopEdge+item->Height;
  701.             baritem->Width=item->Width+1;
  702.             baritem->Height=0;
  703.             baritem->Flags=HIGHNONE;
  704.         }
  705.         item->NextItem=baritem;
  706.     }
  707.     else item->NextItem=nextitem;
  708.     item->MutualExclude=0;
  709. }
  710.  
  711. struct Image *get_bar_image(fg,bg,width)
  712. int fg,bg,width;
  713. {
  714.     struct Image *image;
  715.  
  716.     if (!(image=LAllocRemember(&menu_key,sizeof(struct Image),MEMF_CLEAR))) return(NULL);
  717.  
  718.     image->Width=width;
  719.     image->Height=2;
  720.     image->PlaneOnOff=fg;
  721.  
  722.     return(image);
  723. }
  724.  
  725. /*
  726.     if (newlook) image->PlaneOnOff=fg;
  727.     else {
  728.         USHORT *imagedata;
  729.         int words,a,b,depth,pos;
  730.  
  731.         words=(width+15)/16;
  732.         for (depth=0;;depth++)
  733.             if ((1<<depth)>fg && (1<<depth)>bg) break;
  734.  
  735.         if (!(imagedata=LAllocRemember(&menu_key,words*2*depth*sizeof(USHORT),MEMF_CLEAR|MEMF_CHIP)))
  736.             return(NULL);
  737.  
  738.         for (a=0,pos=0;a<depth;a++) {
  739.             for (b=0;b<words;b++,pos++) {
  740.                 if (fg&(1<<a)) imagedata[pos]=0xdddd;
  741.                 if (bg&(1<<a)) imagedata[pos]|=0x2222;
  742.             }
  743.             for (b=0;b<words;b++,pos++) {
  744.                 if (fg&(1<<a)) imagedata[pos]=0x7777;
  745.                 if (bg&(1<<a)) imagedata[pos]|=0x8888;
  746.             }
  747.         }
  748.  
  749.         image->ImageData=imagedata;
  750.         image->Depth=depth;
  751.         image->PlanePick=(1<<depth)-1;
  752.     }
  753.     return(image);
  754. }
  755. */
  756.