home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / DOpus4-GPL / Program / main21.c < prev    next >
C/C++ Source or Header  |  2000-01-27  |  22KB  |  753 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.     if (addgads) allocate_borders();
  216.  
  217.     if (!scr_gadget_rows) return;
  218.     if (status_iconified>0) yoff=Window->BorderTop+1;
  219.     else {
  220.         yoff=scrdata_gadget_ypos;
  221.         SetFont(main_rp,scr_font[FONT_GADGETS]);
  222.     }
  223.  
  224.     if (addgads!=-1) {
  225.         if (scrdata_drive_width) {
  226.             for (y=0;y<scr_gadget_rows;y++)
  227.                 do3dbox(main_rp,
  228.                     scrdata_gadget_offset+2,(y*scrdata_gadget_height)+yoff,
  229.                     scrdata_drive_width-4,scrdata_gadget_height-2);
  230.         }
  231.  
  232.         for (x=0;x<7;x++) {
  233.             for (y=0;y<scr_gadget_rows;y++) {
  234.                 do3dbox(main_rp,
  235.                     (x*scrdata_gadget_width)+scrdata_gadget_xpos+2,(y*scrdata_gadget_height)+yoff,
  236.                     scrdata_gadget_width-4,scrdata_gadget_height-2);
  237.             }
  238.         }
  239.     }
  240.  
  241.     if (status_iconified>0) ty=Window->BorderTop+main_rp->Font->tf_Baseline+1;
  242.     else ty=yoff+scr_font[FONT_GADGETS]->tf_Baseline+((scrdata_gadget_height-2-scr_font[FONT_GADGETS]->tf_YSize)/2);
  243.  
  244.     num=0;
  245.     if (addgads!=-1) {
  246.         for (y=0;y<scr_gadget_rows;y++) {
  247.             a=((data_gadgetrow_offset+y)*7)+bankoffset;
  248.             for (x=0;x<7;x++,a++) {
  249.                 main_gadgets[num].Flags=GFLG_GADGHNONE;
  250.                 if (dopus_curgadbank) {
  251.                     SetAPen(main_rp,screen_pens[dopus_curgadbank->gadgets[a].bpen].pen);
  252.                     rectfill(main_rp,
  253.                         (x1=((x*scrdata_gadget_width)+scrdata_gadget_xpos+2)),
  254.                         (y1=((y*scrdata_gadget_height)+yoff)),
  255.                         scrdata_gadget_width-4,
  256.                         scrdata_gadget_height-2);
  257.                     if (dopus_curgadbank->gadgets[a].name &&
  258.                         dopus_curgadbank->gadgets[a].name[0]) {
  259.                         SetAPen(main_rp,screen_pens[dopus_curgadbank->gadgets[a].fpen].pen);
  260.                         SetBPen(main_rp,screen_pens[dopus_curgadbank->gadgets[a].bpen].pen);
  261.                         len=makeusstring(dopus_curgadbank->gadgets[a].name,buf,&uspos);
  262.                         l=dotextlength(main_rp,buf,&len,scrdata_gadget_width-4); buf[len]=0;
  263.                         UScoreText(main_rp,buf,(x*scrdata_gadget_width)+scrdata_gadget_xpos+((scrdata_gadget_width-l)/2),(y*scrdata_gadget_height)+ty,uspos);
  264.                     }
  265.                     main_gadgets[num].Activation&=~GACT_BOOLEXTEND;
  266.                     main_gadgets[num].SpecialInfo=NULL;
  267.                     if (config->generalscreenflags&SCR_GENERAL_INDICATERMB &&
  268.                         !bankoffset && isvalidgad(&dopus_curgadbank->gadgets[a+(GADCOUNT/2)])) {
  269.                         drawgadgetcorner(main_rp,x1,y1);
  270.                         fix_gadget_highlight(&dopus_curgadbank->gadgets[a],&main_gadgets[num],1);
  271.                     }
  272.                     else fix_gadget_highlight(&dopus_curgadbank->gadgets[a],&main_gadgets[num],0);
  273.                 }
  274.                 ++num;
  275.             }
  276.         }
  277.     }
  278.  
  279.     if (addgads) {
  280.         num=0;
  281.         for (y=0;y<scr_gadget_rows;y++) {
  282.             b=((data_gadgetrow_offset+y)*7)+bankoffset;
  283.             for (x=0;x<7;x++,b++,num++) {
  284.                 main_gadgets[num].Activation|=GACT_RELVERIFY;
  285.                 main_gadgets[num].LeftEdge=(x*scrdata_gadget_width)+scrdata_gadget_xpos;
  286.                 main_gadgets[num].TopEdge=(y*scrdata_gadget_height)+scrdata_gadget_ypos-1;
  287.                 main_gadgets[num].Width=scrdata_gadget_width;
  288.                 main_gadgets[num].Height=scrdata_gadget_height;
  289.                 main_gadgets[num].GadgetType=GTYP_BOOLGADGET;
  290.                 main_gadgets[num].GadgetID=MAIN_GAD_BASE+b;
  291.                 main_gadgets[num].NextGadget=(b<41)?&main_gadgets[num+1]:NULL;
  292.  
  293.                 if (dopus_curgadbank) {
  294.                     if (config->generalscreenflags&SCR_GENERAL_INDICATERMB &&
  295.                         !bankoffset && isvalidgad(&dopus_curgadbank->gadgets[b+(GADCOUNT/2)])) {
  296.                         fix_gadget_highlight(&dopus_curgadbank->gadgets[b],&main_gadgets[num],1);
  297.                     }
  298.                     else fix_gadget_highlight(&dopus_curgadbank->gadgets[b],&main_gadgets[num],0);
  299.                 }
  300.                 else main_gadgets[num].Flags=GFLG_GADGHNONE;
  301.             }
  302.         }
  303.         AddGList(Window,main_gadgets,-1,num,NULL);
  304.         if (scrdata_drive_width) {
  305.             for (y=0;y<scr_gadget_rows;y++) {
  306.                 drive_gadgets[y].Flags=(config->drive[y+data_drive_offset].name[0] &&
  307.                     config->drive[y+data_drive_offset].function &&
  308.                     config->drive[y+data_drive_offset].function[0])?
  309.                         ((drive_unsel_border)?GFLG_GADGHIMAGE:GFLG_GADGHCOMP):GFLG_GADGHNONE;
  310.                 drive_gadgets[y].LeftEdge=scrdata_gadget_offset;
  311.                 drive_gadgets[y].Width=scrdata_drive_width;
  312.                 drive_gadgets[y].TopEdge=(y*scrdata_gadget_height)+scrdata_gadget_ypos-1;
  313.                 drive_gadgets[y].Height=scrdata_gadget_height;
  314.                 drive_gadgets[y].Activation=GACT_RELVERIFY;
  315.                 drive_gadgets[y].GadgetType=GTYP_BOOLGADGET;
  316.                 drive_gadgets[y].GadgetRender=drive_unsel_border;
  317.                 drive_gadgets[y].SelectRender=drive_sel_border;
  318.                 drive_gadgets[y].GadgetID=200+y;
  319.                 drive_gadgets[y].NextGadget=(y<scr_gadget_rows-1)?&drive_gadgets[y+1]:NULL;
  320.             }
  321.             AddGList(Window,drive_gadgets,-1,scr_gadget_rows,NULL);
  322.         }
  323.     }
  324.     if (status_iconified<1) SetFont(main_rp,scr_font[FONT_GENERAL]);
  325. }
  326.  
  327. void fix_gadget_highlight(func,gad,rmb)
  328. struct newdopusfunction *func;
  329. struct Gadget *gad;
  330. int rmb;
  331. {
  332.     struct Border *selborder,*unselborder;
  333.  
  334.     if (rmb) {
  335.         selborder=gadget_dog_sel_border;
  336.         unselborder=gadget_dog_unsel_border;
  337.     }
  338.     else {
  339.         selborder=gadget_sel_border;
  340.         unselborder=gadget_unsel_border;
  341.     }
  342.  
  343.     gad->GadgetRender=NULL;
  344.     gad->SelectRender=NULL;
  345.  
  346.     if (isvalidgad(func)) {
  347.         if (unselborder) {
  348.             gad->Flags=GFLG_GADGHIMAGE;
  349.             gad->GadgetRender=unselborder;
  350.             gad->SelectRender=selborder;
  351.         }
  352.         else gad->Flags=GFLG_GADGHCOMP;
  353.     }
  354.     else gad->Flags=GFLG_GADGHNONE;
  355. }
  356.  
  357. void init_menus()
  358. {
  359.     int a;
  360.  
  361.     for (a=0;a<5;a++) {
  362.         menu_menus[a].MenuName=config->menutit[a];
  363.         menu_menus[a].TopEdge=0;
  364.         menu_menus[a].Flags=MENUENABLED;
  365.     }
  366.     for (a=0;a<MENUCOUNT;a++) {
  367.         menu_intuitext[a*2].DrawMode=JAM2;
  368.         menu_intuitext[a*2].ITextFont=&menu_attr;
  369.         menu_intuitext[a*2].IText=(UBYTE *)menu_spaceitemnames[a/20];
  370.         menu_intuitext[a*2].NextText=&menu_intuitext[(a*2)+1];
  371.         menu_intuitext[(a*2)+1].DrawMode=JAM2;
  372.         menu_intuitext[(a*2)+1].ITextFont=&menu_attr;
  373.         menu_intuitext[(a*2)+1].IText=(UBYTE *)&menu_itemnames[a*MAXMENULENGTH];
  374.         menu_menuitem[a].Flags=ITEMTEXT|ITEMENABLED|HIGHCOMP;
  375.         menu_menuitem[a].ItemFill=(APTR)&menu_intuitext[a*2];
  376.     }
  377. }
  378.  
  379. void layout_menus()
  380. {
  381.     int a,b,c,d,e,w,f,x=0,l,rn=0,iwid[20],spacew,numspace,snum,fpen,bpen,barflag,t,top;
  382.     struct Menu *firstmenu=NULL,*lastmenu=NULL;
  383.     struct TextFont *title_font;
  384.     struct DrawInfo *drinfo=NULL;
  385.     struct Image *barimage;
  386.     int menu_fpen,menu_bpen;
  387.     char *name;
  388.     int spacewidth;
  389.  
  390.     if (Window->MenuStrip) ClearMenuStrip(Window);
  391.     LFreeRemember(&menu_key);
  392.  
  393.     title_font=Window->WScreen->RastPort.Font;
  394.     if (system_version2>=OSVER_39 && !MainScreen) drinfo=GetScreenDrawInfo(Window->WScreen);
  395.  
  396.     spacew=gettextlength(scr_font[FONT_MENUS]," ",NULL,0);
  397.  
  398.     if (system_version2>=OSVER_39 && Window->Flags&WFLG_NEWLOOKMENUS) {
  399.         if (drinfo) {
  400.             menu_fpen=drinfo->dri_Pens[BARDETAILPEN];
  401.             menu_bpen=drinfo->dri_Pens[BARBLOCKPEN];
  402.         }
  403.         else {
  404.             menu_fpen=screen_pens[1].pen;
  405.             menu_bpen=screen_pens[2].pen;
  406.         }
  407.     }
  408.     else {
  409.         menu_fpen=screen_pens[0].pen;
  410.         menu_bpen=screen_pens[1].pen;
  411.     }
  412.  
  413.     for (a=0;a<MENUCOUNT;a++) {
  414.         if (system_version2>=OSVER_39 &&
  415.             Window->Flags&WFLG_NEWLOOKMENUS &&
  416.             config->menu[a].fpen==0 && config->menu[a].bpen==1) {
  417.             fpen=menu_fpen;
  418.             bpen=menu_bpen;
  419.         }
  420.         else {
  421.             fpen=screen_pens[config->menu[a].fpen].pen;
  422.             bpen=screen_pens[config->menu[a].bpen].pen;
  423.         }
  424.         menu_intuitext[a*2].BackPen=(UBYTE)bpen;
  425.         menu_intuitext[(a*2)+1].FrontPen=(UBYTE)fpen;
  426.         menu_intuitext[(a*2)+1].BackPen=(UBYTE)bpen;
  427.     }
  428.  
  429.     for (a=0;a<5;a++) {
  430.         c=0; d=a*20; l=0;
  431.         menu_menus[a].Width=
  432.             gettextlength(title_font,config->menutit[a],&l,0)+
  433.             title_font->tf_XSize;
  434.         menu_menus[a].LeftEdge=x;
  435.  
  436.         for (b=19;b>=0;b--) {
  437.             if (config->menu[d+b].name && config->menu[d+b].name[0]) {
  438.                 c=1;
  439.                 break;
  440.             }
  441.         }
  442.  
  443.         if (c) {
  444.             menu_real_number[rn++]=a;
  445.             x+=menu_menus[a].Width+(title_font->tf_XSize-1);
  446.             f=a*20;
  447.             w=menu_menus[a].Width;
  448.             for (e=0;e<20;e++) {
  449.                 menu_menuitem[f].NextItem=NULL;
  450.                 if (config->menu[f].name)
  451.                     iwid[e]=gettextlength(scr_font[FONT_MENUS],config->menu[f].name,NULL,0);
  452.                 else iwid[e]=0;
  453.                 if (iwid[e]>w) w=iwid[e];
  454.                 ++f;
  455.             }
  456.  
  457.             f=a*20;
  458.  
  459.             numspace=w/spacew;
  460.             CopyMem(str_space_string,menu_spaceitemnames[a],numspace);
  461.             menu_spaceitemnames[a][numspace]=0;
  462.             snum=(numspace>15)?15:numspace;
  463.             spacewidth=gettextlength(scr_font[FONT_MENUS],menu_spaceitemnames[a],NULL,0);
  464.  
  465.             top=0;
  466.             barimage=NULL;
  467.  
  468.             for (e=0;e<20;e++) {
  469.                 menu_menuitem[f].TopEdge=top;
  470.                 menu_menuitem[f].Width=w;
  471.                 menu_menuitem[f].Height=scr_font[FONT_MENUS]->tf_YSize;
  472.                 menu_menuitem[f].Flags=
  473.                     ITEMTEXT|ITEMENABLED|((isvalidgad(&config->menu[f]))?HIGHCOMP:HIGHNONE);
  474.  
  475.                 menu_intuitext[f*2].LeftEdge=(menu_menuitem[f].LeftEdge+w)-spacewidth;
  476.  
  477.                 name=&menu_itemnames[f*MAXMENULENGTH];
  478.                 barflag=0;
  479.                 if (config->menu[f].name && config->menu[f].name[0]) {
  480.                     LStrnCpy(name,config->menu[f].name,MAXMENULENGTH-1);
  481.                     if (name[(t=(strlen(name)-1))]=='~') {
  482.                         barflag=1;
  483.                         name[t]=0;
  484.                     }
  485.                 }
  486.                 else {
  487.                     CopyMem(str_space_string,name,snum);
  488.                     name[snum]=0;
  489.                 }
  490.                 top+=scr_font[FONT_MENUS]->tf_YSize;
  491.                 if (barflag) {
  492.                     top+=6;
  493.                     menu_menuitem[f].MutualExclude=1;
  494.                     if (!barimage) barimage=get_bar_image(menu_fpen,menu_bpen,w-1);
  495.                 }
  496.                 ++f;
  497.             }
  498.             menu_menus[a].Flags=MENUENABLED;
  499.             menu_menus[a].FirstItem=&menu_menuitem[d];
  500.             for (c=0,t=d;c<b;c++,t++)
  501.                 get_bar_item(&menu_menuitem[t],&menu_menuitem[t+1],barimage);
  502.             menu_menuitem[t].MutualExclude=1;
  503.             get_bar_item(&menu_menuitem[t],NULL,NULL);
  504.             if (firstmenu) lastmenu->NextMenu=&menu_menus[a];
  505.             else firstmenu=&menu_menus[a];
  506.             lastmenu=&menu_menus[a];
  507.             lastmenu->NextMenu=NULL;
  508.         }
  509.     }
  510.     if (firstmenu) SetMenuStrip(Window,firstmenu);
  511.     if (drinfo) FreeScreenDrawInfo(Window->WScreen,drinfo);
  512. }
  513.  
  514. maxgadwidth(font,gads,num)
  515. struct TextFont *font;
  516. char **gads;
  517. int num;
  518. {
  519.     int a,mw=0,w,len;
  520.  
  521.     for (a=0;a<num;a++) {
  522.         len=0;
  523.         if ((w=gettextlength(font,gads[a],&len,-1))>mw) mw=w;
  524.     }
  525.     return(mw);
  526. }
  527.  
  528. gettextlength(font,text,len,width)
  529. struct TextFont *font;
  530. char *text;
  531. int *len,width;
  532. {
  533.     struct RastPort testrast;
  534.  
  535.     InitRastPort(&testrast);
  536.     if (font) SetFont(&testrast,font);
  537.     return(dotextlength(&testrast,text,len,width));
  538. }
  539.  
  540. dotextlength(r,text,len,width)
  541. struct RastPort *r;
  542. char *text;
  543. int *len,width;
  544. {
  545.     int l,x=0;
  546.     struct TextExtent ext;
  547.  
  548.     if (!len || !(l=*len)) l=strlen(text);
  549.     if (l) {
  550.         if (system_version2 && width>0) {
  551.             if (system_version2<OSVER_39 && r->Font->tf_Flags&FPF_PROPORTIONAL) ++width;
  552.             l=TextFit(r,text,l,&ext,NULL,1,width,r->Font->tf_YSize+1);
  553.             x=ext.te_Width;
  554.         }
  555.         else {
  556.             while ((x=TextLength(r,text,l))>width && width>0) {
  557.                 if (!(--l)) break;
  558.             }
  559.         }
  560.     }
  561.     if (len) *len=l;
  562.     return(x);
  563. }
  564.  
  565. void doposdriveprop()
  566. {
  567.     int off,old;
  568.  
  569.     if (scr_gadget_rows) {
  570.         ShowSlider(Window,&drive_propgad);
  571.         old=data_drive_offset;
  572.         off=GetSliderPos(&drive_propgad,USEDRIVECOUNT,scr_gadget_rows);
  573.         if (old!=off) {
  574.             data_drive_offset=off;
  575.             fixdrivegadgets();
  576.         }
  577.     }
  578. }
  579.  
  580. void doposgadgetprop(ref)
  581. int ref;
  582. {
  583.     struct dopusgadgetbanks *bank,*oldbank;
  584.     int a,bankcount,bankstep,oldoff,num;
  585.  
  586.     if (scr_gadget_rows) {
  587.         ShowSlider(Window,&gadget_propgad);
  588.         oldbank=dopus_curgadbank; oldoff=data_gadgetrow_offset;
  589.         bank=dopus_firstgadbank;
  590.         for (bankcount=0;;bankcount++) {
  591.             if (!bank) break;
  592.             bank=bank->next;
  593.         }
  594.         bankstep=6/scr_gadget_rows;
  595.         data_gadgetrow_offset=GetSliderPos(&gadget_propgad,(bankcount*6)/scr_gadget_rows,1);
  596.         a=data_gadgetrow_offset/bankstep;
  597.         data_gadgetrow_offset%=bankstep; data_gadgetrow_offset*=scr_gadget_rows;
  598.         dopus_curgadbank=dopus_firstgadbank; num=a;
  599.         while ((num--) && dopus_curgadbank->next) dopus_curgadbank=dopus_curgadbank->next;
  600.         if (dopus_curgadbank!=oldbank || data_gadgetrow_offset!=oldoff) drawgadgets(0,0);
  601.         if (ref) {
  602.             FixSliderPot(Window,
  603.                 &gadget_propgad,
  604.                 (a*bankstep)+(data_gadgetrow_offset/scr_gadget_rows),
  605.                 (bankcount*6)/scr_gadget_rows,1,1);
  606.         }
  607.     }
  608. }
  609.  
  610. void fixgadgetprop()
  611. {
  612.     struct dopusgadgetbanks *bank;
  613.     int a,bankcount,num;
  614.  
  615.     if (scr_gadget_rows &&
  616.         ((status_iconified && status_flags&STATUS_ISINBUTTONS) ||
  617.             (scr_gadget_bank_count>1 && config->generalscreenflags&SCR_GENERAL_GADSLIDERS))) {
  618.         bank=dopus_firstgadbank;
  619.         num=bankcount=0;
  620.         a=1;
  621.         while (bank) {
  622.             if (bank==dopus_curgadbank) a=0;
  623.             else if (a) ++num;
  624.             ++bankcount;
  625.             bank=bank->next;
  626.         }
  627.         if (!a) {
  628.             FixSliderPot(Window,
  629.                 (status_iconified && status_flags&STATUS_ISINBUTTONS)?&iconbutpropgad:&gadget_propgad,
  630.                 (num*(6/scr_gadget_rows))+(data_gadgetrow_offset/scr_gadget_rows),
  631.                 (bankcount*6)/scr_gadget_rows,
  632.                 1,1);
  633.         }
  634.     }
  635. }
  636.  
  637. makeusstring(from,to,uspos)
  638. char *from,*to;
  639. int *uspos;
  640. {
  641.     int len,c;
  642.  
  643.     *uspos=-1;
  644.     for (c=0,len=0;;c++) {
  645.         if (!from[c]) break;
  646.         else if (from[c]=='_' && *uspos==-1) *uspos=len;
  647.         else to[len++]=from[c];
  648.     }
  649.     to[len]=0;
  650.     return(len);
  651. }
  652.  
  653. void drawgadgetcorner(r,x1,y1)
  654. struct RastPort *r;
  655. int x1,y1;
  656. {
  657.     x1+=scrdata_gadget_width-2;
  658.     drawcornerimage(r,
  659.         x1,y1,
  660.         screen_pens[0].pen,
  661.         screen_pens[config->gadgetbotcol].pen,
  662.         screen_pens[config->gadgettopcol].pen);
  663. }
  664.  
  665. void drawcornerimage(r,x1,y1,bg,bc,tc)
  666. struct RastPort *r;
  667. int x1,y1,bg,bc,tc;
  668. {
  669.     SetAPen(r,bg);
  670.     rectfill(r,x1-5,y1-1,5,4);
  671.     SetDrMd(r,JAM1);
  672.     SetAPen(r,bc);
  673.     BltTemplate((char *)pageflip_data1,0,2,r,x1-6,y1-1,6,5);
  674.     SetAPen(r,tc);
  675.     BltTemplate((char *)pageflip_data2,0,2,r,x1-6,y1,6,3);
  676.     SetDrMd(r,JAM2);
  677. }
  678.  
  679. void get_bar_item(item,nextitem,image)
  680. struct MenuItem *item,*nextitem;
  681. struct Image *image;
  682. {
  683.     struct MenuItem *baritem;
  684.  
  685.     if (item->MutualExclude==1 &&
  686.         (baritem=LAllocRemember(&menu_key,sizeof(struct MenuItem),MEMF_CLEAR))) {
  687.  
  688.         if (nextitem) {
  689.             baritem->NextItem=nextitem;
  690.             baritem->TopEdge=item->TopEdge+item->Height+2;
  691.             baritem->Width=item->Width;
  692.             baritem->Height=2;
  693.             baritem->Flags=HIGHNONE;
  694.             baritem->ItemFill=image;
  695.         }
  696.         else {
  697.             baritem->TopEdge=item->TopEdge+item->Height;
  698.             baritem->Width=item->Width+1;
  699.             baritem->Height=0;
  700.             baritem->Flags=HIGHNONE;
  701.         }
  702.         item->NextItem=baritem;
  703.     }
  704.     else item->NextItem=nextitem;
  705.     item->MutualExclude=0;
  706. }
  707.  
  708. struct Image *get_bar_image(fg,bg,width)
  709. int fg,bg,width;
  710. {
  711.     struct Image *image;
  712.  
  713.     if (!(image=LAllocRemember(&menu_key,sizeof(struct Image),MEMF_CLEAR))) return(NULL);
  714.  
  715.     image->Width=width;
  716.     image->Height=2;
  717.     image->PlaneOnOff=fg;
  718.  
  719.     return(image);
  720. }
  721.  
  722. /*
  723.     if (newlook) image->PlaneOnOff=fg;
  724.     else {
  725.         USHORT *imagedata;
  726.         int words,a,b,depth,pos;
  727.  
  728.         words=(width+15)/16;
  729.         for (depth=0;;depth++)
  730.             if ((1<<depth)>fg && (1<<depth)>bg) break;
  731.  
  732.         if (!(imagedata=LAllocRemember(&menu_key,words*2*depth*sizeof(USHORT),MEMF_CLEAR|MEMF_CHIP)))
  733.             return(NULL);
  734.  
  735.         for (a=0,pos=0;a<depth;a++) {
  736.             for (b=0;b<words;b++,pos++) {
  737.                 if (fg&(1<<a)) imagedata[pos]=0xdddd;
  738.                 if (bg&(1<<a)) imagedata[pos]|=0x2222;
  739.             }
  740.             for (b=0;b<words;b++,pos++) {
  741.                 if (fg&(1<<a)) imagedata[pos]=0x7777;
  742.                 if (bg&(1<<a)) imagedata[pos]|=0x8888;
  743.             }
  744.         }
  745.  
  746.         image->ImageData=imagedata;
  747.         image->Depth=depth;
  748.         image->PlanePick=(1<<depth)-1;
  749.     }
  750.     return(image);
  751. }
  752. */
  753.