home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Utilities / ACDPlay / src / V1.6 / Visual.c < prev    next >
C/C++ Source or Header  |  1998-07-22  |  113KB  |  2,400 lines
  1. /* Visual.c */
  2.  
  3. #include "Constants.h"
  4.  
  5. #include <exec/types.h>
  6. #include <exec/memory.h>
  7. #include <exec/libraries.h>
  8. #include <intuition/intuition.h>
  9. #include <intuition/intuitionbase.h>
  10. #include <intuition/gadgetclass.h>
  11. #include <libraries/gadtools.h>
  12. #include <libraries/commodities.h>
  13. #include <libraries/asl.h>
  14. #include <graphics/rastport.h>
  15. #include <graphics/gfxmacros.h>
  16. #include <devices/scsidisk.h>
  17. #include <devices/cd.h>
  18. #include <libraries/screennotify.h>
  19. #include <pragma/screennotify_lib.h>
  20. #include "AsmLib/CD-ROM.h"
  21. #include "Locale.h"
  22. #include "Structures/Application.h"
  23. #include "Structures/DirNode.h"
  24. #include "Structures/MyPubScreenNode.h"
  25.  
  26. #include <clib/alib_protos.h>
  27. #include <clib/dos_protos.h>
  28. #include <clib/exec_protos.h>
  29. #include <clib/asl_protos.h>
  30. #include <clib/gadtools_protos.h>
  31. #include <clib/graphics_protos.h>
  32. #include <clib/intuition_protos.h>
  33. #include <clib/commodities_protos.h>
  34. #include <clib/icon_protos.h>
  35. #include <clib/locale_protos.h>
  36. #include <clib/wb_protos.h>
  37. #include <string.h>
  38. #include <stdlib.h>
  39. #include <stdio.h>
  40. #include <math.h>
  41. #include "ACDPlay_protos.h"
  42.  
  43. extern char *ls[ANZ_MSG];
  44. extern char *PROG_FULLNAME;
  45. char       *TEXT_MAIN_DIRECTCHOICE0[]    = {"_1",  "_2",  "_3",  "_4",  "_5",  "_6",  "_7",  "_8",  "_9",  "1_0", NULL};
  46. char       *TEXT_MAIN_DIRECTCHOICE1[]    = {"11", "12", "13", "14", "15", "16", "17", "18", "19", "20", NULL};
  47.  
  48. void MakeInterior(Application *app, WORD win)
  49. {
  50.     register struct AppWin *appwin = &app->appwin[win];
  51.     register struct CDStruct *cdstr = app->cdstr;
  52.  
  53.     if (!appwin->window) return;
  54.  
  55.     /* Damit bei Fade-Makros die Titel nicht flackern */
  56.     if (win != WINDOW_VOLUME)
  57.         UpdateWinTitle(app);
  58.  
  59.     switch (win)
  60.     {
  61.         case WINDOW_MAIN: /* Hauptfenster */
  62.             if ((app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW]) && ((cdstr->active == AUDIO_STAT_PLAYING) || (cdstr->active == AUDIO_STAT_PAUSED)))
  63.                 GT_SetGadgetAttrs(appwin->gadget[GADGET_MAIN_TITLESHOW], appwin->window, NULL, GTTX_Text, cdstr->tracknames[cdstr->cur_track - 1], TAG_END);
  64.  
  65.             if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSHOW])
  66.                 GT_SetGadgetAttrs(appwin->gadget[GADGET_MAIN_TRACKSHOW], appwin->window, NULL, GTNM_Number, cdstr->cdx->cdx_CurrentTrack, TAG_END);
  67.  
  68.             if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_INDEXSHOW])
  69.                 GT_SetGadgetAttrs(appwin->gadget[GADGET_MAIN_INDEXSHOW], appwin->window, NULL, GTNM_Number, cdstr->cdx->cdx_CurrentIndex, TAG_END);
  70.  
  71.             if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TIMESHOW])
  72.             {
  73.                 DoTimeBuffer(app);
  74.                 GT_SetGadgetAttrs(appwin->gadget[GADGET_MAIN_TIMESHOW], appwin->window, NULL, GTTX_Text, app->timeshowbuf, TAG_END);
  75.             }
  76.             break;
  77.  
  78.         case WINDOW_CDINFO: /* CD-Informationsfenster */
  79.             FormatA(app->timeshowbuf + 20, "%02ld:%02ld", (LONG)base2min(cdstr->cdx->cdx_TOCData->Entry[0].Address), (LONG)base2sec(cdstr->cdx->cdx_TOCData->Entry[0].Address));
  80.             GT_SetGadgetAttrs(appwin->gadget[GADGET_CDINFO_AUTHOR], appwin->window, NULL, GTTX_Text, cdstr->artistname, TAG_END);
  81.             GT_SetGadgetAttrs(appwin->gadget[GADGET_CDINFO_TITLE], appwin->window, NULL, GTTX_Text, cdstr->cdname, TAG_END);
  82.             GT_SetGadgetAttrs(appwin->gadget[GADGET_CDINFO_TRACKS], appwin->window, NULL, GTNM_Number, cdstr->num_track, TAG_END);
  83.             GT_SetGadgetAttrs(appwin->gadget[GADGET_CDINFO_TIME], appwin->window, NULL, GTTX_Text, app->timeshowbuf + 20, TAG_END);
  84.             break;
  85.  
  86.         case WINDOW_DRIVEINFO:
  87.             GT_SetGadgetAttrs(appwin->gadget[GADGET_DRIVEINFO_DEVICE], appwin->window, NULL, GTTX_Text, cdstr->device, GTTX_Justification, GTJ_LEFT, TAG_END);
  88.             GT_SetGadgetAttrs(appwin->gadget[GADGET_DRIVEINFO_UNIT], appwin->window, NULL, GTNM_Number, cdstr->unit, TAG_END);
  89.             GT_SetGadgetAttrs(appwin->gadget[GADGET_DRIVEINFO_VENDOR], appwin->window, NULL, GTTX_Text, cdstr->cdx->cdx_Vendor, TAG_END);
  90.             GT_SetGadgetAttrs(appwin->gadget[GADGET_DRIVEINFO_PRODUCT], appwin->window, NULL, GTTX_Text, &cdstr->cdx->cdx_Product, TAG_END);
  91.             GT_SetGadgetAttrs(appwin->gadget[GADGET_DRIVEINFO_SPECIFIC], appwin->window, NULL, GTTX_Text, &cdstr->cdx->cdx_Specific, TAG_END);
  92.             break;
  93.  
  94.         case WINDOW_PUBSCREEN:
  95.             GT_SetGadgetAttrs(appwin->gadget[GADGET_PUBSCREEN_LISTVIEW], appwin->window, NULL, GTLV_Labels, app->pubscreenlist, TAG_END);
  96.             break;
  97.  
  98.         case WINDOW_TITLES:
  99.             GT_SetGadgetAttrs(appwin->gadget[GADGET_TITLES_LISTVIEW], appwin->window, NULL, GTLV_Labels, cdstr->playlist[cdstr->playmode], TAG_END);
  100.             if (cdstr->active == AUDIO_STAT_PLAYING || cdstr->active == AUDIO_STAT_PAUSED)
  101.                     GT_SetGadgetAttrs(appwin->gadget[GADGET_TITLES_LISTVIEW], appwin->window, NULL, GTLV_Selected, GetNodeNumber(cdstr->playlist[cdstr->playmode], (struct Node *)cdstr->currentlyplayed), TAG_END);
  102.             /*printf("%d", (int)GetNodeNumber(cdstr->playlist[cdstr->playmode], (struct Node *)cdstr->currentlyplayed));
  103.             GT_SetGadgetAttrs(appwin->gadget[GADGET_TITLES_LISTVIEW], appwin->window, NULL, GTLV_Selected, GetNodeNumber(cdstr->playlist[cdstr->playmode], (struct Node *)cdstr->currentlyplayed), TAG_END);*/
  104.             break;
  105.  
  106.         case WINDOW_EDIT:
  107.             GT_SetGadgetAttrs(appwin->gadget[GADGET_EDIT_TITLE], appwin->window, NULL, GTST_String, cdstr->cdname, TAG_END);
  108.             GT_SetGadgetAttrs(appwin->gadget[GADGET_EDIT_ARTIST], appwin->window, NULL, GTST_String, cdstr->artistname, TAG_END);
  109.             GT_SetGadgetAttrs(appwin->gadget[GADGET_EDIT_LISTVIEW], appwin->window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_CD], TAG_END);
  110.             if (app->edit_pos >= 0)
  111.             {
  112.                 GT_SetGadgetAttrs(appwin->gadget[GADGET_EDIT_LISTVIEW], appwin->window, NULL, GTLV_Selected, app->edit_pos, TAG_END);
  113.             }
  114.             break;
  115.  
  116.         case WINDOW_PROGRAM:
  117.             GT_SetGadgetAttrs(appwin->gadget[GADGET_PROGRAM_LVCD], appwin->window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_CD], TAG_END);
  118.             GT_SetGadgetAttrs(appwin->gadget[GADGET_PROGRAM_LVPRG], appwin->window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_PROGRAM], TAG_END);
  119.             break;
  120.  
  121.         case WINDOW_AB:
  122.             DoABBuffer(app);
  123.             break;
  124.  
  125.         case WINDOW_VOLUME:
  126.             GT_SetGadgetAttrs(appwin->gadget[GADGET_VOLUME_LEFT], appwin->window, NULL, GTSL_Level, cdstr->cdx->cdx_Volume[0], TAG_DONE);
  127.             GT_SetGadgetAttrs(appwin->gadget[GADGET_VOLUME_MASTER], appwin->window, NULL, GTSL_Level, (cdstr->cdx->cdx_Volume[0]+cdstr->cdx->cdx_Volume[1])/2, TAG_DONE);
  128.             GT_SetGadgetAttrs(appwin->gadget[GADGET_VOLUME_RIGHT], appwin->window, NULL, GTSL_Level, cdstr->cdx->cdx_Volume[1], TAG_DONE);
  129.             break;
  130.  
  131.         case WINDOW_SAVEAUDIO:
  132.             DoSizeBuffer(app);
  133.             break;
  134.     }
  135. }
  136.  
  137. void UpdateGadgets(Application *app)
  138. {
  139.     int percent;
  140.  
  141.  
  142. /*    printf("Zustand des CDLW: %d", (int)app->cdstr->cdx->cdx_Active);
  143.     printf("      Anzahl Tracks: %d \n", (int)app->cdstr->cdx->cdx_TOCData->TrackNum);
  144. */
  145.  
  146.     if (app->cdstr->num_track != app->cdstr->cdx->cdx_TOCData->TrackNum)
  147.     {
  148.         UpdateTrackNumber(app);
  149.     }
  150.  
  151.     if (app->cdstr->cur_track != app->cdstr->cdx->cdx_CurrentTrack)
  152.     {
  153.         UpdateCurrentTrack(app);
  154.     }
  155.  
  156.     /* Aktuelle Index-Anzeige, kann doch hier plaziert werden, oder? */
  157.     if (app->cdstr->cur_index != app->cdstr->cdx->cdx_CurrentIndex)
  158.     {
  159.         app->cdstr->cur_index = app->cdstr->cdx->cdx_CurrentIndex;
  160.         if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_INDEXSHOW])
  161.             GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_INDEXSHOW], app->appwin[WINDOW_MAIN].window, NULL, GTNM_Number, app->cdstr->cur_index, TAG_END);
  162.     }
  163.  
  164.     if (app->cdstr->active != app->cdstr->cdx->cdx_Active)
  165.     {
  166.         UpdateStatus(app);
  167.     }
  168.  
  169.     percent = app->cdstr->cdx->cdx_TrackLength ? (int) (((double) 100 / (double)app->cdstr->cdx->cdx_TrackLength) * app->cdstr->cdx->cdx_CurrentRelAddr) : 0;
  170.     if (app->cdstr->time_percentage != percent)
  171.     {
  172.         UpdateTimePercent(app, percent);
  173.     }
  174.  
  175.     if (app->cdstr->time_curseconds != app->cdstr->cdx->cdx_CurrentAbsAddr / 75)
  176.     {
  177.         UpdateTimeGadget(app);
  178.     }
  179.  
  180.     /* TestUnitLUN() wird nur von HandleEvents() aus aufgerufen */
  181.  
  182.     TestABRepeat(app);
  183.  
  184.     app->cdstr->useraction = FALSE;        /* useraction-Bool wieder auf unwahr stellen */
  185. }
  186. void UpdateTrackNumber(struct Application *app)
  187. {
  188.     app->cdstr->num_track = app->cdstr->cdx->cdx_TOCData->TrackNum;
  189.  
  190.     /* Falls das CD-Info-Fenster offen ist, Anzahl Tracks modifizieren */
  191.     if (app->appwin[WINDOW_CDINFO].window)
  192.     {
  193.         GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TRACKS], app->appwin[WINDOW_CDINFO].window, NULL, GTNM_Number, app->cdstr->num_track, TAG_END);
  194.     }
  195.     /* Falls das Hauptfenster offen ist, Direktwahlbuttons ggf. shaden */
  196.     if (app->appwin[WINDOW_MAIN].window)
  197.     {
  198.         int i;
  199.  
  200.         for (i = GADGET_MAIN_DIRECTCHOICE0; i < app->cdstr->num_track + GADGET_MAIN_DIRECTCHOICE0; i++)
  201.         {
  202.             if (app->appwin[WINDOW_MAIN].gadget[i])
  203.                 GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[i], app->appwin[WINDOW_MAIN].window, NULL, GA_Disabled, FALSE, TAG_END);
  204.         }
  205.         for (i = app->cdstr->num_track + GADGET_MAIN_DIRECTCHOICE0; i < GADGET_MAIN_DIRECTCHOICE1 + 10; i++)
  206.         {
  207.             if (app->appwin[WINDOW_MAIN].gadget[i])
  208.                 GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[i], app->appwin[WINDOW_MAIN].window, NULL, GA_Disabled, TRUE, TAG_END);
  209.         }
  210.     }
  211. }
  212. void UpdateCurrentTrack(struct Application *app)
  213. {
  214.     register struct CDStruct *cdstr = app->cdstr;
  215.  
  216.     /* letzten Track retten */
  217.     UBYTE lasttrack = cdstr->cur_track;
  218.  
  219.     cdstr->cur_track = cdstr->cdx->cdx_CurrentTrack;
  220.  
  221.     /* Die Wiederholung wird  nicht ausgeführt, wenn die  Trackveränderung  */
  222.     /* von  einem  der Buttons in  ACDPlay (oder über ARexx) geschah, oder  */
  223.     /* wenn der Track danach 0 ist. (Stop, Eject auch bei anderen Playern)  */
  224.  
  225.     if ((cdstr->useraction == FALSE) && (cdstr->cdx->cdx_Active != AUDIO_STAT_NO_DISK) && (cdstr->repeatmode != REPEATMODE_REPAB))
  226.     {
  227.         if (cdstr->repeatmode == REPEATMODE_REPTRACK)
  228.         {
  229.             CDPlayA(cdstr->cdx, lasttrack, 1);
  230.             cdstr->cur_track = lasttrack;
  231.             cdstr->cdx->cdx_Active = AUDIO_STAT_PLAYING;
  232.         }
  233.         else
  234.         {
  235.             if (cdstr->playrandom)
  236.             {
  237.                 if (cdstr->currentlyplayed = GetRandomElement(cdstr->playlist[cdstr->playmode]))
  238.                 {
  239.                     CDPlayVerify(cdstr, cdstr->currentlyplayed->pln_track);
  240.                     cdstr->cur_track = cdstr->currentlyplayed->pln_track;
  241.                     cdstr->cdx->cdx_Active = AUDIO_STAT_PLAYING;
  242.                 }
  243.                 else
  244.                 {
  245.                     if (cdstr->repeatmode == REPEATMODE_REPALL)
  246.                     {
  247.                         PlayListStart(cdstr);
  248.                           cdstr->cur_track = cdstr->currentlyplayed->pln_track;
  249.                         cdstr->cdx->cdx_Active = AUDIO_STAT_PLAYING;
  250.                     }
  251.                     else
  252.                     {
  253.                         CDStopA(cdstr->cdx);
  254.                         cdstr->cur_track = 0;
  255.                         cdstr->currentlyplayed = NULL;
  256.                         cdstr->cdx->cdx_Active = AUDIO_STAT_STOPPED;
  257.                     }
  258.                 }
  259.             }
  260.             else
  261.             {
  262.                 if (cdstr->currentlyplayed == (struct PlayListNode *)cdstr->playlist[cdstr->playmode]->lh_TailPred)
  263.                 {
  264.                     if (cdstr->repeatmode == REPEATMODE_REPALL)
  265.                     {
  266.                         PlayListStart(cdstr);
  267.                           cdstr->cur_track = cdstr->currentlyplayed->pln_track;
  268.                         cdstr->cdx->cdx_Active = AUDIO_STAT_PLAYING;
  269.                     }
  270.                     else
  271.                     {
  272.                         CDStopA(cdstr->cdx);
  273.                         cdstr->cur_track = 0;
  274.                         cdstr->currentlyplayed = NULL;
  275.                         cdstr->cdx->cdx_Active = AUDIO_STAT_STOPPED;
  276.                     }
  277.                 }
  278.                 else
  279.                 {
  280.                     cdstr->currentlyplayed = (struct PlayListNode *)cdstr->currentlyplayed->pln_Node.ln_Succ;
  281.                     CDPlayVerify(cdstr, cdstr->currentlyplayed->pln_track);
  282.                     cdstr->cur_track = cdstr->currentlyplayed->pln_track;
  283.                     cdstr->cdx->cdx_Active = AUDIO_STAT_PLAYING;
  284.                 }
  285.             }
  286.         }
  287.     }
  288.  
  289.     if (cdstr->playlist[cdstr->playmode])
  290.     {
  291.         if (IsListEmpty(cdstr->playlist[cdstr->playmode]))
  292.             CDStopA(cdstr->cdx);
  293.     }
  294.     else
  295.         CDStopA(cdstr->cdx);
  296.  
  297.     if (app->appwin[WINDOW_MAIN].window)
  298.     {
  299.         /* Aktueller-Track-Anzeige */
  300.         if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSHOW])
  301.             GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSHOW], app->appwin[WINDOW_MAIN].window, NULL, GTNM_Number, cdstr->cur_track, TAG_END);
  302.  
  303.         /* Name des Tracks ändert sich */
  304.         if ((app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW]) && ((cdstr->active == AUDIO_STAT_PLAYING) || (cdstr->active == AUDIO_STAT_PAUSED)))
  305.             GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, cdstr->tracknames[cdstr->cur_track - 1], TAG_END);
  306.     }
  307.  
  308.     if (app->appwin[WINDOW_TITLES].window)
  309.     {
  310.         if (app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW] && cdstr->cur_track)
  311.             GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Selected, GetNodeNumber(cdstr->playlist[cdstr->playmode], (struct Node *)cdstr->currentlyplayed), TAG_END);
  312.     }
  313. }
  314. void UpdateStatus(struct Application *app)
  315. {
  316.     register struct CDStruct *cdstr = app->cdstr;
  317.     UBYTE lastactive = cdstr->active;    /* wichtig für UpdateCDTitles und */
  318.                         /* später auch für Gadget-Shadings */
  319.      cdstr->active = cdstr->cdx->cdx_Active;
  320.  
  321.     if ((lastactive == AUDIO_STAT_NO_DISK) || (cdstr->active == AUDIO_STAT_NO_DISK))
  322.     {
  323.         UpdateCDTitles(app);
  324.         if (lastactive == AUDIO_STAT_NO_DISK)
  325.             ProgramLoad(app);
  326.     }
  327.  
  328.     /* PauseGadget updaten */
  329.     if (cdstr->active == AUDIO_STAT_PAUSED)
  330.         SelectGadget(app, WINDOW_MAIN, GADGET_MAIN_PAUSE, TRUE);
  331.     else if (lastactive == AUDIO_STAT_PAUSED)
  332.         SelectGadget(app, WINDOW_MAIN, GADGET_MAIN_PAUSE, FALSE);
  333.  
  334.     if (lastactive == AUDIO_STAT_NO_DISK)
  335.     {
  336.         /* Wenn AUTOSTART, dann CD starten */
  337.         if (app->flag_tool & FLAG_TOOL_AUTOSTART)
  338.             PlayButton(app);
  339.  
  340.         if (app->appwin[WINDOW_MAIN].window)
  341.         {
  342.             int i;
  343.  
  344.             /* einige Direktwahlbuttons enablen */
  345.             for (i = GADGET_MAIN_DIRECTCHOICE0; i < cdstr->num_track + GADGET_MAIN_DIRECTCHOICE0; i++)
  346.             {
  347.                 if (app->appwin[WINDOW_MAIN].gadget[i])
  348.                     GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[i], app->appwin[WINDOW_MAIN].window, NULL, GA_Disabled, FALSE, TAG_END);
  349.             }
  350.  
  351.             for (i = GADGET_MAIN_TITLESHOW; i <= GADGET_MAIN_REPEATMODE; i++)
  352.             {
  353.                 if (app->appwin[WINDOW_MAIN].gadget[i])
  354.                     GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[i], app->appwin[WINDOW_MAIN].window, NULL, GA_Disabled, FALSE, TAG_END);
  355.             }
  356.  
  357.             for (i = GADGET_MAIN_JUMPBWRD; i <= GADGET_MAIN_SRCHFWRD; i++)
  358.             {
  359.                 if (app->appwin[WINDOW_MAIN].gadget[i])
  360.                     OnGadget(app->appwin[WINDOW_MAIN].gadget[i], app->appwin[WINDOW_MAIN].window, NULL);
  361.             }
  362.             if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_PAUSE])
  363.                 OnGadget(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_PAUSE], app->appwin[WINDOW_MAIN].window, NULL);
  364.             if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_PLAY])
  365.                 OnGadget(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_PLAY], app->appwin[WINDOW_MAIN].window, NULL);
  366.         }
  367.  
  368.         if (app->appwin[WINDOW_CDINFO].window)
  369.         {
  370.             FormatA(app->timeshowbuf + 20, "%02ld:%02ld", (LONG)base2min(cdstr->cdx->cdx_TOCData->Entry[0].Address), (LONG)base2sec(cdstr->cdx->cdx_TOCData->Entry[0].Address));
  371.             GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_AUTHOR], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, cdstr->artistname, TAG_END);
  372.             GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TITLE], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, cdstr->cdname, TAG_END);
  373.             GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TRACKS], app->appwin[WINDOW_CDINFO].window, NULL, GTNM_Number, cdstr->num_track, TAG_END);
  374.             GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TIME], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, app->timeshowbuf + 20, TAG_END);
  375.         }
  376.         if (app->appwin[WINDOW_EDIT].window)
  377.         {
  378.             GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TITLE], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, cdstr->cdname, GA_Disabled, FALSE, TAG_END);
  379.             GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_ARTIST], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, cdstr->artistname, GA_Disabled, FALSE, TAG_END);
  380.             GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_SAVE], app->appwin[WINDOW_EDIT].window, NULL, GA_Disabled, FALSE, TAG_END);
  381.         }
  382.         if (app->appwin[WINDOW_PROGRAM].window)
  383.         {
  384.             GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_COPYALL], app->appwin[WINDOW_PROGRAM].window, NULL, GA_Disabled, FALSE, TAG_END);
  385.             GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_DEL], app->appwin[WINDOW_PROGRAM].window, NULL, GA_Disabled, FALSE, TAG_END);
  386.             GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LOAD], app->appwin[WINDOW_PROGRAM].window, NULL, GA_Disabled, FALSE, TAG_END);
  387.             GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_SAVE], app->appwin[WINDOW_PROGRAM].window, NULL, GA_Disabled, FALSE, TAG_END);
  388.         }
  389.         if (app->appwin[WINDOW_AB].window)
  390.         {
  391.             GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TRACK], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, FALSE, TAG_END);
  392.             GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TRACK], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, FALSE, TAG_END);
  393.             GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TIME], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, FALSE, TAG_END);
  394.             GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TIME], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, FALSE, TAG_END);
  395.         }
  396.         if (app->appwin[WINDOW_SAVEAUDIO].window)
  397.         {
  398.             GT_SetGadgetAttrs(app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_SIZE], app->appwin[WINDOW_SAVEAUDIO].window, NULL, GA_Disabled, FALSE, TAG_END);
  399.             GT_SetGadgetAttrs(app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_SAVE], app->appwin[WINDOW_SAVEAUDIO].window, NULL, GA_Disabled, FALSE, TAG_END);
  400.         }
  401.     }
  402.  
  403.     switch (cdstr->active)
  404.     {
  405.         case AUDIO_STAT_NO_DISK:
  406.             if (app->appwin[WINDOW_MAIN].window)
  407.             {
  408.                 int i;
  409.  
  410.                 if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW])
  411.                     GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, NULL, TAG_END);
  412.  
  413.                 for (i = GADGET_MAIN_DIRECTCHOICE0; i < cdstr->num_track + GADGET_MAIN_DIRECTCHOICE0; i++)
  414.                 {
  415.                     if (app->appwin[WINDOW_MAIN].gadget[i])
  416.                         GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[i], app->appwin[WINDOW_MAIN].window, NULL, GA_Disabled, TRUE, TAG_END);
  417.                 }
  418.  
  419.                 for (i = GADGET_MAIN_TITLESHOW; i <= GADGET_MAIN_TRACKSLIDER; i++)
  420.                 {
  421.                     if (app->appwin[WINDOW_MAIN].gadget[i])
  422.                         GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[i], app->appwin[WINDOW_MAIN].window, NULL, GA_Disabled, TRUE, TAG_END);
  423.                 }
  424.  
  425.                 for (i = GADGET_MAIN_JUMPBWRD; i <= GADGET_MAIN_PLAY; i++)
  426.                 {
  427.                     if (app->appwin[WINDOW_MAIN].gadget[i])
  428.                         OffGadget(app->appwin[WINDOW_MAIN].gadget[i], app->appwin[WINDOW_MAIN].window, NULL);
  429.                 }
  430.             }
  431.  
  432.             if (app->appwin[WINDOW_CDINFO].window)
  433.             {
  434.                 GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_AUTHOR], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, NULL, TAG_END);
  435.                 GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TITLE], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, NULL, TAG_END);
  436.                 GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TRACKS], app->appwin[WINDOW_CDINFO].window, NULL, GTNM_Number, 0, TAG_END);
  437.                 GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TIME], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, NULL, TAG_END);
  438.             }
  439.             if (app->appwin[WINDOW_EDIT].window)
  440.             {
  441.                 GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TITLE], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, NULL, GA_Disabled, TRUE, TAG_END);
  442.                 GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_ARTIST], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, NULL, GA_Disabled, TRUE, TAG_END);
  443.                 GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, NULL, GA_Disabled, TRUE, TAG_END);
  444.                 GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_SAVE], app->appwin[WINDOW_EDIT].window, NULL, GA_Disabled, TRUE, TAG_END);
  445.             }
  446.             if (app->appwin[WINDOW_PROGRAM].window)
  447.             {
  448.                 GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_COPYALL], app->appwin[WINDOW_PROGRAM].window, NULL, GA_Disabled, TRUE, TAG_END);
  449.                 GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_DEL], app->appwin[WINDOW_PROGRAM].window, NULL, GA_Disabled, TRUE, TAG_END);
  450.                 GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LOAD], app->appwin[WINDOW_PROGRAM].window, NULL, GA_Disabled, TRUE, TAG_END);
  451.                 GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_SAVE], app->appwin[WINDOW_PROGRAM].window, NULL, GA_Disabled, TRUE, TAG_END);
  452.             }
  453.             if (app->appwin[WINDOW_AB].window)
  454.             {
  455.                 cdstr->a_adr = cdstr->b_adr = NULL;
  456.                 cdstr->a_track = cdstr->b_track = 0;
  457.                 DoABBuffer(app);
  458.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, TRUE, TAG_END);
  459.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, TRUE, TAG_END);
  460.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TRACK], app->appwin[WINDOW_AB].window, NULL, GTIN_Number, cdstr->a_track, GA_Disabled, TRUE, TAG_END);
  461.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TRACK], app->appwin[WINDOW_AB].window, NULL, GTIN_Number, cdstr->b_track, GA_Disabled, TRUE, TAG_END);
  462.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TIME], app->appwin[WINDOW_AB].window, NULL, GTST_String, cdstr->buf_ab_time_a, GA_Disabled, TRUE, TAG_END);
  463.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TIME], app->appwin[WINDOW_AB].window, NULL, GTST_String, cdstr->buf_ab_time_b, GA_Disabled, TRUE, TAG_END);
  464.             }
  465.             if (app->appwin[WINDOW_SAVEAUDIO].window)
  466.             {
  467.                 GT_SetGadgetAttrs(app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_SIZE], app->appwin[WINDOW_SAVEAUDIO].window, NULL, GA_Disabled, TRUE, TAG_END);
  468.                 GT_SetGadgetAttrs(app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_SAVE], app->appwin[WINDOW_SAVEAUDIO].window, NULL, GA_Disabled, TRUE, TAG_END);
  469.                 /* Wichtig ist, daß das hier nach den Funktionen für's A-B-Repeat-Fenster aufgerufen wird */
  470.                 DoSizeBuffer(app);
  471.             }
  472.             break;
  473.  
  474.         case AUDIO_STAT_PLAYING:
  475.             if (app->appwin[WINDOW_MAIN].window)
  476.             {
  477.                 if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW])
  478.                     GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, cdstr->tracknames[cdstr->cur_track - 1], TAG_END);
  479.                 if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSLIDER])
  480.                     GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSLIDER], app->appwin[WINDOW_MAIN].window, NULL, GA_Disabled, FALSE, TAG_END);
  481.                 if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_STOP])
  482.                     OnGadget(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_STOP], app->appwin[WINDOW_MAIN].window, NULL);
  483.             }
  484.             if (app->appwin[WINDOW_TITLES].window)
  485.             {
  486.                 if (app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW])
  487.                     GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Selected, GetNodeNumber(cdstr->playlist[cdstr->playmode], (struct Node *)cdstr->currentlyplayed), TAG_END);
  488.             }
  489.             if (app->appwin[WINDOW_AB].window)
  490.             {
  491.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, FALSE, TAG_END);
  492.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, FALSE, TAG_END);
  493.             }
  494.             break;
  495.  
  496.         case AUDIO_STAT_PAUSED:
  497.             if (app->appwin[WINDOW_MAIN].window)
  498.             {
  499.                 if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW])
  500.                     GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, cdstr->tracknames[cdstr->cur_track - 1], TAG_END);
  501.  
  502.                 if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSLIDER])
  503.                     GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSLIDER], app->appwin[WINDOW_MAIN].window, NULL, GA_Disabled, FALSE, TAG_END);
  504.                 if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_STOP])
  505.                     OnGadget(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_STOP], app->appwin[WINDOW_MAIN].window, NULL);
  506.             }
  507.             if (app->appwin[WINDOW_TITLES].window)
  508.             {
  509.                 if (app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW])
  510.                     GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Selected, GetNodeNumber(cdstr->playlist[cdstr->playmode], (struct Node *)cdstr->currentlyplayed), TAG_END);
  511.             }
  512.             if (app->appwin[WINDOW_AB].window)
  513.             {
  514.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, FALSE, TAG_END);
  515.                 GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, FALSE, TAG_END);
  516.             }
  517.             break;
  518.  
  519.         case AUDIO_STAT_STOPPED:
  520.             if (lastactive != AUDIO_STAT_NO_DISK)
  521.             {
  522.                 CDStopA(cdstr->cdx);
  523.                 cdstr->currentlyplayed = NULL;
  524.  
  525.                 if (app->appwin[WINDOW_MAIN].window)
  526.                 {
  527.                     if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW])
  528.                         GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, NULL, TAG_END);
  529.                     if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_STOP])
  530.                         OffGadget(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_STOP], app->appwin[WINDOW_MAIN].window, NULL);
  531.                     if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSLIDER])
  532.                         GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSLIDER], app->appwin[WINDOW_MAIN].window, NULL, GA_Disabled, TRUE, TAG_END);
  533.                 }
  534.                 if (app->appwin[WINDOW_TITLES].window)
  535.                 {
  536.                     if (app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW])
  537.                         GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Selected, 0xFFFF, TAG_END);
  538.                 }
  539.                 if (app->appwin[WINDOW_AB].window)
  540.                 {
  541.                     GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, TRUE, TAG_END);
  542.                     GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B], app->appwin[WINDOW_AB].window, NULL, GA_Disabled, TRUE, TAG_END);
  543.                 }
  544.             }
  545.             break;
  546.     }
  547. }
  548. void UpdateTimePercent(struct Application *app, int val)
  549. {
  550.     app->cdstr->time_percentage = val;
  551.     /* ggf. Trackslider ändern */
  552.     if (app->appwin[WINDOW_MAIN].window && app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSLIDER])
  553.     {
  554.         GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSLIDER], app->appwin[WINDOW_MAIN].window, NULL, GTSL_Level, app->cdstr->time_percentage, TAG_END);
  555.     }
  556. }
  557. void UpdateTimeGadget(struct Application *app)
  558. {
  559.     /* Time-Gad aktualisieren */
  560.     app->cdstr->time_curseconds = app->cdstr->cdx->cdx_CurrentAbsAddr / 75;
  561.  
  562.     if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TIMESHOW])
  563.     {
  564.         DoTimeBuffer(app);
  565.         GT_SetGadgetAttrs(app->appwin->gadget[GADGET_MAIN_TIMESHOW], app->appwin->window, NULL, GTTX_Text, app->timeshowbuf, TAG_END);
  566.     }
  567. }
  568. void UpdateUnitLUN(struct Application *app)
  569. {
  570.     struct AppWin *appwin = &app->appwin[WINDOW_VOLUME];
  571.     struct CDxRequest *cdx = app->cdstr->cdx;
  572.  
  573.     /* Unit oder LUN geändert */
  574.     app->cdstr->unit = cdx->cdx_Unit;
  575.     app->cdstr->lun = cdx->cdx_LUN;
  576.     if (app->appwin[WINDOW_DRIVEINFO].window)
  577.         MakeInterior(app, WINDOW_DRIVEINFO);
  578.  
  579.     /* CD entfernt vorgaukeln, damit alle Puffer wieder freigegeben werden */
  580.     cdx->cdx_Active = AUDIO_STAT_NO_DISK;
  581.     UpdateGadgets(app);
  582.  
  583.     /* neuen, realen Status aktualisieren */
  584.     CDUpdateA(cdx);
  585.     UpdateGadgets(app);
  586.  
  587.     /* Volume-Fenster aktualisieren, ist nicht in MakeInterior, da es nur hier gebraucht wird */
  588.     if (appwin->window)
  589.     {
  590.         GT_SetGadgetAttrs(appwin->gadget[GADGET_VOLUME_LEFT], appwin->window, NULL, GTSL_Level, cdx->cdx_Volume[0], TAG_END);
  591.         GT_SetGadgetAttrs(appwin->gadget[GADGET_VOLUME_MASTER], appwin->window, NULL, GTSL_Level, (cdx->cdx_Volume[0]+cdx->cdx_Volume[1])/2, TAG_END);
  592.         GT_SetGadgetAttrs(appwin->gadget[GADGET_VOLUME_RIGHT], appwin->window, NULL, GTSL_Level, cdx->cdx_Volume[1], TAG_END);
  593.     }
  594. }
  595. void TestABRepeat(struct Application *app)
  596. {
  597.     /* Test für A-B-Repeat */
  598.     if ((app->cdstr->repeatmode == REPEATMODE_REPAB) && (app->cdstr->active == AUDIO_STAT_PLAYING))
  599.     {
  600.         /* Prüfen, ob a >= Anfang ist, ansonsten Absturz! */
  601.         if ((app->cdstr->a_track > 0) && (app->cdstr->a_adr >= app->cdstr->cdx->cdx_TOCData->FirstAudioAddress))
  602.         {
  603.             /* Prüfen, ob a < b ist */
  604.             if (app->cdstr->a_adr < app->cdstr->b_adr)
  605.             {
  606.                 /* Prüfen, ob sich ACDPlay außerhalb des A-B-Bereichs befindet */
  607.                 if ((app->cdstr->cdx->cdx_CurrentAbsAddr < app->cdstr->a_adr) || (app->cdstr->b_adr < app->cdstr->cdx->cdx_CurrentAbsAddr))
  608.                 {
  609.                     CDJumpA(app->cdstr->cdx, app->cdstr->a_adr, JUMPMODE_PLAY_ABS);
  610.                     CDUpdateA(app->cdstr->cdx);
  611.                     UpdateGadgets(app);
  612.                 }
  613.             }
  614.         }
  615.     }
  616. }
  617.  
  618. void UpdateWinTitle(Application *app)
  619. {
  620.     int i = 0;
  621.  
  622.     if (app->appwin[WINDOW_MAIN].window)
  623.     {
  624.         SetWindowTitles(app->appwin[WINDOW_MAIN].window, "", (UBYTE *) -1);
  625.         switch (app->cdstr->active)
  626.         {
  627.             case AUDIO_STAT_NO_DISK:
  628.                 strncpy(app->winmaintitlebuf, ls[MSG_CDTITLE_NOCD], 50);
  629.                 break;
  630.             case AUDIO_STAT_PLAYING:
  631.                 strncpy(app->winmaintitlebuf, ls[MSG_CDTITLE_PLAYING], 50);
  632.                 break;
  633.             case AUDIO_STAT_PAUSED:
  634.                 strncpy(app->winmaintitlebuf, ls[MSG_CDTITLE_PAUSE], 50);
  635.                 break;
  636.             case AUDIO_STAT_STOPPED:
  637.                 strncpy(app->winmaintitlebuf, ls[MSG_CDTITLE_CD], 50);
  638.                 break;
  639.         }
  640.         if ((app->cdstr->active != AUDIO_STAT_NO_DISK) && (app->flag_tool & FLAG_TOOL_USEWINDOWBAR))
  641.         {
  642.             strcat(app->winmaintitlebuf, " [");
  643.             strncat(app->winmaintitlebuf, app->cdstr->cdname, MAXCDNAME);
  644.             strcat(app->winmaintitlebuf, "]");
  645.         }
  646.         SetWindowTitles(app->appwin[WINDOW_MAIN].window, app->winmaintitlebuf, (UBYTE *) -1);
  647.     }
  648.  
  649.     if (app->appwin[WINDOW_TITLES].window)
  650.         SetWindowTitles(app->appwin[WINDOW_TITLES].window, "", (UBYTE *) -1);
  651.  
  652.     if ((app->appwin[WINDOW_TITLES].window) || (app->flag_tool & FLAG_TOOL_USESCREENBAR))
  653.     {
  654.         if (app->cdstr->active == AUDIO_STAT_NO_DISK)
  655.             strncpy(app->wintitlestitlebuf, ls[MSG_CDTITLE_NOCD], 50);
  656.         else
  657.         {
  658.             strncpy(app->wintitlestitlebuf, app->cdstr->cdname, MAXCDNAME);
  659.             strcat(app->wintitlestitlebuf, " · ");
  660.             strncat(app->wintitlestitlebuf, app->cdstr->artistname, MAXARTISTNAME);
  661.         }
  662.     }
  663.  
  664.     if (app->appwin[WINDOW_TITLES].window)
  665.         SetWindowTitles(app->appwin[WINDOW_TITLES].window, app->wintitlestitlebuf, (UBYTE *) -1);
  666.  
  667.     /* Screenbar benutzen */
  668.     if (app->flag_tool & FLAG_TOOL_USESCREENBAR)
  669.     {
  670.         for (i = 0; i < ANZ_WINDOWS; i++)
  671.         {
  672.             if (app->appwin[i].window)
  673.                 SetWindowTitles(app->appwin[i].window, (UBYTE *) -1, app->wintitlestitlebuf);
  674.         }
  675.     }
  676. }
  677. BOOL UpdateCDTitles(Application *app)
  678. {
  679.     BOOL success = TRUE;
  680.     register struct CDStruct *cdstr = app->cdstr;
  681.     struct PlayListNode *tempnode;
  682.     char **tracknames = NULL;
  683.     int i;
  684.  
  685.     /*** Also, Mak, ich hab' einen Teil des Gadgetkrams aus UpdateStatus() hierher verlagert,
  686.          weil ein ACDPlay-Benutzer unbedingt UPDATETITLES als ARexx-Kommando brauchte und
  687.          ich wollte, daß das gleich aktualisiert wird ... ***/
  688.  
  689.     /* Erstmal die Listen aus den Listviews nehmen */
  690.     if (app->appwin[WINDOW_TITLES].window)
  691.         GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Labels, ~0, TAG_END);
  692.     if (app->appwin[WINDOW_EDIT].window)
  693.         GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Labels, ~0, TAG_END);
  694.     if (app->appwin[WINDOW_PROGRAM].window)
  695.     {
  696.         GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVCD], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, ~0, TAG_END);
  697.         GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVPRG], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, ~0, TAG_END);
  698.     }
  699.  
  700.     /* und dann ein paar Gadgets freigeben, weils systemkonformer ist */
  701.     if (app->appwin[WINDOW_CDINFO].window)
  702.     {
  703.         GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_AUTHOR], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, NULL, TAG_END);
  704.         GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TITLE], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, NULL, TAG_END);
  705.     }
  706.     if (app->appwin[WINDOW_MAIN].window && app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW])
  707.         GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, NULL, TAG_END);
  708.  
  709.     FreeList(cdstr->playlist[PLAYLIST_CD]);
  710.     cdstr->playlist[PLAYLIST_CD] = NULL;
  711.  
  712.     /* Neue Listen müssen auf jeden Fall erzeugt werden */
  713.     if (cdstr->playlist[PLAYLIST_CD] = GetVecA(sizeof(struct List), MEMF_PUBLIC | MEMF_CLEAR))
  714.         NewList(cdstr->playlist[PLAYLIST_CD]);
  715.     else
  716.         return (FALSE);
  717.  
  718.     CDUpdateA(cdstr->cdx);
  719.     cdstr->active = cdstr->cdx->cdx_Active;
  720.  
  721.     switch(cdstr->active)
  722.     {
  723.         case AUDIO_STAT_NO_DISK:
  724.             /* Name und Interpreten-Strings 'leeren' */
  725.             cdstr->cdname[0] = 0;        /* Nullzeichen am Anfang */
  726.             cdstr->artistname[0] = 0;
  727.             /* Listen bleiben leer */
  728.  
  729.             /* currentlyplayed auf NULL setzen */
  730.             cdstr->currentlyplayed = NULL;
  731.  
  732.             /* Programm-LV leeren */
  733.             if (app->appwin[WINDOW_PROGRAM].window)
  734.                 GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVPRG], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, ~0, TAG_END);
  735.             FreeList(cdstr->playlist[PLAYLIST_PROGRAM]);
  736.             cdstr->playlist[PLAYLIST_PROGRAM] = NULL;
  737.             if (cdstr->playlist[PLAYLIST_PROGRAM] = GetVecA(sizeof(struct List), MEMF_PUBLIC | MEMF_CLEAR))
  738.                 NewList(cdstr->playlist[PLAYLIST_PROGRAM]);
  739.             else
  740.                 success = FALSE;
  741.             if (app->appwin[WINDOW_PROGRAM].window)
  742.                 GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVPRG], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_PROGRAM], TAG_END);
  743.  
  744.             break;
  745.  
  746.         case AUDIO_STAT_PLAYING:
  747.         case AUDIO_STAT_PAUSED:
  748.         case AUDIO_STAT_STOPPED:
  749.             {
  750.                 char *wantedname;
  751.                 char *filebuffer;
  752.                 ULONG filelength;
  753.  
  754.                 if (wantedname = GetVecA(strlen(cdstr->diskpath) + 22, MEMF_PUBLIC | MEMF_CLEAR))
  755.                 {
  756.                     strcpy(wantedname, cdstr->diskpath);
  757.                     strcat(wantedname, "ID");
  758.                     strcat(wantedname, cdstr->cdx->cdx_TOCData->CDID);
  759.  
  760.                     if ((filelength = ExamineFileLength(wantedname)) && (filebuffer = OpenFile(wantedname)))
  761.                     {
  762.                         /* Das passiert, wenn die CD-Titel bereits gespeichert */
  763.                         /* waren und die Datei auch gefunden wurde */
  764.  
  765.                         char *actpos = filebuffer;
  766.                         int j;
  767.  
  768.                         /* Name des Interpreten */
  769.                         /* Bei allen Schleifen wird auf LF-Zeichen geachtet und überprüft, ob die
  770.                            Datei schon zuende ist */
  771.                         for (i = 0; (*(actpos) != 0x0A) && (actpos - filebuffer < filelength); i++, actpos++)
  772.                         {
  773.                             if (i >= MAXARTISTNAME)
  774.                             {
  775.                                 while ((*(actpos) != 0x0A) && (actpos - filebuffer < filelength))
  776.                                     actpos++;
  777.                                 break;
  778.                             }
  779.                             cdstr->artistname[i] = *(actpos);
  780.                         }
  781.                         cdstr->artistname[i] = 0;
  782.                         actpos++;
  783.                         /* Falls der Interpret gar nicht ausgefüllt wurde, wird der Standardtitel genommen */
  784.                         if (!strlen(cdstr->artistname))
  785.                             strncpy(cdstr->artistname, ls[MSG_CDTITLE_UNKNOWNARTIST], MAXARTISTNAME);
  786.  
  787.                         /* CD-Name */
  788.                         for (i = 0; (*(actpos) != 0x0A) && (actpos - filebuffer < filelength); i++, actpos++)
  789.                         {
  790.                             if (i >= MAXCDNAME)
  791.                             {
  792.                                 while ((*(actpos) != 0x0A) && (actpos - filebuffer < filelength))
  793.                                     actpos++;
  794.                                 break;
  795.                             }
  796.                             cdstr->cdname[i] = *(actpos);
  797.                         }
  798.                         cdstr->cdname[i] = 0;
  799.                         actpos++;
  800.                         /* Falls kein Name eingetragen wurde, Standardname */
  801.                         if (!strlen(cdstr->cdname))
  802.                             strncpy(cdstr->cdname, ls[MSG_CDTITLE_UNKNOWNCD], MAXCDNAME);
  803.  
  804.                         /* Alle Titel */
  805.                         if (tracknames = GetVecA((cdstr->num_track + 1) * sizeof(char *), MEMF_PUBLIC))
  806.                         {
  807.                             for (i = 0; i < cdstr->num_track; i++)
  808.                             {
  809.                                 if (tracknames[i] = GetVecA(MAXTITLENAME + 1, MEMF_PUBLIC | MEMF_CLEAR))
  810.                                 {
  811.                                     for (j = 0; (*(actpos) != 0x0A) && (actpos - filebuffer < filelength); j++, actpos++)
  812.                                     {
  813.                                         if (i >= MAXTITLENAME)
  814.                                         {
  815.                                             while ((*(actpos) != 0x0A) && (actpos - filebuffer < filelength))
  816.                                                 actpos++;
  817.                                             break;
  818.                                         }
  819.                                         tracknames[i][j] = *(actpos);
  820.                                     }
  821.                                     tracknames[i][j] = 0;
  822.                                     actpos++;
  823.  
  824.                                     /* Falls kein Titel eingetragen wurde, Standardtitel */
  825.                                     if (!strlen(tracknames[i]))
  826.                                     {
  827.                                         strncpy(tracknames[i], ls[MSG_CDTITLE_TRACK], MAXTITLENAME - 5);
  828.                                         strcat(tracknames[i], " #");
  829.                                         inttostr(i + 1, tracknames[i] + strlen(tracknames[i]), 10);
  830.                                     }
  831.                                 }
  832.                                 else
  833.                                     success = FALSE;
  834.                             }
  835.                             tracknames[cdstr->num_track] = NULL;    /* als Endemarkierung */
  836.                         }
  837.                         FreeVec(filebuffer);
  838.                     }
  839.                     else
  840.                     {
  841.                         /* Hier werden Default-Titel benutzt, wenn noch nichts */
  842.                         /* gespeichert war oder die Datei nicht gefunden wurde */
  843.                         /* oder sonstwas */
  844.  
  845.                         /* Name und Interpreten-Strings setzen */
  846.                         strncpy(cdstr->cdname, ls[MSG_CDTITLE_UNKNOWNCD], MAXCDNAME);
  847.                         strncpy(cdstr->artistname, ls[MSG_CDTITLE_UNKNOWNARTIST], MAXARTISTNAME);
  848.  
  849.                         if (tracknames = GetVecA((cdstr->num_track + 1) * sizeof(char *), MEMF_PUBLIC))
  850.                         {
  851.                             for (i = 0; i < cdstr->num_track; i++)
  852.                             {
  853.                                 if (tracknames[i] = GetVecA(MAXTITLENAME + 1, MEMF_PUBLIC | MEMF_CLEAR))
  854.                                 {
  855.                                     strncpy(tracknames[i], ls[MSG_CDTITLE_TRACK], MAXTITLENAME - 5);
  856.                                     strcat(tracknames[i], " #");
  857.                                     inttostr(i + 1, tracknames[i] + strlen(tracknames[i]), 10);
  858.                                 }
  859.                                 else
  860.                                     success = FALSE;
  861.                             }
  862.                             tracknames[cdstr->num_track] = NULL;
  863.                         }
  864.                         FreeVec(wantedname);
  865.                     }
  866.  
  867.                     /* Die Standard-PlayList erstellen */
  868.                     for (i = 0; i < cdstr->num_track; i++)
  869.                     {
  870.                         if (tempnode = GetVecA(sizeof(struct PlayListNode), MEMF_PUBLIC | MEMF_CLEAR))
  871.                         {
  872.                             tempnode->pln_Node.ln_Name = tracknames[i];
  873.                             tempnode->pln_track = i + 1;
  874.                             AddTail(cdstr->playlist[PLAYLIST_CD], (struct Node *)tempnode);
  875.                         }
  876.                     }
  877.                 }
  878.             }
  879.             break;
  880.     }
  881.  
  882.     /* Hier erst werden die Titel gelöscht und ggf. ersetzt */
  883.     for (i = 0; cdstr->tracknames[i]; i++)
  884.         FreeVec(cdstr->tracknames[i]);
  885.  
  886.     FreeVec(cdstr->tracknames);
  887.     cdstr->tracknames = tracknames;
  888.  
  889.     /* Ich muß die Stringpointer in den einzelnen Program-Nodes leider alle hier
  890.        schon ändern, was wie gesagt letztendlich an UPDATETITLES (ARexx) liegt */
  891.     if (!IsListEmpty(cdstr->playlist[PLAYLIST_PROGRAM]))
  892.     {
  893.         for (tempnode = ((struct PlayListNode *)cdstr->playlist[PLAYLIST_PROGRAM]->lh_Head); tempnode->pln_Node.ln_Succ; tempnode = (struct PlayListNode *)tempnode->pln_Node.ln_Succ)
  894.         {
  895.             tempnode->pln_Node.ln_Name = cdstr->tracknames[tempnode->pln_track - 1];
  896.         }
  897.     }
  898.  
  899.     /* Listen einbauen */
  900.     if (app->appwin[WINDOW_TITLES].window)
  901.         GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Labels, cdstr->playlist[cdstr->playmode], TAG_END);
  902.     if (app->appwin[WINDOW_EDIT].window)
  903.         GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_CD], TAG_END);
  904.     if (app->appwin[WINDOW_PROGRAM].window)
  905.     {
  906.         GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVCD], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_CD], TAG_END);
  907.         GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVPRG], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_PROGRAM], TAG_END);
  908.     }
  909.  
  910.     /* Gadgets updaten */
  911.     if (app->appwin[WINDOW_CDINFO].window)
  912.     {
  913.         GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_AUTHOR], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, cdstr->artistname, TAG_END);
  914.         GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TITLE], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, cdstr->cdname, TAG_END);
  915.     }
  916.     if (app->appwin[WINDOW_EDIT].window)
  917.     {
  918.         GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TITLE], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, cdstr->cdname, GA_Disabled, FALSE, TAG_END);
  919.         GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_ARTIST], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, cdstr->artistname, GA_Disabled, FALSE, TAG_END);
  920.     }
  921.     if (app->appwin[WINDOW_MAIN].window && app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW])
  922.         GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, cdstr->tracknames[cdstr->cur_track - 1], TAG_END);
  923.  
  924.     /* Window-Titel updaten */
  925.     UpdateWinTitle(app);
  926.  
  927.     return (success);
  928. }
  929.  
  930. void ChangeButtonText(Application *app, WORD win, WORD button, char *newtext)
  931. {
  932.     if (app->appwin[win].window)
  933.     {
  934.         if (app->appwin[win].gadget[button])
  935.         {
  936.             static struct NewGadget newgad;
  937.             static struct Gadget *glist = NULL;
  938.             static struct Gadget *gad;
  939.  
  940.             RemoveGadget(app->appwin[win].window, app->appwin[win].gadget[button]);
  941.  
  942.             /* Jetzt ist die Gadgetstruktur noch nicht freigegeben */
  943.             newgad.ng_LeftEdge        = app->appwin[win].gadget[button]->LeftEdge;
  944.             newgad.ng_TopEdge        = app->appwin[win].gadget[button]->TopEdge;
  945.             newgad.ng_Width            = app->appwin[win].gadget[button]->Width;
  946.             newgad.ng_Height        = app->appwin[win].gadget[button]->Height;
  947.             newgad.ng_GadgetText    = newtext;
  948.             newgad.ng_TextAttr        = app->font;
  949.             newgad.ng_GadgetID        = button;
  950.             newgad.ng_VisualInfo    = app->visualinfo;
  951.  
  952.             /* setzt voraus, daß ein Buttongadget aus nur einem Gadget besteht */
  953.             app->appwin[win].gadget[button]->NextGadget = NULL;
  954.             FreeGadgets(app->appwin[win].gadget[button]);
  955.  
  956.             gad = CreateContext(&glist);
  957.             app->appwin[win].gadget[button] = CreateGadget(BUTTON_KIND, gad, &newgad, TAG_END);
  958.  
  959.             /* wieder was freigeben */
  960.             gad->NextGadget = NULL;
  961.             FreeGadgets(gad);
  962.  
  963.             AddGadget(app->appwin[win].window, app->appwin[win].gadget[button], button);
  964.             RefreshGList(app->appwin[win].gadget[button], app->appwin[win].window, NULL, 1);
  965.         }
  966.     }
  967. }
  968. void SelectGadget(Application *app, WORD win, WORD gadid, BOOL status)
  969. {
  970.     /* Diese Funktion wird eigentlich nur für das Pause-Gadget benutzt, */
  971.     /* funktioniert aber für jedes handgemachte Toggle-Gadget */
  972.     /* status == TRUE -> selektiert, status == FALSE -> nicht selektiert */
  973.     /* Es wird selbständig überprüft, ob das Window/Gadget existiert */
  974.  
  975.     if (app->appwin[win].window)
  976.     {
  977.         if (app->appwin[win].gadget[gadid])
  978.         {
  979.             RemoveGadget(app->appwin[win].window, app->appwin[win].gadget[gadid]);
  980.  
  981.             if (status)
  982.                 app->appwin[win].gadget[gadid]->Flags |= GFLG_SELECTED;
  983.             else
  984.                 app->appwin[win].gadget[gadid]->Flags &= ~GFLG_SELECTED;
  985.  
  986.             AddGadget(app->appwin[win].window, app->appwin[win].gadget[gadid], gadid);
  987.             RefreshGList(app->appwin[win].gadget[gadid], app->appwin[win].window, NULL, 1);
  988.         }
  989.     }
  990. }
  991.  
  992. UWORD *CreatePanelData(BOOL magicwb, UWORD width, UWORD height)
  993. {
  994.     struct RastPort *rp;
  995.     UBYTE         *paneldata = NULL;
  996.     UWORD          bplwidth;
  997.     UWORD         bitplanes = magicwb ? 3 : 2;
  998.  
  999.     /* width auf das nächste Vielfache von 16 bringen */
  1000.     if (width % 16)
  1001.         bplwidth = (width / 16 + 1) * 16;
  1002.     else
  1003.         bplwidth = width;
  1004.  
  1005.     if (rp = GetVecA(sizeof(struct RastPort), MEMF_CLEAR))
  1006.     {
  1007.         InitRastPort(rp);
  1008.  
  1009.         if (rp->BitMap = GetVecA(sizeof(struct BitMap), MEMF_CLEAR))
  1010.         {
  1011.             LONG    i;
  1012.             BOOL    noerror;
  1013.  
  1014.             InitBitMap(rp->BitMap, bitplanes, bplwidth, height * ANZ_GADGET_PANEL * 2);
  1015.  
  1016.             noerror = TRUE;
  1017.             for (i = 0; i < bitplanes; i++) {
  1018.                 rp->BitMap->Planes[i] = NULL;
  1019.                 if (!(rp->BitMap->Planes[i] = AllocRaster(bplwidth, height * 16)))
  1020.                     noerror = FALSE;
  1021.             }
  1022.  
  1023.             if (noerror)
  1024.             {
  1025.                 int i;
  1026.  
  1027.                 DrawPanelGadgets(magicwb, rp, width, height);
  1028.  
  1029.                 /* Kopieren der Daten, so daß sie zu Images gemacht werden können */
  1030.                 if (paneldata = GetVecA(bplwidth / 8 * height * ANZ_GADGET_PANEL * 2 * bitplanes, MEMF_CLEAR | MEMF_CHIP))
  1031.                 {
  1032.                     int j;
  1033.                     int size = bplwidth / 8 * height;    /* Größe einer Gadgetbitplane */
  1034.  
  1035.                     for (i = 0; i < ANZ_GADGET_PANEL * 2; i++)
  1036.                     {
  1037.                         for (j = 0; j < size; j++)
  1038.                             paneldata[i * bitplanes * size + j] = rp->BitMap->Planes[0][i * size + j];
  1039.                         for (j = 0; j < size; j++)
  1040.                             paneldata[i * bitplanes * size + size + j] = rp->BitMap->Planes[1][i * size + j];
  1041.  
  1042.                         if (magicwb)
  1043.                             for (j = 0; j < size; j++)
  1044.                                 paneldata[i * bitplanes * size + 2 * size + j] = rp->BitMap->Planes[2][i * size + j];
  1045.                     }
  1046.                 }
  1047.             }
  1048.  
  1049.             for (i = bitplanes - 1; i >= 0; i--)
  1050.                 if (rp->BitMap->Planes[i])
  1051.                 {
  1052.                     FreeRaster(rp->BitMap->Planes[i], bplwidth, height * ANZ_GADGET_PANEL * 2);
  1053.                     rp->BitMap->Planes[i] = NULL;
  1054.                 }
  1055.  
  1056.             FreeVec(rp->BitMap);
  1057.         }
  1058.         FreeVec(rp);
  1059.     }
  1060.  
  1061.     return (UWORD *)paneldata;
  1062. }
  1063. void DrawPanelGadgets(BOOL magicwb, struct RastPort *rp, UWORD width, UWORD height)
  1064. {
  1065.     LONG    i;
  1066.     UWORD    bplwidth, temp;
  1067.  
  1068.     UWORD    hspace = width / 5;
  1069.     UWORD    vspace = height / 5;
  1070.  
  1071.     if (width % 8)
  1072.         bplwidth = (width / 8 + 1) * 8;
  1073.     else
  1074.         bplwidth = width;
  1075.  
  1076.     /* Bildschirm löschen */
  1077.     SetBPen(rp, 0);
  1078.     EraseRect(rp, 0, 0, width - 1, height * 16 - 1);
  1079.  
  1080.     /* Zeichnen der Umrandung */
  1081.     for (i = 0; i < ANZ_GADGET_PANEL * 2; i++)
  1082.     {
  1083.         SetAPen(rp, i % 2 ? 1 : 2);
  1084.         Move(rp, width - 2, i * height);
  1085.         Draw(rp, 0, i * height);
  1086.         Draw(rp, 0, (i + 1) * height - 1);
  1087.         Move(rp, 1, i * height);
  1088.         Draw(rp, 1, (i + 1) * height - 2);
  1089.  
  1090.         SetAPen(rp, i % 2 ? 2 : 1);
  1091.         Move(rp, width - 1, i * height);
  1092.         Draw(rp, width - 1, (i + 1) * height - 1);
  1093.         Draw(rp, 1, (i + 1) * height - 1);
  1094.         Move(rp, width - 2, (i + 1) * height - 1);
  1095.         Draw(rp, width - 2, i * height + 1);
  1096.     }
  1097.  
  1098.     SetAPen(rp, 1);        /* schwarz */
  1099.     SetDrPt(rp, ~0);
  1100.     SetOPen(rp, 1);
  1101.  
  1102.     /* Eject-Button */
  1103.     temp = height - 3 - vspace - 2 * height / 10;
  1104.     Triangle(rp, 3 + hspace, temp, width / 2, 2 + vspace, width - 4 - hspace, temp);
  1105.     Flood(rp, 0, width / 2, temp - 1);
  1106.     RectFill(rp, 3 + hspace, height - 3 - vspace - height / 10, width - 4 - hspace, height - 3 - vspace);
  1107.  
  1108.     /* Jump-Backward-Button */
  1109.     Triangle(rp, width - 4 - hspace, 2 * height + 2 + vspace, width - 4 - 2 * hspace, 2 * height + height / 2, width - 4 - hspace, 3 * height - 3 - vspace);
  1110.     Flood(rp, 0, width - 5 - hspace, 2 * height + height / 2);
  1111.     Triangle(rp, width - 4 - 2 * hspace, 2 * height + 2 + vspace, width - 4 - 3 * hspace, 2 * height + height / 2, width - 4 - 2 * hspace, 3 * height - 3 - vspace);
  1112.     Flood(rp, 0, width - 5 - 2 * hspace, 2 * height + height / 2);
  1113.     /* Search-Backward-Button */
  1114.     ClipBlit(rp, 3, 2 * height + 2, rp, 3, 6 * height + 2, width - 6, height - 4, ABNC | ABC);
  1115.     /* Jump-Backward-Button */
  1116.     RectFill(rp, 3 + hspace, 2 * height + 2 + vspace, width - 4 - 3 * hspace, 3 * height - 3 - vspace);
  1117.  
  1118.     /* Jump-Forward-Button */
  1119.     Triangle(rp, 3 + hspace, 4 * height + 2 + vspace, 3 + 2 * hspace, 4 * height + height / 2, 3 + hspace, 5 * height - 3 - vspace);
  1120.     Flood(rp, 0, 4 + hspace, 4 * height + height / 2);
  1121.     Triangle(rp, 3 + 2 * hspace, 4 * height + 2 + vspace, 3 + 3 * hspace, 4 * height + height / 2, 3 + 2 * hspace, 5 * height - 3 - vspace);
  1122.     Flood(rp, 0, 4 + 2 * hspace, 4 * height + height / 2);
  1123.     /* Search-Forward-Button */
  1124.     ClipBlit(rp, 3, 4 * height + 2, rp, 3, 8 * height + 2, width - 6, height - 4, ABNC | ABC);
  1125.     /* Jump-Forward-Button */
  1126.     RectFill(rp, 3 + 3 * hspace, 4 * height + 2 + vspace, width - 4 - hspace, 5 * height - 3 - vspace);
  1127.  
  1128.     /* Stop-Button */
  1129.     RectFill(rp, 3 + hspace, 10 * height + 2 + vspace, width - 4 - hspace, 11 * height - 3 - vspace);
  1130.  
  1131.     /* Pause-Button */
  1132.     temp = width / 2 - 2 - width / 40;
  1133.     RectFill(rp, 3 + hspace, 12 * height + 2 + vspace, temp, 13 * height - 3 - vspace);
  1134.     RectFill(rp, width - temp - 1, 12 * height + 2 + vspace, width - 4 - hspace, 13 * height - 3 - vspace);
  1135.  
  1136.     /* Play-Button */
  1137.     Triangle(rp, 3 + hspace, 14 * height + 2 + vspace, width - 4 - hspace, 14 * height + height / 2, 3 + hspace, 15 * height - 3 - vspace);
  1138.     Flood(rp, 0, 4 + hspace, 14 * height + height / 2);
  1139.  
  1140.     for (i = 0; i < 8; i++)
  1141.         ClipBlit(rp, 3, i * 2 * height + 2, rp, 4, (i * 2 + 1) * height + 3, width - 6, height - 4, ABNC | ABC);
  1142. }
  1143. void Triangle(struct RastPort *rp, WORD x1, WORD y1, WORD x2, WORD y2, WORD x3, WORD y3)
  1144. {
  1145.     WORD coords[] = {x1, y1, x2, y2, x3, y3};
  1146.  
  1147.     Move(rp, x3, y3);
  1148.     PolyDraw(rp, 3, coords);
  1149. }
  1150.  
  1151. BOOL MakeVisuals(Application *app, WORD win)
  1152. {
  1153.     BOOL             success = FALSE;
  1154.     struct NewGadget     newgad     = {0};
  1155.     Gadget             *gad;
  1156.  
  1157.     static char         colon[] = ":";
  1158.     static char        leave[] = "";
  1159.  
  1160.     int             widest     = 0;
  1161.  
  1162.     /* Diese Attribute sind für alle Gadgets gleich */
  1163.     newgad.ng_VisualInfo    = app->visualinfo;
  1164.     newgad.ng_TextAttr        = app->font;
  1165.  
  1166.     /* In allen Fenstern sind Gadgets, also: */
  1167.     app->appwin[win].gadgetlist = NULL;
  1168.     gad = CreateContext(&(app->appwin[win].gadgetlist));
  1169.  
  1170.     switch (win)
  1171.     {
  1172.         case WINDOW_MAIN:
  1173.             /*** Gadgets ***/
  1174.             if (app->appwin[WINDOW_MAIN].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_MAIN, MEMF_PUBLIC | MEMF_CLEAR))
  1175.             {
  1176.                                 int temp1, temp2, i;
  1177.  
  1178.                                 static char *TEXT_MAIN_PLAYMODE[5];             /* Wenn ich die Variablen gleich */
  1179.                                 static char *TEXT_MAIN_REPEAT[5];               /* initialisiere, funktioniert's nicht */
  1180.  
  1181.                                 /* Zuerst wird das längste GUI-Element und die Größe des Fensters ermittelt, */
  1182.                                 /* nicht selektierte Elemente werden natürlich nicht berücksichtigt */
  1183.  
  1184.                                 /* Mindestwerte */
  1185.                                 widest = 200;
  1186.                                 app->appwin[WINDOW_MAIN].maxsize[HEIGHT] = YOFFSET + 2;
  1187.  
  1188.                                 if (app->flag_main & FLAG_MAIN_DIRECTCHOICE0)
  1189.                                 {
  1190.                                         temp1 = (FindWidest(TEXT_MAIN_DIRECTCHOICE0, app->font) - TextWidth("_", app->font) + BUTTONSPACE) * 10;
  1191.                                         widest = temp1 > widest ? temp1 : widest;
  1192.                                         app->appwin[WINDOW_MAIN].maxsize[HEIGHT] += BUTTONHEIGHT + INTERHEIGHT;
  1193.                                 }
  1194.                                 if (app->flag_main & FLAG_MAIN_DIRECTCHOICE1)
  1195.                                 {
  1196.                                         temp1 = (FindWidest(TEXT_MAIN_DIRECTCHOICE1, app->font) + BUTTONSPACE) * 10;
  1197.                                         widest = temp1 > widest ? temp1 : widest;
  1198.                                         app->appwin[WINDOW_MAIN].maxsize[HEIGHT] += BUTTONHEIGHT + INTERHEIGHT;
  1199.                                 }
  1200.                                 if (app->flag_main & FLAG_MAIN_TITLE)
  1201.                                         app->appwin[WINDOW_MAIN].maxsize[HEIGHT] += BUTTONHEIGHT + INTERHEIGHT;
  1202.                                 if (app->flag_main & FLAG_MAIN_TIME)
  1203.                                 {
  1204.                                         temp1 = TextWidth(ls[MSG_MAIN_INDEX], app->font) + TextWidth(ls[MSG_MAIN_TRACK], app->font) + 2 * TextWidth("99", app->font) + TextWidth("99:99 / 99:99", app->font) + 4 * INTERWIDTH + 3 * BUTTONSPACE;
  1205.                                         widest = temp1 > widest ? temp1 : widest;
  1206.                                         app->appwin[WINDOW_MAIN].maxsize[HEIGHT] += BUTTONHEIGHT + INTERHEIGHT;
  1207.                                 }
  1208.                                 if (app->flag_main & FLAG_MAIN_MODE)
  1209.                                 {
  1210.                                         TEXT_MAIN_PLAYMODE[0] = ls[MSG_MAIN_PM_CD_GAD];
  1211.                                         TEXT_MAIN_PLAYMODE[1] = ls[MSG_MAIN_PM_RNDCD_GAD];
  1212.                                         TEXT_MAIN_PLAYMODE[2] = ls[MSG_MAIN_PM_PRG_GAD];
  1213.                                         TEXT_MAIN_PLAYMODE[3] = ls[MSG_MAIN_PM_RNDPRG_GAD];
  1214.                                         TEXT_MAIN_PLAYMODE[4] = NULL;
  1215.  
  1216.                                         TEXT_MAIN_REPEAT[0] = ls[MSG_MAIN_REP_NOREP_GAD];
  1217.                                         TEXT_MAIN_REPEAT[1] = ls[MSG_MAIN_REP_REPTRACK_GAD];
  1218.                                         TEXT_MAIN_REPEAT[2] = ls[MSG_MAIN_REP_REPALL_GAD];
  1219.                                         TEXT_MAIN_REPEAT[3] = ls[MSG_MAIN_REP_REPAB_GAD];
  1220.                                         TEXT_MAIN_REPEAT[4] = NULL;
  1221.  
  1222.                                         temp1 = FindWidest(TEXT_MAIN_PLAYMODE, app->font);
  1223.                                         temp2 = FindWidest(TEXT_MAIN_REPEAT, app->font);
  1224.                                         temp1 = temp1 > temp2 ? temp1 : temp2;
  1225.                                         temp1 = 2 * temp1 + 2 * BUTTONSPACE + 40;
  1226.                                         widest = temp1 > widest ? temp1 : widest;
  1227.                                         app->appwin[WINDOW_MAIN].maxsize[HEIGHT] += BUTTONHEIGHT + INTERHEIGHT;
  1228.                                 }
  1229.                                 if (app->flag_main & FLAG_MAIN_PANEL)
  1230.                                 {
  1231.                                         temp1 = 8 * app->panelwidth + 2 * INTERWIDTH;
  1232.                                         widest = temp1 > widest ? temp1 : widest;
  1233.                                         app->appwin[WINDOW_MAIN].maxsize[HEIGHT] += app->panelheight + INTERHEIGHT;
  1234.                                 }
  1235.                                 if (app->flag_main & FLAG_MAIN_TRACKSLIDER)
  1236.                                         app->appwin[WINDOW_MAIN].maxsize[HEIGHT] += app->font->ta_YSize + 3 + INTERHEIGHT;
  1237.  
  1238.                                 /* widest ggf. durch 10 teilbar machen */
  1239.                                 if ((app->flag_main & FLAG_MAIN_DIRECTCHOICE0) || (app->flag_main & FLAG_MAIN_DIRECTCHOICE1))
  1240.                                         if (i = (widest % 10)) widest += 10 - i;
  1241.  
  1242.                                 app->appwin[WINDOW_MAIN].minsize[WIDTH] = app->appwin[WINDOW_MAIN].maxsize[WIDTH] = XOFFSET + widest + 8;
  1243.                                 app->appwin[WINDOW_MAIN].minsize[HEIGHT] = app->font->ta_YSize + app->screen->WBorTop + 1;
  1244.  
  1245.                                 if (!app->flag_main)    /* wenn gar keine Flags gesetzt sind */
  1246.                                         app->appwin[WINDOW_MAIN].maxsize[HEIGHT] = app->appwin[WINDOW_MAIN].minsize[HEIGHT];
  1247.  
  1248.  
  1249.                                 /* nun werden die Gadgets selbst erstellt .... */
  1250.                                 /* ........................................... */
  1251.  
  1252.                                 temp2 = YOFFSET;        /* für die y-Pos der Gadgets benutzt */
  1253.  
  1254.                                 if (app->flag_main & FLAG_MAIN_DIRECTCHOICE0)
  1255.                                 {
  1256.                                         newgad.ng_TopEdge       = temp2;
  1257.                                         newgad.ng_Width         = widest / 10;
  1258.                                         newgad.ng_Height        = BUTTONHEIGHT;
  1259.                                         for (i = GADGET_MAIN_DIRECTCHOICE0; i < GADGET_MAIN_DIRECTCHOICE0 + 10; i++)
  1260.                                         {
  1261.                                                 newgad.ng_LeftEdge              = XOFFSET + (i - GADGET_MAIN_DIRECTCHOICE0) * (widest / 10);
  1262.                                                 newgad.ng_GadgetText    = TEXT_MAIN_DIRECTCHOICE0[i - GADGET_MAIN_DIRECTCHOICE0];
  1263.                                                 newgad.ng_GadgetID              = i;
  1264.                                                 app->appwin[WINDOW_MAIN].gadget[i] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GT_Underscore, '_', GA_Disabled, (app->cdstr->num_track <= i - GADGET_MAIN_DIRECTCHOICE0) || (app->cdstr->active == AUDIO_STAT_NO_DISK) ? TRUE : FALSE, TAG_END);
  1265.                                         }
  1266.                                         temp2 += BUTTONHEIGHT + INTERHEIGHT;
  1267.                                 }
  1268.  
  1269.                                 if (app->flag_main & FLAG_MAIN_DIRECTCHOICE1)
  1270.                                 {
  1271.                                         if (app->flag_main & FLAG_MAIN_DIRECTCHOICE0)   /* zwischen beiden Direktwahl- */
  1272.                                         {                                                                                               /* reihen soll kein Abstand sein */
  1273.                                                 temp2 -= INTERHEIGHT;
  1274.                                                 app->appwin[WINDOW_MAIN].maxsize[HEIGHT] -= INTERHEIGHT;
  1275.                                         }
  1276.  
  1277.                                         newgad.ng_TopEdge       = temp2;
  1278.                                         newgad.ng_Width         = widest / 10;
  1279.                                         newgad.ng_Height        = BUTTONHEIGHT;
  1280.                                         for (i = GADGET_MAIN_DIRECTCHOICE1; i < GADGET_MAIN_DIRECTCHOICE1 + 10; i++)
  1281.                                         {
  1282.                                                 newgad.ng_LeftEdge              = XOFFSET + (i - GADGET_MAIN_DIRECTCHOICE1) * (widest / 10);
  1283.                                                 newgad.ng_GadgetText    = TEXT_MAIN_DIRECTCHOICE1[i - GADGET_MAIN_DIRECTCHOICE1];
  1284.                                                 newgad.ng_GadgetID              = i;
  1285.                                                 app->appwin[WINDOW_MAIN].gadget[i] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GA_Disabled, (app->cdstr->num_track <= i - GADGET_MAIN_DIRECTCHOICE0) || (app->cdstr->active == AUDIO_STAT_NO_DISK) ? TRUE : FALSE, TAG_END);
  1286.                                         }
  1287.                                         temp2 += BUTTONHEIGHT + INTERHEIGHT;
  1288.                                 }
  1289.  
  1290.                                 if (app->flag_main & FLAG_MAIN_TITLE)
  1291.                                 {
  1292.                                     i = TextWidth("T", app->font) + BUTTONSPACE;
  1293.  
  1294.                     newgad.ng_LeftEdge        = XOFFSET;
  1295.                     newgad.ng_TopEdge        = temp2;
  1296.                     newgad.ng_Width            = widest - i;
  1297.                     newgad.ng_Height        = BUTTONHEIGHT;
  1298.                     newgad.ng_GadgetText        = NULL;
  1299.                     newgad.ng_GadgetID        = GADGET_MAIN_TITLESHOW;
  1300.                     app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Border, TRUE, TAG_END);
  1301.  
  1302.                     newgad.ng_LeftEdge           += newgad.ng_Width;
  1303.                     newgad.ng_Width            = i;
  1304.                     newgad.ng_GadgetText        = "T";
  1305.                     newgad.ng_GadgetID        = GADGET_MAIN_POPUP;
  1306.                     app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_POPUP] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, TAG_END);
  1307.                     temp2 += BUTTONHEIGHT + INTERHEIGHT;
  1308.                                 }
  1309.  
  1310.                                 if (app->flag_main & FLAG_MAIN_TIME)
  1311.                                 {
  1312.                                         int temp3 = TextWidth("99", app->font);
  1313.                                         int temp4 = TextWidth("99:99 / 99:99", app->font);
  1314.                                         int temp5 = TextWidth(ls[MSG_MAIN_TRACK], app->font);
  1315.                                         int temp6 = TextWidth(ls[MSG_MAIN_INDEX], app->font);
  1316.  
  1317.                                         temp1 = temp5 + temp6 + 2 * temp3 + temp4 + 4 * INTERWIDTH + 3 * BUTTONSPACE;
  1318.  
  1319.                                         newgad.ng_LeftEdge              = XOFFSET + temp5 + INTERWIDTH;
  1320.                                         newgad.ng_TopEdge               = temp2;
  1321.                                         newgad.ng_Width                 = temp3 + BUTTONSPACE + (widest - temp1) / 3;
  1322.                                         newgad.ng_Height                = BUTTONHEIGHT;
  1323.                                         newgad.ng_GadgetText    = ls[MSG_MAIN_TRACK];
  1324.                                         newgad.ng_GadgetID              = GADGET_MAIN_TRACKSHOW;
  1325.                                         app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSHOW] = gad = CreateGadget(NUMBER_KIND, gad, &newgad, GTNM_Border, TRUE, GTNM_Justification, GTJ_CENTER, GTNM_Number, app->cdstr->cdx->cdx_CurrentTrack, TAG_END);
  1326.  
  1327.                                         newgad.ng_LeftEdge         += newgad.ng_Width + INTERWIDTH + temp6 + INTERWIDTH;
  1328.                                         newgad.ng_GadgetText    = ls[MSG_MAIN_INDEX];
  1329.                                         newgad.ng_GadgetID              = GADGET_MAIN_INDEXSHOW;
  1330.                                         app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_INDEXSHOW] = gad = CreateGadget(NUMBER_KIND, gad, &newgad, GTNM_Border, TRUE, GTNM_Justification, GTJ_CENTER, GTNM_Number, app->cdstr->cdx->cdx_CurrentIndex, TAG_END);
  1331.  
  1332.                     newgad.ng_LeftEdge           += newgad.ng_Width + INTERWIDTH;
  1333.                     newgad.ng_Width            = temp4 + BUTTONSPACE + widest - temp1 - (widest - temp1) / 3 * 2;
  1334.                     newgad.ng_GadgetText        = NULL;
  1335.                     newgad.ng_GadgetID        = GADGET_MAIN_TIMESWITCH;
  1336.                     app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TIMESWITCH] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GA_Disabled, app->cdstr->active == AUDIO_STAT_NO_DISK ? TRUE : FALSE, TAG_END);
  1337.  
  1338.                     newgad.ng_LeftEdge           += (newgad.ng_Width - temp4) / 2;
  1339.                     newgad.ng_Width                = temp4;
  1340.                     newgad.ng_GadgetID        = GADGET_MAIN_TIMESHOW;
  1341.                     app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TIMESHOW] = gad = CreateGadget(TEXT_KIND, gad, &newgad, TAG_END);
  1342.                     temp2 += BUTTONHEIGHT + INTERHEIGHT;
  1343.                                 }
  1344.  
  1345.                                 if (app->flag_main & FLAG_MAIN_MODE)
  1346.                                 {
  1347.                                         newgad.ng_LeftEdge              = XOFFSET;
  1348.                                         newgad.ng_TopEdge               = temp2;
  1349.                                         newgad.ng_Width                 = widest / 2;
  1350.                                         newgad.ng_Height                = BUTTONHEIGHT;
  1351.                                         newgad.ng_GadgetText        = NULL;
  1352.                                         newgad.ng_GadgetID              = GADGET_MAIN_PLAYMODE;
  1353.                                         app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_PLAYMODE] = gad = CreateGadget(CYCLE_KIND, gad, &newgad, GTCY_Labels, TEXT_MAIN_PLAYMODE, GA_Disabled, app->cdstr->active == AUDIO_STAT_NO_DISK ? TRUE : FALSE, GTCY_Active, (app->cdstr->playmode == PLAYMODE_PROGRAM ? 2 : 0) | (app->cdstr->playrandom ? 1 : 0), TAG_END);
  1354.  
  1355.                                         newgad.ng_LeftEdge        += widest / 2;
  1356.                                         newgad.ng_Width                 = widest - (widest / 2);
  1357.                                         newgad.ng_GadgetID              = GADGET_MAIN_REPEATMODE;
  1358.                                         app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_REPEATMODE] = gad = CreateGadget(CYCLE_KIND, gad, &newgad, GTCY_Labels, TEXT_MAIN_REPEAT, GA_Disabled, app->cdstr->active == AUDIO_STAT_NO_DISK ? TRUE : FALSE, GTCY_Active, app->cdstr->repeatmode, TAG_END);
  1359.                                         temp2 += BUTTONHEIGHT + INTERHEIGHT;
  1360.                                 }
  1361.  
  1362.                                 if (app->flag_main & FLAG_MAIN_PANEL)
  1363.                                 {
  1364.                                     BOOL    mwb = FALSE;
  1365.  
  1366.                                         /* Testen, ob der Screen >=8 Farben hat. Ggf. mwb-bool einschalten */
  1367.                                         if (((GetScreenDrawInfo(app->screen))->dri_Depth > 2) && app->magicwbmode)
  1368.                         mwb = TRUE;
  1369.  
  1370.                     app->paneldata = CreatePanelData(mwb, app->panelwidth, app->panelheight);
  1371.  
  1372.                                         if (app->appwin[WINDOW_MAIN].img = GetVecA(sizeof(struct Image) * 16, MEMF_PUBLIC | MEMF_CLEAR))
  1373.                                         {
  1374.                                                 for (i = 0; i < 16; i++)
  1375.                                                 {
  1376.                                                         /* Images erstellen */
  1377.                                                         app->appwin[WINDOW_MAIN].img[i].LeftEdge        = 0;
  1378.                                                         app->appwin[WINDOW_MAIN].img[i].TopEdge         = 0;
  1379.                                                         app->appwin[WINDOW_MAIN].img[i].Width           = app->panelwidth;
  1380.                                                         app->appwin[WINDOW_MAIN].img[i].Height          = app->panelheight;
  1381.                                                         app->appwin[WINDOW_MAIN].img[i].Depth           = mwb ? 3 : 2;
  1382.                                                         app->appwin[WINDOW_MAIN].img[i].ImageData       = app->paneldata + (app->panelwidth % 16 ? (app->panelwidth + 16) / 16  : app->panelwidth / 16) * (mwb ? 3 : 2) * i * app->panelheight;
  1383.                                                         app->appwin[WINDOW_MAIN].img[i].PlanePick       = mwb ? 7 : 3;
  1384.                                                         app->appwin[WINDOW_MAIN].img[i].PlaneOnOff      = 0;
  1385.                                                         app->appwin[WINDOW_MAIN].img[i].NextImage       = NULL;
  1386.                                                 }
  1387.  
  1388.                                                 newgad.ng_TopEdge    = temp2;
  1389.                                                 newgad.ng_Width        = app->panelwidth;
  1390.                                                 newgad.ng_Height    = app->panelheight;
  1391.                                                 newgad.ng_GadgetText    = NULL;
  1392.  
  1393.                                                 /* Gadgets erstellen */
  1394.                                                 newgad.ng_LeftEdge              = XOFFSET;
  1395.                                                 newgad.ng_GadgetID              = GADGET_MAIN_CDOUT;
  1396.                                                 gad = CreateGadget(GENERIC_KIND, gad, &newgad, TAG_END);
  1397.                                                 app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_CDOUT] = gad;
  1398.  
  1399.                                                 for (i = GADGET_MAIN_JUMPBWRD; i <= GADGET_MAIN_SRCHFWRD; i++)
  1400.                                                 {
  1401.                                                         newgad.ng_LeftEdge      = XOFFSET + (i - GADGET_MAIN_JUMPBWRD + 1) * app->panelwidth + (widest - 8 * app->panelwidth) / 2;
  1402.                                                         newgad.ng_GadgetID      = i;
  1403.                                                         app->appwin[WINDOW_MAIN].gadget[i] = gad = CreateGadget(GENERIC_KIND, gad, &newgad, TAG_END);
  1404.                                                 }
  1405.                                                 for (i = GADGET_MAIN_STOP; i <= GADGET_MAIN_PLAY; i++)
  1406.                                                 {
  1407.                                                         newgad.ng_LeftEdge      = XOFFSET + (i - GADGET_MAIN_STOP + 5) * app->panelwidth + (widest - 8 * app->panelwidth);
  1408.                                                         newgad.ng_GadgetID      = i;
  1409.                                                         app->appwin[WINDOW_MAIN].gadget[i] = gad = CreateGadget(GENERIC_KIND, gad, &newgad, TAG_END);
  1410.                                                 }
  1411.  
  1412.                                                 /* Flags setzen und Gadgets mit Images verknüpfen */
  1413.                                                 for (i = GADGET_MAIN_CDOUT; i <= GADGET_MAIN_PLAY; i++)
  1414.                                                 {
  1415.                                                         app->appwin[WINDOW_MAIN].gadget[i]->GadgetType  |= GTYP_BOOLGADGET;
  1416.                                                         app->appwin[WINDOW_MAIN].gadget[i]->Flags               |= GFLG_GADGIMAGE | GFLG_GADGHIMAGE;
  1417.                                                         if ((app->cdstr->active == AUDIO_STAT_NO_DISK) && (i != GADGET_MAIN_CDOUT))
  1418.                                                                 app->appwin[WINDOW_MAIN].gadget[i]->Flags       |= GFLG_DISABLED;
  1419.                                                         app->appwin[WINDOW_MAIN].gadget[i]->Activation  |= GACT_RELVERIFY | GACT_IMMEDIATE;
  1420.                                                         app->appwin[WINDOW_MAIN].gadget[i]->GadgetRender = app->appwin[WINDOW_MAIN].img + (i - GADGET_MAIN_CDOUT) * 2;
  1421.                                                         app->appwin[WINDOW_MAIN].gadget[i]->SelectRender = app->appwin[WINDOW_MAIN].img + ((i - GADGET_MAIN_CDOUT) * 2) + 1;
  1422.                                                 }
  1423.  
  1424.                                                 /* Stop-Gad im Stopped-Modus disablen */
  1425.                                                 if (app->cdstr->active == AUDIO_STAT_STOPPED)
  1426.                                                         app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_STOP]->Flags        |= GFLG_DISABLED;
  1427.                                                 /* Pause soll ein Toggle-Gadget sein */
  1428.                                                 app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_PAUSE]->Activation |= GACT_TOGGLESELECT;
  1429.                                                 /* ggf. Gadget drücken */
  1430.                                                 if (app->cdstr->active == AUDIO_STAT_PAUSED)
  1431.                                                         app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_PAUSE]->Flags |= GFLG_SELECTED;
  1432.                                         }
  1433.                                         temp2 += app->panelheight + INTERHEIGHT;
  1434.                                 }
  1435.  
  1436.                                 if (app->flag_main & FLAG_MAIN_TRACKSLIDER)
  1437.                                 {
  1438.                                         app->cdstr->time_percentage = app->cdstr->cdx->cdx_TrackLength ? (int) (((double) 100 / (double)app->cdstr->cdx->cdx_TrackLength) * app->cdstr->cdx->cdx_CurrentRelAddr) : 0;
  1439.  
  1440.                                         newgad.ng_LeftEdge              = XOFFSET;
  1441.                                         newgad.ng_TopEdge               = temp2;
  1442.                                         newgad.ng_Width                 = widest;
  1443.                                         newgad.ng_Height                = app->font->ta_YSize + 3;
  1444.                                         newgad.ng_GadgetText    = NULL;
  1445.                                         newgad.ng_GadgetID              = GADGET_MAIN_TRACKSLIDER;
  1446.                                         app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TRACKSLIDER] = gad = CreateGadget(SLIDER_KIND, gad, &newgad, GTSL_Min, 0, GTSL_Max, 99, GTSL_Level, app->cdstr->time_percentage, PGA_Freedom, LORIENT_HORIZ, GA_RelVerify, TRUE, GA_Disabled, (app->cdstr->active == AUDIO_STAT_NO_DISK) || (app->cdstr->active == AUDIO_STAT_STOPPED) ? TRUE : FALSE, TAG_END);
  1447.                                 }
  1448.  
  1449.                                 success = TRUE;
  1450.             }
  1451.             break;
  1452.  
  1453.         case WINDOW_ABOUT:
  1454.             /*** Intuitexte ***/
  1455.             if (app->appwin[WINDOW_ABOUT].itext = GetVecA(sizeof(struct IntuiText) * 4, MEMF_PUBLIC | MEMF_CLEAR))
  1456.             {
  1457.                 #include "ACDP_Logo.c"    /* Leider schon hier wegen der Konstanten */
  1458.                 int i, temp1;
  1459.  
  1460.                 char *stext[] = {    ls[MSG_ABOUT_MAINPROGRAMMING],
  1461.                                     leave,
  1462.                                     "Marc Altmann",
  1463.                                     "Martin Kresse",
  1464.                                     leave,
  1465.                                     ls[MSG_ABOUT_SCSIPROGRAMMING],
  1466.                                     leave,
  1467.                                     "Martin Kresse",
  1468.                                     leave,
  1469.                                     ls[MSG_ABOUT_TRANSLATEDBY],
  1470.                                     leave,
  1471.                                     ls[MSG_ABOUT_TRANSLATOR],
  1472.                                     leave,
  1473.                                     ls[MSG_ABOUT_PROOFREADBY],
  1474.                                     leave,
  1475.                                     ls[MSG_ABOUT_PROOFREADER],
  1476.                                     leave,
  1477.                                     ls[MSG_ABOUT_BETATESTERS],
  1478.                                     leave,
  1479.                                     "Marc Albrecht",
  1480.                                     "Gregory Donner",
  1481.                                     "Marc Doumayrou",
  1482.                                     "Ole Friis",
  1483.                                     "Siegfried Fröhlich",
  1484.                                     "Sigurbjörn B. Lárusson",
  1485.                                     "Jeroen Massar",
  1486.                                     "Eivind Olsen",
  1487.                                     "Rolf Rotvel",
  1488.                                     "Bert Schulzki",
  1489.                                     "Dirk Tietke",
  1490.                                     "Rino van Wijngaarden",
  1491.                                     leave,
  1492.                                     ls[MSG_ABOUT_THANKS],
  1493.                                     leave,
  1494.                                     "Alexander Altmann",
  1495.                                     "Patrick Hess",
  1496.                                     "Stefan Schupp",
  1497.                                     leave,
  1498.                                     ls[MSG_ABOUT_SUPPORT],
  1499.                                     leave,
  1500.                                     "mcthree@berlin.snafu.de",
  1501.                                     "mak@atp.dame.de",
  1502.                                     leave,
  1503.                                     "http://www.snafu.de/~mcthree/acdplay",
  1504.                                     NULL    };
  1505.  
  1506.                 BYTE flags[] = {     1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  1507.                                     1,0,0,0,0,0,1,0,0,0,0,0 };
  1508.  
  1509.                 char *text[] = {    PROG_FULLNAME,
  1510.                                     "Emailware",
  1511.                                     "© 1996-1998 Marc Altmann/Martin Kresse",
  1512.                                     NULL };
  1513.  
  1514.                 temp1 = FindWidest(stext, app->font);
  1515.  
  1516.                 /* durch 16 teilbar machen */
  1517.                 if (i = (temp1 % 16))
  1518.                     temp1 += 16 - i;
  1519.                 widest = FindWidest(text, app->font);
  1520.                 widest = widest > WIDTH_ACDPLOGO ? widest : WIDTH_ACDPLOGO;
  1521.                 widest = widest > temp1 ? widest : temp1;
  1522.  
  1523.                 /* Scroller erstellen */
  1524.                 app->scroller->Text        = stext;
  1525.                 app->scroller->Flags    = flags;
  1526.                 app->scroller->LeftEdge = (widest - temp1) / 2 + FAKEREQUESTSPACE + XOFFSET + 10;
  1527.                 app->scroller->TopEdge    = YOFFSET + 10 + HEIGHT_ACDPLOGO + 10 + 3 * app->font->ta_YSize + 12 + FAKEREQUESTSPACE;
  1528.                 app->scroller->Width    = temp1;
  1529.                 app->scroller->Height    = 6 * app->font->ta_YSize;
  1530.                 app->scroller->Font        = app->font;
  1531.                 CreateScrollObject(app->scroller);
  1532.                                 for (i = 0; i < 3; i++)
  1533.                 {
  1534.                     app->appwin[WINDOW_ABOUT].itext[i].FrontPen     = 1;
  1535.                     app->appwin[WINDOW_ABOUT].itext[i].DrawMode     = JAM1;
  1536.                     app->appwin[WINDOW_ABOUT].itext[i].LeftEdge     = ((widest - TextWidth(text[i], app->font)) / 2) + FAKEREQUESTSPACE + XOFFSET + 10;
  1537.                     app->appwin[WINDOW_ABOUT].itext[i].TopEdge      = i * app->font->ta_YSize + FAKEREQUESTSPACE + YOFFSET + 10 + HEIGHT_ACDPLOGO + 10;
  1538.                     app->appwin[WINDOW_ABOUT].itext[i].IText        = text[i];
  1539.                     app->appwin[WINDOW_ABOUT].itext[i].ITextFont     = app->font;
  1540.                     app->appwin[WINDOW_ABOUT].itext[i].NextText        = i < 2 ? app->appwin[WINDOW_ABOUT].itext + i + 1 : NULL;
  1541.                 }
  1542.  
  1543.                 /* Image */
  1544.                 if (app->appwin[WINDOW_ABOUT].img = GetVecA(sizeof(struct Image), MEMF_PUBLIC | MEMF_CLEAR))
  1545.                 {
  1546.                     app->appwin[WINDOW_ABOUT].img->LeftEdge        = ((widest - WIDTH_ACDPLOGO) / 2) + FAKEREQUESTSPACE + XOFFSET + 10;
  1547.                     app->appwin[WINDOW_ABOUT].img->TopEdge        = FAKEREQUESTSPACE + YOFFSET + 10;
  1548.                     app->appwin[WINDOW_ABOUT].img->Width        = WIDTH_ACDPLOGO;
  1549.                     app->appwin[WINDOW_ABOUT].img->Height        = HEIGHT_ACDPLOGO;
  1550.                     app->appwin[WINDOW_ABOUT].img->Depth        = 2;
  1551.                     app->appwin[WINDOW_ABOUT].img->ImageData    = imgdata_acdplogo;
  1552.                     app->appwin[WINDOW_ABOUT].img->PlanePick    = 3;
  1553.  
  1554.                     /* Gadget */
  1555.                     if (app->appwin[WINDOW_ABOUT].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_ABOUT, MEMF_PUBLIC | MEMF_CLEAR))
  1556.                     {
  1557.                         newgad.ng_TopEdge        = YOFFSET + 10 + HEIGHT_ACDPLOGO + 10 + 3 * app->font->ta_YSize + 12 + 6 * app->font->ta_YSize + 10 + 2 * FAKEREQUESTSPACE;
  1558.                         newgad.ng_LeftEdge        = XOFFSET;
  1559.                         newgad.ng_Width            = 10 + widest + 10 + 2 * FAKEREQUESTSPACE;
  1560.                         newgad.ng_Height        = BUTTONHEIGHT;
  1561.                         newgad.ng_GadgetText    = ls[MSG_OK_GAD];
  1562.                         newgad.ng_GadgetID        = GADGET_ABOUT_OK;
  1563.                         app->appwin[WINDOW_ABOUT].gadget[GADGET_ABOUT_OK] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, TAG_END);
  1564.  
  1565.                         app->appwin[WINDOW_ABOUT].maxsize[WIDTH]    = XOFFSET + 10 + widest + 10 + INTERWIDTH + 2 * FAKEREQUESTSPACE;
  1566.                         app->appwin[WINDOW_ABOUT].maxsize[HEIGHT]    = YOFFSET + 10 + HEIGHT_ACDPLOGO + 10 + 3 * app->font->ta_YSize + 12 + 6 * app->font->ta_YSize + 10 + BUTTONHEIGHT + INTERHEIGHT + 2 + 2 * FAKEREQUESTSPACE;
  1567.  
  1568.                         if (app->appwin[WINDOW_ABOUT].bbox = GetVecA(sizeof(struct BevelBox), MEMF_PUBLIC | MEMF_CLEAR))
  1569.                         {
  1570.                             app->appwin[WINDOW_ABOUT].bbox->bb_LeftEdge        = XOFFSET + 10 + FAKEREQUESTSPACE;
  1571.                             app->appwin[WINDOW_ABOUT].bbox->bb_TopEdge        = YOFFSET + 10 + HEIGHT_ACDPLOGO + 10 + 3 * app->font->ta_YSize + 10 + FAKEREQUESTSPACE;
  1572.                             app->appwin[WINDOW_ABOUT].bbox->bb_Width        = widest;
  1573.                             app->appwin[WINDOW_ABOUT].bbox->bb_Height        = 2;
  1574.                             app->appwin[WINDOW_ABOUT].bbox->bb_FrameType    = BBFT_BUTTON;
  1575.                             app->appwin[WINDOW_ABOUT].bbox->bb_Recessed        = TRUE;
  1576.                             app->appwin[WINDOW_ABOUT].bbox->bb_VisualInfo    = app->visualinfo;
  1577.  
  1578.                             success = TRUE;
  1579.                         }
  1580.                     }
  1581.                 }
  1582.             }
  1583.             break;
  1584.  
  1585.         case WINDOW_CDINFO:
  1586.             /* Intuitexte */
  1587.             if (app->appwin[WINDOW_CDINFO].itext = GetVecA(sizeof(struct IntuiText) * ANZ_GADGET_CDINFO, MEMF_PUBLIC | MEMF_CLEAR))
  1588.             {
  1589.                 int i;
  1590.                 char *text[] = {    ls[MSG_CDINFO_ARTIST],
  1591.                                     ls[MSG_CDINFO_CDTITLE],
  1592.                                     leave,
  1593.                                     ls[MSG_CDINFO_TRACKS],
  1594.                                     ls[MSG_CDINFO_TIME],
  1595.                                     NULL };
  1596.  
  1597.                 widest = FindWidest(text, app->font);
  1598.  
  1599.                 /* Maximalgröße */
  1600.                 app->appwin[WINDOW_CDINFO].maxheight = YOFFSET + 10 + 5 * app->font->ta_YSize + 10 + BUTTONHEIGHT + INTERHEIGHT + 10 + 2 * FAKEREQUESTSPACE;
  1601.  
  1602.                 AdjustNewSize(app, WINDOW_CDINFO, XOFFSET + 10 + widest + 10 + 100 + 10 + INTERWIDTH + 2 * FAKEREQUESTSPACE, app->appwin[WINDOW_CDINFO].maxheight);
  1603.  
  1604.                 for (i = 0; i < 5; i++)
  1605.                 {
  1606.                     app->appwin[WINDOW_CDINFO].itext[i].FrontPen     = 2;
  1607.                     app->appwin[WINDOW_CDINFO].itext[i].DrawMode     = JAM1;
  1608.                     app->appwin[WINDOW_CDINFO].itext[i].LeftEdge     = FAKEREQUESTSPACE + XOFFSET + 10;
  1609.                     app->appwin[WINDOW_CDINFO].itext[i].TopEdge      = (i * app->font->ta_YSize) + FAKEREQUESTSPACE + YOFFSET + 10;
  1610.                     app->appwin[WINDOW_CDINFO].itext[i].IText        = text[i];
  1611.                     app->appwin[WINDOW_CDINFO].itext[i].ITextFont     = app->font;
  1612.                     app->appwin[WINDOW_CDINFO].itext[i].NextText    = i < 4 ? app->appwin[WINDOW_CDINFO].itext + i + 1 : NULL;
  1613.                 }
  1614.  
  1615.                 /* Gadgets */
  1616.                 if (app->appwin[WINDOW_CDINFO].gadget = GetVecA(sizeof(struct Gadget *) * 5, MEMF_PUBLIC | MEMF_CLEAR))
  1617.                 {
  1618.                     newgad.ng_TopEdge        = YOFFSET + 10 + 5 * app->font->ta_YSize + 10 + 2 * FAKEREQUESTSPACE;
  1619.                     newgad.ng_LeftEdge        = XOFFSET;
  1620.                     newgad.ng_Width            = app->appwin[WINDOW_CDINFO].maxsize[WIDTH] - XOFFSET - 8;
  1621.                     newgad.ng_Height        = BUTTONHEIGHT;
  1622.                     newgad.ng_GadgetText    = ls[MSG_OK_GAD];
  1623.                     newgad.ng_GadgetID        = GADGET_CDINFO_OK;
  1624.                     app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_OK] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, TAG_END);
  1625.  
  1626.                     /* Diese Attribute sind für alle folgenden Gadgets gleich */
  1627.                     newgad.ng_LeftEdge        = 10 + widest + 24 + FAKEREQUESTSPACE;
  1628.                     newgad.ng_Width            = app->appwin[WINDOW_CDINFO].maxsize[WIDTH] - (XOFFSET + 10 + widest + 10 + 10 + INTERWIDTH + 2 * FAKEREQUESTSPACE);
  1629.                     newgad.ng_Height        = app->font->ta_YSize;
  1630.                     newgad.ng_GadgetText    = colon;
  1631.                     newgad.ng_Flags            = NG_HIGHLABEL;
  1632.  
  1633.                     /* Autor */
  1634.                     newgad.ng_TopEdge        = YOFFSET + 10 + FAKEREQUESTSPACE;
  1635.                     newgad.ng_GadgetID        = GADGET_CDINFO_AUTHOR;
  1636.                     app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_AUTHOR] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Clipped, TRUE, TAG_END);
  1637.  
  1638.                     /* Titel */
  1639.                     newgad.ng_TopEdge       += app->font->ta_YSize;
  1640.                     newgad.ng_GadgetID        = GADGET_CDINFO_TITLE;
  1641.                     app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TITLE] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Clipped, TRUE, TAG_END);
  1642.  
  1643.                     /* Spuren */
  1644.                     newgad.ng_TopEdge       += 2 * app->font->ta_YSize;
  1645.                     newgad.ng_GadgetID        = GADGET_CDINFO_TRACKS;
  1646.                     app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TRACKS] = gad = CreateGadget(NUMBER_KIND, gad, &newgad, GTNM_Clipped, TRUE, TAG_END);
  1647.  
  1648.                     /* Zeit */
  1649.                     newgad.ng_TopEdge       += app->font->ta_YSize;
  1650.                     newgad.ng_GadgetID        = GADGET_CDINFO_TIME;
  1651.                     app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TIME] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Clipped, TRUE, TAG_END);
  1652.  
  1653.                     success = TRUE;
  1654.                 }
  1655.             }
  1656.             break;
  1657.  
  1658.         case WINDOW_DRIVEINFO:
  1659.             /* Intuitexte */
  1660.             if (app->appwin[WINDOW_DRIVEINFO].itext = GetVecA(sizeof(struct IntuiText) * 6, MEMF_PUBLIC | MEMF_CLEAR))
  1661.             {
  1662.                 int i;
  1663.                 char *text[] = {    ls[MSG_DRIVEINFO_DEVICE],
  1664.                                     ls[MSG_DRIVEINFO_UNIT],
  1665.                                     leave,
  1666.                                     ls[MSG_DRIVEINFO_VENDOR],
  1667.                                     ls[MSG_DRIVEINFO_PRODUCT],
  1668.                                     ls[MSG_DRIVEINFO_SPECIFIC],
  1669.                                     NULL };
  1670.  
  1671.                 widest = FindWidest(text, app->font);
  1672.  
  1673.                 /* Maximalgrößen */
  1674.                 app->appwin[WINDOW_DRIVEINFO].maxheight    = YOFFSET + 10 + 6 * app->font->ta_YSize + 10 + BUTTONHEIGHT + INTERHEIGHT + 10 + 2 * FAKEREQUESTSPACE;
  1675.  
  1676.                 AdjustNewSize(app, WINDOW_DRIVEINFO, XOFFSET + 10 + widest + 10 + 100 + 10 + INTERWIDTH + 2 * FAKEREQUESTSPACE, app->appwin[WINDOW_DRIVEINFO].maxheight);
  1677.  
  1678.                 for (i = 0; i < 6; i++)
  1679.                 {
  1680.                     app->appwin[WINDOW_DRIVEINFO].itext[i].FrontPen     = 2;
  1681.                     app->appwin[WINDOW_DRIVEINFO].itext[i].DrawMode     = JAM1;
  1682.                     app->appwin[WINDOW_DRIVEINFO].itext[i].LeftEdge     = FAKEREQUESTSPACE + XOFFSET + 10;
  1683.                     app->appwin[WINDOW_DRIVEINFO].itext[i].TopEdge      = i * app->font->ta_YSize + FAKEREQUESTSPACE + YOFFSET + 10;
  1684.                     app->appwin[WINDOW_DRIVEINFO].itext[i].IText        = text[i];
  1685.                     app->appwin[WINDOW_DRIVEINFO].itext[i].ITextFont     = app->font;
  1686.                     app->appwin[WINDOW_DRIVEINFO].itext[i].NextText        = i < 5 ? app->appwin[WINDOW_DRIVEINFO].itext + i + 1 : NULL;
  1687.                 }
  1688.  
  1689.                 /*** Gadgets ***/
  1690.                 if (app->appwin[WINDOW_DRIVEINFO].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_DRIVEINFO, MEMF_PUBLIC | MEMF_CLEAR))
  1691.                 {
  1692.                     newgad.ng_TopEdge        = YOFFSET + 10 + 6 * app->font->ta_YSize + 10 + 2 * FAKEREQUESTSPACE;
  1693.                     newgad.ng_LeftEdge        = XOFFSET;
  1694.                     newgad.ng_Width            = app->appwin[WINDOW_DRIVEINFO].maxsize[WIDTH] - XOFFSET - 8;
  1695.                     newgad.ng_Height        = BUTTONHEIGHT;
  1696.                     newgad.ng_GadgetText    = ls[MSG_OK_GAD];
  1697.                     newgad.ng_GadgetID        = GADGET_DRIVEINFO_OK;
  1698.                     app->appwin[WINDOW_DRIVEINFO].gadget[GADGET_DRIVEINFO_OK] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, TAG_END);
  1699.  
  1700.                     /* Diese Attribute sind bei den folgenden Gadgets gleich */
  1701.                     newgad.ng_LeftEdge        = 10 + widest + 24 + FAKEREQUESTSPACE;
  1702.                     newgad.ng_Width            = app->appwin[WINDOW_DRIVEINFO].maxsize[WIDTH] - (XOFFSET + 10 + widest + 10 + 10 + INTERWIDTH + 2 * FAKEREQUESTSPACE);
  1703.                     newgad.ng_Height        = app->font->ta_YSize;
  1704.                     newgad.ng_GadgetText    = colon;
  1705.                     newgad.ng_Flags            = NG_HIGHLABEL;
  1706.  
  1707.                     /* Laufwerk */
  1708.                     newgad.ng_TopEdge        = YOFFSET + 10 + FAKEREQUESTSPACE;
  1709.                     newgad.ng_GadgetID        = GADGET_DRIVEINFO_DEVICE;
  1710.                     app->appwin[WINDOW_DRIVEINFO].gadget[GADGET_DRIVEINFO_DEVICE] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Clipped, TRUE, TAG_END);
  1711.  
  1712.                     /* Unit */
  1713.                     newgad.ng_TopEdge       += app->font->ta_YSize;
  1714.                     newgad.ng_GadgetID        = GADGET_DRIVEINFO_UNIT;
  1715.                     app->appwin[WINDOW_DRIVEINFO].gadget[GADGET_DRIVEINFO_UNIT] = gad = CreateGadget(NUMBER_KIND, gad, &newgad, GTNM_Clipped, TRUE, TAG_END);
  1716.  
  1717.                     /* Hersteller */
  1718.                     newgad.ng_TopEdge       += 2 * app->font->ta_YSize;
  1719.                     newgad.ng_GadgetID        = GADGET_DRIVEINFO_VENDOR;
  1720.                     app->appwin[WINDOW_DRIVEINFO].gadget[GADGET_DRIVEINFO_VENDOR] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Clipped, TRUE, TAG_END);
  1721.  
  1722.                     /* Produkt */
  1723.                     newgad.ng_TopEdge       += app->font->ta_YSize;
  1724.                     newgad.ng_GadgetID        = GADGET_DRIVEINFO_PRODUCT;
  1725.                     app->appwin[WINDOW_DRIVEINFO].gadget[GADGET_DRIVEINFO_PRODUCT] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Clipped, TRUE, TAG_END);
  1726.  
  1727.                     /* Spezifisches */
  1728.                     newgad.ng_TopEdge       += app->font->ta_YSize;
  1729.                     newgad.ng_GadgetID        = GADGET_DRIVEINFO_SPECIFIC;
  1730.                     app->appwin[WINDOW_DRIVEINFO].gadget[GADGET_DRIVEINFO_SPECIFIC] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Clipped, TRUE, TAG_END);
  1731.  
  1732.                     success = TRUE;
  1733.                 }
  1734.             }
  1735.             break;
  1736.  
  1737.         case WINDOW_PUBSCREEN:
  1738.             /*** Gadgets ***/
  1739.             if (app->appwin[WINDOW_PUBSCREEN].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_PUBSCREEN, MEMF_PUBLIC | MEMF_CLEAR))
  1740.             {
  1741.                 widest = TextWidth(ls[MSG_PUBSCREEN_UPDATE], app->font) + BUTTONSPACE;
  1742.                 AdjustNewSize(app, WINDOW_PUBSCREEN, widest + XOFFSET + 8, YOFFSET + 4 + 4 * app->font->ta_YSize + BUTTONHEIGHT + INTERHEIGHT + 10);
  1743.  
  1744.                 newgad.ng_TopEdge        = YOFFSET;
  1745.                 newgad.ng_LeftEdge        = XOFFSET;
  1746.                 newgad.ng_Width            = app->appwin[WINDOW_PUBSCREEN].maxsize[WIDTH] - XOFFSET - 8;
  1747.                 newgad.ng_Height        = app->appwin[WINDOW_PUBSCREEN].maxsize[HEIGHT] - YOFFSET - INTERHEIGHT - 10 - BUTTONHEIGHT;
  1748.                 newgad.ng_GadgetID        = GADGET_PUBSCREEN_LISTVIEW;
  1749.                 app->appwin[WINDOW_PUBSCREEN].gadget[GADGET_PUBSCREEN_LISTVIEW] = gad = CreateGadget(LISTVIEW_KIND, gad, &newgad, GTLV_Labels, NULL, TAG_END);
  1750.  
  1751.                 newgad.ng_TopEdge        = newgad.ng_TopEdge + newgad.ng_Height;
  1752.                 newgad.ng_Height        = BUTTONHEIGHT;
  1753.                 newgad.ng_GadgetText    = ls[MSG_PUBSCREEN_UPDATE];
  1754.                 newgad.ng_GadgetID        = GADGET_PUBSCREEN_UPDATE;
  1755.                 app->appwin[WINDOW_PUBSCREEN].gadget[GADGET_PUBSCREEN_UPDATE] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, TAG_END);
  1756.  
  1757.                 success = TRUE;
  1758.             }
  1759.             break;
  1760.  
  1761.         case WINDOW_TITLES:
  1762.             /*** Gadgets ***/
  1763.             if (app->appwin[WINDOW_TITLES].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_TITLES, MEMF_PUBLIC | MEMF_CLEAR))
  1764.             {
  1765.                 AdjustNewSize(app, WINDOW_TITLES, MINWIDTH_LISTVIEWWIN, MINHEIGHT_LISTVIEWWIN);
  1766.  
  1767.                 newgad.ng_TopEdge        = YOFFSET;
  1768.                 newgad.ng_LeftEdge        = XOFFSET;
  1769.                 newgad.ng_Width            = app->appwin[WINDOW_TITLES].maxsize[WIDTH] - XOFFSET - 8;
  1770.                 newgad.ng_Height        = app->appwin[WINDOW_TITLES].maxsize[HEIGHT] - YOFFSET - INTERHEIGHT - 10;
  1771.                 newgad.ng_GadgetID        = GADGET_TITLES_LISTVIEW;
  1772.                 app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW] = gad = CreateGadget(LISTVIEW_KIND, gad, &newgad, GTLV_Labels, NULL, GTLV_ShowSelected, NULL, TAG_END);
  1773.  
  1774.                 success = TRUE;
  1775.             }
  1776.             break;
  1777.  
  1778.         case WINDOW_EDIT:
  1779.             /*** Gadgets ***/
  1780.             if (app->appwin[WINDOW_EDIT].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_EDIT, MEMF_PUBLIC | MEMF_CLEAR))
  1781.             {
  1782.                 int temp1, temp2;
  1783.                 char *text[] = {    ls[MSG_EDIT_ARTIST],
  1784.                                     ls[MSG_EDIT_CDTITLE],
  1785.                                     NULL };
  1786.  
  1787.                 widest         = (temp2 = FindWidest(text, app->font) + INTERWIDTH)    + MINWIDTH_STRINGGAD;
  1788.                 temp1        = TextWidth(ls[MSG_EDIT_SAVE], app->font) + BUTTONSPACE;
  1789.  
  1790.                 if (temp1 > widest)
  1791.                     widest = temp1;
  1792.  
  1793.                 if (MINWIDTH_LISTVIEW > widest)
  1794.                     widest = MINWIDTH_LISTVIEW;
  1795.  
  1796.                 AdjustNewSize(app, WINDOW_EDIT, widest + XOFFSET + INTERWIDTH, MINHEIGHT_LISTVIEWWIN + 4 * BUTTONHEIGHT + 3 * INTERHEIGHT);
  1797.                                 /* Titel-String */
  1798.                 newgad.ng_TopEdge        = YOFFSET;
  1799.                 newgad.ng_LeftEdge        = XOFFSET + temp2;
  1800.                 newgad.ng_Width            = app->appwin[WINDOW_EDIT].maxsize[WIDTH] - XOFFSET - INTERWIDTH - temp2;
  1801.                 newgad.ng_Height        = BUTTONHEIGHT;
  1802.                 newgad.ng_GadgetText    = ls[MSG_EDIT_CDTITLE];
  1803.                 newgad.ng_GadgetID        = GADGET_EDIT_TITLE;
  1804.                 app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TITLE] = gad = CreateGadget(STRING_KIND, gad, &newgad, GA_Disabled, (app->cdstr->active == AUDIO_STAT_NO_DISK) ? TRUE : FALSE, GA_TabCycle, TRUE, GTST_MaxChars, MAXCDNAME, TAG_END);
  1805.  
  1806.                 /* Künstler-String */
  1807.                 newgad.ng_TopEdge       += BUTTONHEIGHT + INTERHEIGHT;
  1808.                 newgad.ng_GadgetText    = ls[MSG_EDIT_ARTIST];
  1809.                 newgad.ng_GadgetID        = GADGET_EDIT_ARTIST;
  1810.                 app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_ARTIST] = gad = CreateGadget(STRING_KIND, gad, &newgad, GA_Disabled, (app->cdstr->active == AUDIO_STAT_NO_DISK) ? TRUE : FALSE, GA_TabCycle, TRUE, GTST_MaxChars, MAXARTISTNAME, TAG_END);
  1811.  
  1812.                 /* Save-Button */
  1813.                 newgad.ng_TopEdge        = app->appwin[WINDOW_EDIT].maxsize[HEIGHT] - INTERHEIGHT - BUTTONHEIGHT - 10;
  1814.                 newgad.ng_LeftEdge        = XOFFSET;
  1815.                 newgad.ng_Width            = app->appwin[WINDOW_EDIT].maxsize[WIDTH] - XOFFSET - INTERWIDTH;
  1816.                 newgad.ng_GadgetText    = ls[MSG_EDIT_SAVE];
  1817.                 newgad.ng_GadgetID        = GADGET_EDIT_SAVE;
  1818.                 app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_SAVE] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GA_Disabled, (app->cdstr->active == AUDIO_STAT_NO_DISK) ? TRUE : FALSE, TAG_END);
  1819.  
  1820.                 /* Track-Titel-String, muß vor dem Listview kreiert werden */
  1821.                 newgad.ng_TopEdge       -= BUTTONHEIGHT + INTERHEIGHT;
  1822.                 newgad.ng_GadgetText    = NULL;
  1823.                 newgad.ng_GadgetID        = GADGET_EDIT_TRACKTITLE;
  1824.                 app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE] = gad = CreateGadget(STRING_KIND, gad, &newgad, GA_Disabled, app->edit_pos >= 0 ? FALSE : TRUE, GA_TabCycle, TRUE, GTST_MaxChars, MAXTITLENAME, TAG_END);
  1825.  
  1826.                 /* Listview */
  1827.                 newgad.ng_TopEdge        = YOFFSET + 2 * BUTTONHEIGHT + 2 * INTERHEIGHT;
  1828.                 newgad.ng_Height        = app->appwin[WINDOW_EDIT].maxsize[HEIGHT] - newgad.ng_TopEdge - 2 * INTERHEIGHT - BUTTONHEIGHT - 10;
  1829.                 newgad.ng_GadgetText    = NULL;
  1830.                 newgad.ng_GadgetID        = GADGET_EDIT_LISTVIEW;
  1831.                 app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW] = gad = CreateGadget(LISTVIEW_KIND, gad, &newgad, GTLV_Labels, NULL, GTLV_ShowSelected, app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], TAG_END);
  1832.  
  1833.                 success = TRUE;
  1834.             }
  1835.             break;
  1836.  
  1837.         case WINDOW_PROGRAM:
  1838.             if (app->appwin[WINDOW_PROGRAM].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_PROGRAM, MEMF_PUBLIC | MEMF_CLEAR))
  1839.             {
  1840.                 char *text[] = {    ls[MSG_PROGRAM_COPYALL],
  1841.                                     ls[MSG_PROGRAM_LOAD],
  1842.                                     ls[MSG_PROGRAM_DEL],
  1843.                                     ls[MSG_PROGRAM_SAVE],
  1844.                                     NULL };
  1845.  
  1846.                 widest = (FindWidest(text, app->font) + BUTTONSPACE) * 2;
  1847.  
  1848.                 /* widest muß mindestens so lang sein: */
  1849.                 if (widest < 2 * MINWIDTH_LISTVIEW + INTERWIDTH)
  1850.                     widest = 2 * MINWIDTH_LISTVIEW + INTERWIDTH;
  1851.  
  1852.                 AdjustNewSize(app, WINDOW_PROGRAM, widest + XOFFSET + INTERWIDTH, MINHEIGHT_LISTVIEWWIN + app->font->ta_YSize + INTERHEIGHT + 2 * BUTTONHEIGHT);
  1853.  
  1854.                 /* CD-Listview */
  1855.                 newgad.ng_TopEdge        = YOFFSET + app->font->ta_YSize + INTERHEIGHT;
  1856.                 newgad.ng_LeftEdge        = XOFFSET;
  1857.                 newgad.ng_Width            = (app->appwin[WINDOW_PROGRAM].maxsize[WIDTH] - XOFFSET - 2 * INTERWIDTH) / 2;
  1858.                 newgad.ng_Height        = app->appwin[WINDOW_PROGRAM].maxsize[HEIGHT] - YOFFSET - app->font->ta_YSize - 2 * INTERHEIGHT - 2 * BUTTONHEIGHT - 10;
  1859.                 newgad.ng_GadgetText    = ls[MSG_PROGRAM_CD];
  1860.                 newgad.ng_GadgetID        = GADGET_PROGRAM_LVCD;
  1861.                 newgad.ng_Flags            = NG_HIGHLABEL;
  1862.                 app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVCD] = gad = CreateGadget(LISTVIEW_KIND, gad, &newgad, GTLV_Labels, NULL, TAG_END);
  1863.  
  1864.                 /* Programm-Listview */
  1865.                 newgad.ng_LeftEdge       += newgad.ng_Width + INTERWIDTH;
  1866.                 newgad.ng_Width            = app->appwin[WINDOW_PROGRAM].maxsize[WIDTH] - XOFFSET - 2 * INTERWIDTH - newgad.ng_Width;
  1867.                 newgad.ng_GadgetText    = ls[MSG_PROGRAM_PRG];
  1868.                 newgad.ng_GadgetID        = GADGET_PROGRAM_LVPRG;
  1869.                 app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVPRG] = gad = CreateGadget(LISTVIEW_KIND, gad, &newgad, GTLV_Labels, NULL, TAG_END);
  1870.  
  1871.                 /* Button: Alles kopieren */
  1872.                 newgad.ng_TopEdge       += newgad.ng_Height;
  1873.                 newgad.ng_LeftEdge        = XOFFSET;
  1874.                 newgad.ng_Width            = (app->appwin[WINDOW_PROGRAM].maxsize[WIDTH] - XOFFSET - INTERWIDTH) / 2;
  1875.                 newgad.ng_Height        = BUTTONHEIGHT;
  1876.                 newgad.ng_GadgetText    = ls[MSG_PROGRAM_COPYALL];
  1877.                 newgad.ng_GadgetID        = GADGET_PROGRAM_COPYALL;
  1878.                 newgad.ng_Flags            = 0;
  1879.                 app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_COPYALL] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GA_Disabled, (app->cdstr->active == AUDIO_STAT_NO_DISK) ? TRUE : FALSE, TAG_END);
  1880.  
  1881.                 /* Button: Laden */
  1882.                 newgad.ng_TopEdge       += BUTTONHEIGHT;
  1883.                 newgad.ng_GadgetText    = ls[MSG_PROGRAM_LOAD];
  1884.                 newgad.ng_GadgetID        = GADGET_PROGRAM_LOAD;
  1885.                 app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LOAD] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GA_Disabled, (app->cdstr->active == AUDIO_STAT_NO_DISK) ? TRUE : FALSE, TAG_END);
  1886.  
  1887.                 /* Button: Prog löschen */
  1888.                 newgad.ng_LeftEdge       += newgad.ng_Width;
  1889.                 newgad.ng_Width            = app->appwin[WINDOW_PROGRAM].maxsize[WIDTH] - XOFFSET - INTERWIDTH - newgad.ng_Width;
  1890.                 newgad.ng_TopEdge       -= BUTTONHEIGHT;
  1891.                 newgad.ng_GadgetText    = ls[MSG_PROGRAM_DEL];
  1892.                 newgad.ng_GadgetID        = GADGET_PROGRAM_DEL;
  1893.                 app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_DEL] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GA_Disabled, (app->cdstr->active == AUDIO_STAT_NO_DISK) ? TRUE : FALSE, TAG_END);
  1894.  
  1895.                 /* Button: Speichern */
  1896.                 newgad.ng_TopEdge       += BUTTONHEIGHT;
  1897.                 newgad.ng_GadgetText    = ls[MSG_PROGRAM_SAVE];
  1898.                 newgad.ng_GadgetID        = GADGET_PROGRAM_SAVE;
  1899.                 app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_SAVE] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GA_Disabled, (app->cdstr->active == AUDIO_STAT_NO_DISK) ? TRUE : FALSE, TAG_END);
  1900.  
  1901.                 success = TRUE;
  1902.             }
  1903.             break;
  1904.  
  1905.         case WINDOW_VOLUME:
  1906.             if (app->appwin[WINDOW_VOLUME].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_VOLUME, MEMF_PUBLIC | MEMF_CLEAR))
  1907.             {
  1908.                 struct CDxRequest *cdx = app->cdstr->cdx;
  1909.                 int temp1;
  1910.                 int temp2;
  1911.  
  1912.                 char *text[] = {    ls[MSG_VOLUME_LEFT],
  1913.                                     ls[MSG_VOLUME_MASTER],
  1914.                                     ls[MSG_VOLUME_RIGHT],
  1915.                                     NULL };
  1916.  
  1917.                 widest    = FindWidest(text, app->font);
  1918.                 temp1    = 3 * TextWidth("8", app->font) + 2;
  1919.  
  1920.                 if (temp1 > widest) widest = temp1;
  1921.  
  1922.                 temp2    = widest;
  1923.                 widest *= 3;
  1924.                 widest += 2 * INTERWIDTH;
  1925.  
  1926.                 AdjustNewSize(app, WINDOW_VOLUME, XOFFSET + widest + INTERWIDTH, YOFFSET + 2 * app->font->ta_YSize + 3 * INTERHEIGHT + MINHEIGHT_VERTSLIDER + 10);
  1927.  
  1928.                 /* Volumewerte aktualisieren */
  1929.                 CDVolumeA(cdx, GET_VOLUME);
  1930.  
  1931.                 /* Linker Lautstärkeregler */
  1932.                 newgad.ng_Width            = temp1;
  1933.  
  1934.                 temp1 = (app->appwin[WINDOW_VOLUME].maxsize[WIDTH] - XOFFSET - 3 * INTERWIDTH - 3 * temp2) / 2;
  1935.  
  1936.                 newgad.ng_LeftEdge        = XOFFSET + (temp2 - newgad.ng_Width) / 2;
  1937.                 newgad.ng_TopEdge        = YOFFSET + app->font->ta_YSize + INTERHEIGHT + 2;
  1938.                 newgad.ng_Height        = app->appwin[WINDOW_VOLUME].maxsize[HEIGHT] - newgad.ng_TopEdge - 2 * INTERHEIGHT - app->font->ta_YSize - 10 - 2;
  1939.                 newgad.ng_GadgetText    = text[0];
  1940.                 newgad.ng_GadgetID        = GADGET_VOLUME_LEFT;
  1941.                 newgad.ng_Flags            = PLACETEXT_ABOVE;
  1942.                 app->appwin[WINDOW_VOLUME].gadget[GADGET_VOLUME_LEFT] = gad = CreateGadget(SLIDER_KIND, gad, &newgad, GTSL_Max, 255, GTSL_Level, cdx->cdx_Volume[0], GTSL_LevelFormat, "%2ld", GTSL_MaxLevelLen, 3, GTSL_LevelPlace, PLACETEXT_BELOW, PGA_Freedom, LORIENT_VERT, GA_Disabled, cdx->cdx_Flags & SPECIALF_ATAPI, TAG_END);
  1943.  
  1944.                 /* Gesamtlautstärke */
  1945.                 newgad.ng_Width           += 2;
  1946.                 newgad.ng_LeftEdge        = XOFFSET + temp2 + INTERWIDTH + (temp2 - newgad.ng_Width) / 2 + temp1;
  1947.                 newgad.ng_TopEdge       -= 2;
  1948.                 newgad.ng_Height       += 4;
  1949.                 newgad.ng_GadgetText    = text[1];
  1950.                 newgad.ng_GadgetID        = GADGET_VOLUME_MASTER;
  1951.                 newgad.ng_Flags            = PLACETEXT_ABOVE | NG_HIGHLABEL;
  1952.                 app->appwin[WINDOW_VOLUME].gadget[GADGET_VOLUME_MASTER] = gad = CreateGadget(SLIDER_KIND, gad, &newgad, GTSL_Max, 255, GTSL_Level, (cdx->cdx_Volume[0]+cdx->cdx_Volume[1])/2, GTSL_LevelFormat, "%2ld", GTSL_MaxLevelLen, 3, GTSL_LevelPlace, PLACETEXT_BELOW, PGA_Freedom, LORIENT_VERT, TAG_END);
  1953.  
  1954.                 /* Rechter Lautstärkeregler */
  1955.                 newgad.ng_Width           -= 2;
  1956.                 newgad.ng_LeftEdge        = app->appwin[WINDOW_VOLUME].maxsize[WIDTH] - INTERWIDTH - temp2 + (temp2 - newgad.ng_Width) / 2;
  1957.                 newgad.ng_TopEdge       += 2;
  1958.                 newgad.ng_Height       -= 4;
  1959.                 newgad.ng_GadgetText    = text[2];
  1960.                 newgad.ng_GadgetID        = GADGET_VOLUME_RIGHT;
  1961.                 newgad.ng_Flags            = PLACETEXT_ABOVE;
  1962.                 app->appwin[WINDOW_VOLUME].gadget[GADGET_VOLUME_RIGHT] = gad = CreateGadget(SLIDER_KIND, gad, &newgad, GTSL_Max, 255, GTSL_Level, cdx->cdx_Volume[1], GTSL_LevelFormat, "%2ld", GTSL_MaxLevelLen, 3, GTSL_LevelPlace, PLACETEXT_BELOW, PGA_Freedom, LORIENT_VERT, GA_Disabled, cdx->cdx_Flags & SPECIALF_ATAPI, TAG_END);
  1963.  
  1964.                 success = TRUE;
  1965.             }
  1966.             break;
  1967.  
  1968.         case WINDOW_AB:
  1969.             if (app->appwin[WINDOW_AB].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_AB, MEMF_PUBLIC))
  1970.             {
  1971.                 int temp1, temp2, temp3;    /* später wichtig */
  1972.                 char *text[] = { "A", "B", NULL };
  1973.  
  1974.                 /* temp1 enthält die Länge des A- oder B-Buttons    */
  1975.                 /* temp2 enthält die Länge des Track-Strings         */
  1976.                 /* temp3 --------"-------- des Zeit-Strings            */
  1977.                 /* -> Daraus wird die Größe in Prozent berechnet,    */
  1978.                 /*    um beim Sizing die Proportionen zu wahren..    */
  1979.  
  1980.                 temp1 = FindWidest(text, app->font) + BUTTONSPACE;
  1981.                 temp2 = TextWidth("99", app->font) + BUTTONSPACE;
  1982.                 temp3 = TextWidth("99:99.99", app->font) + BUTTONSPACE;
  1983.  
  1984.                 widest = temp1 + temp2 + temp3;
  1985.  
  1986.                 /* Maximalgrößen */
  1987.                 app->appwin[WINDOW_AB].maxheight = YOFFSET + 2 * BUTTONHEIGHT + app->font->ta_YSize + 2 * INTERHEIGHT + 10;
  1988.                 AdjustNewSize(app, WINDOW_AB, XOFFSET + widest + INTERWIDTH, app->appwin[WINDOW_AB].maxheight);
  1989.  
  1990.                 /* Der A-Button */
  1991.                 newgad.ng_LeftEdge         = XOFFSET;
  1992.                 newgad.ng_TopEdge        = YOFFSET + app->font->ta_YSize + INTERHEIGHT;
  1993.                 newgad.ng_Width            = (WORD)((app->appwin[WINDOW_AB].maxsize[WIDTH] - XOFFSET - INTERWIDTH) / (DOUBLE)widest * temp1);
  1994.                 newgad.ng_Height         = BUTTONHEIGHT;
  1995.                 newgad.ng_GadgetText    = text[0];
  1996.                 newgad.ng_GadgetID        = GADGET_AB_A;
  1997.                 app->appwin[WINDOW_AB].gadget[GADGET_AB_A] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GA_Disabled, app->cdstr->active == AUDIO_STAT_NO_DISK || app->cdstr->active == AUDIO_STAT_STOPPED ? TRUE : FALSE, TAG_END);
  1998.  
  1999.                 /* Der B-Button */
  2000.                 newgad.ng_TopEdge       += BUTTONHEIGHT;
  2001.                 newgad.ng_GadgetText    = text[1];
  2002.                 newgad.ng_GadgetID        = GADGET_AB_B;
  2003.                 app->appwin[WINDOW_AB].gadget[GADGET_AB_B] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, GA_Disabled, app->cdstr->active == AUDIO_STAT_NO_DISK || app->cdstr->active == AUDIO_STAT_STOPPED ? TRUE : FALSE, TAG_END);
  2004.  
  2005.                 /* Der A-Track-String */
  2006.                 newgad.ng_LeftEdge       += newgad.ng_Width;
  2007.                 newgad.ng_TopEdge       -= BUTTONHEIGHT;
  2008.                 newgad.ng_Width            = (WORD)((app->appwin[WINDOW_AB].maxsize[WIDTH] - XOFFSET - INTERWIDTH) / (DOUBLE)widest * temp2);
  2009.                 newgad.ng_GadgetText    = ls[MSG_AB_TRACK];
  2010.                 newgad.ng_GadgetID        = GADGET_AB_A_TRACK;
  2011.                 newgad.ng_Flags            = PLACETEXT_ABOVE | NG_HIGHLABEL;
  2012.                 app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TRACK] = gad = CreateGadget(INTEGER_KIND, gad, &newgad, GA_Disabled, app->cdstr->active == AUDIO_STAT_NO_DISK ? TRUE : FALSE, GA_TabCycle, TRUE, GTIN_MaxChars, 2, TAG_END);
  2013.  
  2014.                 /* Der B-Track-String */
  2015.                 newgad.ng_TopEdge       += BUTTONHEIGHT;
  2016.                 newgad.ng_GadgetText    = NULL;
  2017.                 newgad.ng_GadgetID        = GADGET_AB_B_TRACK;
  2018.                 app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TRACK] = gad = CreateGadget(INTEGER_KIND, gad, &newgad, GA_Disabled, app->cdstr->active == AUDIO_STAT_NO_DISK ? TRUE : FALSE, GA_TabCycle, TRUE, GTIN_MaxChars, 2, TAG_END);
  2019.  
  2020.                 /* Der A-Zeit-String */
  2021.                 newgad.ng_LeftEdge       += newgad.ng_Width;
  2022.                 newgad.ng_TopEdge       -= BUTTONHEIGHT;
  2023.                 newgad.ng_Width            = app->appwin[WINDOW_AB].maxsize[WIDTH] - newgad.ng_LeftEdge - INTERWIDTH;
  2024.                 newgad.ng_GadgetText    = ls[MSG_AB_TIME];
  2025.                 newgad.ng_GadgetID        = GADGET_AB_A_TIME;
  2026.                 app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TIME] = gad = CreateGadget(STRING_KIND, gad, &newgad, GA_Disabled, app->cdstr->active == AUDIO_STAT_NO_DISK ? TRUE : FALSE, GA_TabCycle, TRUE, GTST_MaxChars, 8, TAG_END);
  2027.  
  2028.                 /* Der B-Zeit-String */
  2029.                 newgad.ng_TopEdge       += BUTTONHEIGHT;
  2030.                 newgad.ng_GadgetText    = NULL;
  2031.                 newgad.ng_GadgetID        = GADGET_AB_B_TIME;
  2032.                 app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TIME] = gad = CreateGadget(STRING_KIND, gad, &newgad, GA_Disabled, app->cdstr->active == AUDIO_STAT_NO_DISK ? TRUE : FALSE, GA_TabCycle, TRUE, GTST_MaxChars, 8, TAG_END);
  2033.  
  2034.                 success = TRUE;
  2035.             }
  2036.             break;
  2037.  
  2038.         case WINDOW_SAVEAUDIO:
  2039.             if (app->appwin[WINDOW_SAVEAUDIO].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_SAVEAUDIO, MEMF_PUBLIC))
  2040.             {
  2041.                 int temp1, temp2, temp3, temp4;
  2042.  
  2043.                 static char    *TEXT_SAVEAUDIO_FORMAT[2],
  2044.                             *TEXT_SAVEAUDIO_FREQ[5];
  2045.  
  2046.                 char *text[] = {    ls[MSG_SAVEAUDIO_FORMAT],
  2047.                                     "Frequency", /* ls[MSG_SAVEAUDIO_FREQ], */
  2048.                                     ls[MSG_SAVEAUDIO_FILENAME],
  2049.                                     ls[MSG_SAVEAUDIO_SIZE],
  2050.                                     NULL };
  2051.                 temp1 = FindWidest(text, app->font);
  2052.  
  2053.                 TEXT_SAVEAUDIO_FORMAT[0] = "CDR";
  2054.                 TEXT_SAVEAUDIO_FORMAT[1] = NULL;
  2055.                 temp2 = FindWidest(TEXT_SAVEAUDIO_FORMAT, app->font) + 20;    // 20 für Cycleimage
  2056.  
  2057.                 TEXT_SAVEAUDIO_FREQ[0] = "5512";
  2058.                 TEXT_SAVEAUDIO_FREQ[1] = "11025";
  2059.                 TEXT_SAVEAUDIO_FREQ[2] = "22050";
  2060.                 TEXT_SAVEAUDIO_FREQ[3] = "44100";
  2061.                 TEXT_SAVEAUDIO_FREQ[4] = NULL;
  2062.  
  2063.                 temp3 = FindWidest(TEXT_SAVEAUDIO_FREQ, app->font) + 20;    // 20 Cycleimage
  2064.                 if (temp3 > temp2)
  2065.                     temp2 = temp3;
  2066.  
  2067.                 temp3 = TextWidth("000.000.000 Byte", app->font);
  2068.                 if (temp3 > temp2)
  2069.                     temp2 = temp3;
  2070.  
  2071.                 temp3 = TextWidth("G", app->font) + BUTTONSPACE;
  2072.                 if (temp3 > temp2)
  2073.                     temp2 = temp3;
  2074.  
  2075.                 temp2 += BUTTONSPACE;
  2076.  
  2077.                 temp4 = TextWidth(ls[MSG_SAVEAUDIO_SAVE], app->font) + BUTTONSPACE;
  2078.                 widest = temp1 + INTERWIDTH + temp2;
  2079.                 if (temp4 > widest)
  2080.                     widest = temp4;
  2081.  
  2082.                 /* Maximalgrößen */
  2083.                 app->appwin[WINDOW_SAVEAUDIO].maxheight = YOFFSET + 5 * BUTTONHEIGHT + 5 * INTERHEIGHT + 10;
  2084.                 AdjustNewSize(app, WINDOW_SAVEAUDIO, XOFFSET + widest + INTERWIDTH, app->appwin[WINDOW_SAVEAUDIO].maxheight);
  2085.  
  2086.                 /* Der Format-Button */
  2087.                 newgad.ng_LeftEdge         = XOFFSET + temp1 + INTERWIDTH;
  2088.                 newgad.ng_TopEdge        = YOFFSET;
  2089.                 newgad.ng_Width            = app->appwin[WINDOW_SAVEAUDIO].maxsize[WIDTH] - XOFFSET - temp1 - 2 * INTERWIDTH;
  2090.                 newgad.ng_Height         = BUTTONHEIGHT;
  2091.                 newgad.ng_GadgetText    = ls[MSG_SAVEAUDIO_FORMAT];
  2092.                 newgad.ng_GadgetID        = GADGET_SAVEAUDIO_FORMAT;
  2093.                 app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FORMAT] = gad = CreateGadget(CYCLE_KIND, gad, &newgad, GA_Disabled, TRUE, GTCY_Labels, TEXT_SAVEAUDIO_FORMAT, GTCY_Active, app->cdstr->fileformat, TAG_END);
  2094.  
  2095.                 /* Der Freq-Slider */
  2096.                 newgad.ng_TopEdge       += BUTTONHEIGHT + INTERHEIGHT;
  2097.                 newgad.ng_GadgetText    = "Frequency";    /* ls[MSG_SAVEAUDIO_FREQ]; */
  2098.                 newgad.ng_GadgetID        = GADGET_SAVEAUDIO_FREQ;
  2099.                 app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FREQ] = gad = CreateGadget(CYCLE_KIND, gad, &newgad, GA_Disabled, app->cdstr->fileformat == FORMAT_CDR ? TRUE : FALSE, GTCY_Labels, TEXT_SAVEAUDIO_FREQ, GTCY_Active, app->cdstr->freq, TAG_END);
  2100.  
  2101.                 /* vorgezogen: Size-Textfeld */
  2102.                 newgad.ng_TopEdge       += 2 * BUTTONHEIGHT + 2 * INTERHEIGHT;
  2103.                 newgad.ng_GadgetText    = ls[MSG_SAVEAUDIO_SIZE];
  2104.                 newgad.ng_GadgetID        = GADGET_SAVEAUDIO_SIZE;
  2105.                 app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_SIZE] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Border, TRUE, TAG_END);
  2106.  
  2107.                 /* Die Filename-Buttons */
  2108.                 newgad.ng_TopEdge       -= BUTTONHEIGHT + INTERHEIGHT;
  2109.                 newgad.ng_Width           -= temp3;
  2110.                 newgad.ng_GadgetText    = ls[MSG_SAVEAUDIO_FILENAME];
  2111.                 newgad.ng_GadgetID        = GADGET_SAVEAUDIO_FILENAME;
  2112.                 app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FILENAME] = gad = CreateGadget(STRING_KIND, gad, &newgad, GTST_MaxChars, DISKPATHLENGTH, TAG_END);
  2113.  
  2114.                 newgad.ng_LeftEdge       += newgad.ng_Width;
  2115.                 newgad.ng_Width            = temp3;
  2116.                 newgad.ng_GadgetText    = "G";
  2117.                 newgad.ng_GadgetID        = GADGET_SAVEAUDIO_GETFILE;
  2118.                 app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_GETFILE] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, TAG_END);
  2119.  
  2120.                 /* Der Save-Button */
  2121.                 newgad.ng_LeftEdge        = XOFFSET;
  2122.                 newgad.ng_TopEdge       += 2 * BUTTONHEIGHT + 2 * INTERHEIGHT;
  2123.                 newgad.ng_Width            = app->appwin[WINDOW_SAVEAUDIO].maxsize[WIDTH] - XOFFSET - INTERWIDTH;
  2124.                 newgad.ng_GadgetText    = ls[MSG_SAVEAUDIO_SAVE];
  2125.                 newgad.ng_GadgetID        = GADGET_SAVEAUDIO_SAVE;
  2126.                 app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_SAVE] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, TAG_END);
  2127.  
  2128.                 success = TRUE;
  2129.             }
  2130.             break;
  2131.  
  2132.         case WINDOW_SAVING:
  2133.             if (app->appwin[WINDOW_SAVING].gadget = GetVecA(sizeof(struct Gadget *) * ANZ_GADGET_SAVING, MEMF_PUBLIC))
  2134.             {
  2135.                 int temp1, temp2;
  2136.  
  2137.                 temp1 = TextWidth("Transferred", /* ls[MSG_SAVING_TRANSFERRED], */app->font) + INTERWIDTH;
  2138.                 temp2 = temp1 + TextWidth("100 %", app->font);
  2139.                 widest = TextWidth(ls[MSG_SAVING_CANCEL], app->font);
  2140.  
  2141.                 if (temp2 > widest)
  2142.                     widest = temp2;
  2143.  
  2144.                 widest += BUTTONSPACE;
  2145.  
  2146.                 /* Maximalgrößen */
  2147.                 app->appwin[WINDOW_SAVING].maxsize[WIDTH]    = XOFFSET + widest + INTERWIDTH;
  2148.                 app->appwin[WINDOW_SAVING].maxsize[HEIGHT]    = YOFFSET + 2 * BUTTONHEIGHT + 2 * INTERHEIGHT + 2;
  2149.  
  2150.                 /* Der Prozent-Button */
  2151.                 newgad.ng_LeftEdge         = XOFFSET + temp1;
  2152.                 newgad.ng_TopEdge        = YOFFSET;
  2153.                 newgad.ng_Width            = widest - temp1;
  2154.                 newgad.ng_Height         = BUTTONHEIGHT;
  2155.                 newgad.ng_GadgetText    = "Transferred"; /* ls[MSG_SAVING_TRANSFERRED]; */
  2156.                 newgad.ng_GadgetID        = GADGET_SAVING_TRANSFERRED;
  2157.                 app->appwin[WINDOW_SAVING].gadget[GADGET_SAVING_TRANSFERRED] = gad = CreateGadget(TEXT_KIND, gad, &newgad, GTTX_Border, TRUE, TAG_END);
  2158.  
  2159.                 /* Der Cancel-Button */
  2160.                 newgad.ng_LeftEdge       -= temp1;
  2161.                 newgad.ng_TopEdge       += BUTTONHEIGHT + INTERHEIGHT;
  2162.                 newgad.ng_Width            = widest;
  2163.                 newgad.ng_GadgetText    = ls[MSG_SAVING_CANCEL];
  2164.                 newgad.ng_GadgetID        = GADGET_SAVING_CANCEL;
  2165.                 app->appwin[WINDOW_SAVING].gadget[GADGET_SAVING_CANCEL] = gad = CreateGadget(BUTTON_KIND, gad, &newgad, TAG_END);
  2166.  
  2167.                 success = TRUE;
  2168.             }
  2169.             break;
  2170.     }
  2171.     return (success);
  2172. }
  2173. BOOL MakeMenus(Application *app)
  2174. {
  2175.     BOOL success = FALSE;
  2176.     struct NewMenu *nmenu = NULL;
  2177.  
  2178.     WORD dircount = app->arexxdir ? ListLengthA(app->arexxdir) : 0;
  2179.  
  2180.     if (nmenu = GetVecA((59 + dircount) * sizeof(struct NewMenu), MEMF_PUBLIC | MEMF_CLEAR))
  2181.     {
  2182.         char *numbers[8] = {"0", "1", "2", "3", "4", "5", "6", "7"};
  2183.         int i;
  2184.  
  2185.         nmenu[0].nm_Type            = NM_TITLE;
  2186.         nmenu[0].nm_Label            = ls[MSG_PROJECT_MENU];
  2187.         nmenu[1].nm_Type            = NM_ITEM;
  2188.         nmenu[1].nm_Label            = ls[MSG_PROJECT_ABOUT];
  2189.         nmenu[1].nm_CommKey            = "?";
  2190.         nmenu[2].nm_Type            = NM_ITEM;
  2191.         nmenu[2].nm_Label            = NM_BARLABEL;
  2192.         nmenu[3].nm_Type            = NM_ITEM;
  2193.         nmenu[3].nm_Label            = ls[MSG_PROJECT_HIDE];
  2194.         nmenu[3].nm_CommKey            = "H";
  2195.         nmenu[4].nm_Type            = NM_ITEM;
  2196.         nmenu[4].nm_Label            = ls[MSG_PROJECT_QUIT];
  2197.         nmenu[4].nm_CommKey            = "Q";
  2198.  
  2199.         nmenu[5].nm_Type            = NM_TITLE;
  2200.         nmenu[5].nm_Label            = ls[MSG_CD_MENU];
  2201.         nmenu[6].nm_Type            = NM_ITEM;
  2202.         nmenu[6].nm_Label            = ls[MSG_CD_SELECTTITLE];
  2203.         nmenu[6].nm_CommKey            = "T";
  2204.         nmenu[7].nm_Type            = NM_ITEM;
  2205.         nmenu[7].nm_Label            = ls[MSG_CD_EDITPROGRAM];
  2206.         nmenu[7].nm_CommKey            = "P";
  2207.         nmenu[8].nm_Type            = NM_ITEM;
  2208.         nmenu[8].nm_Label            = ls[MSG_CD_EDITTITLES];
  2209.         nmenu[8].nm_CommKey            = "E";
  2210.         nmenu[9].nm_Type            = NM_ITEM;
  2211.         nmenu[9].nm_Label            = NM_BARLABEL;
  2212.         nmenu[10].nm_Type            = NM_ITEM;
  2213.         nmenu[10].nm_Label            = ls[MSG_CD_SETVOLUME];
  2214.         nmenu[10].nm_CommKey        = "V";
  2215.         nmenu[11].nm_Type            = NM_ITEM;
  2216.         nmenu[11].nm_Label            = ls[MSG_CD_SETAB];
  2217.         nmenu[11].nm_CommKey        = "A";
  2218.         nmenu[12].nm_Type            = NM_ITEM;
  2219.         nmenu[12].nm_Label            = ls[MSG_CD_SAVEAUDIO];
  2220.         nmenu[12].nm_Flags            = NM_ITEMDISABLED;
  2221.         nmenu[13].nm_Type            = NM_ITEM;
  2222.         nmenu[13].nm_Label            = NM_BARLABEL;
  2223.         nmenu[14].nm_Type            = NM_ITEM;
  2224.         nmenu[14].nm_Label            = ls[MSG_MENU_INFO];
  2225.  
  2226.         nmenu[15].nm_Type            = NM_TITLE;
  2227.         nmenu[15].nm_Label            = ls[MSG_DRIVE_MENU];
  2228.         nmenu[16].nm_Type            = NM_ITEM;
  2229.         nmenu[16].nm_Label            = ls[MSG_DRIVE_LUN];
  2230.         nmenu[17].nm_Type            = NM_SUB;
  2231.         nmenu[17].nm_Label            = nmenu[16].nm_CommKey            = numbers[0];
  2232.         nmenu[17].nm_Flags            = CHECKIT;
  2233.         nmenu[17].nm_MutualExclude    = 254;
  2234.         nmenu[18].nm_Type            = NM_SUB;
  2235.         nmenu[18].nm_Label            = nmenu[17].nm_CommKey            = numbers[1];
  2236.         nmenu[18].nm_Flags            = CHECKIT;
  2237.         nmenu[18].nm_MutualExclude    = 253;
  2238.         nmenu[19].nm_Type            = NM_SUB;
  2239.         nmenu[19].nm_Label            = nmenu[18].nm_CommKey            = numbers[2];
  2240.         nmenu[19].nm_Flags            = CHECKIT;
  2241.         nmenu[19].nm_MutualExclude    = 251;
  2242.         nmenu[20].nm_Type            = NM_SUB;
  2243.         nmenu[20].nm_Label            = nmenu[19].nm_CommKey            = numbers[3];
  2244.         nmenu[20].nm_Flags            = CHECKIT;
  2245.         nmenu[20].nm_MutualExclude    = 247;
  2246.         nmenu[21].nm_Type            = NM_SUB;
  2247.         nmenu[21].nm_Label            = nmenu[20].nm_CommKey            = numbers[4];
  2248.         nmenu[21].nm_Flags            = CHECKIT;
  2249.         nmenu[21].nm_MutualExclude    = 239;
  2250.         nmenu[22].nm_Type            = NM_SUB;
  2251.         nmenu[22].nm_Label            = nmenu[21].nm_CommKey            = numbers[5];
  2252.         nmenu[22].nm_Flags            = CHECKIT;
  2253.         nmenu[22].nm_MutualExclude    = 223;
  2254.         nmenu[23].nm_Type            = NM_SUB;
  2255.         nmenu[23].nm_Label            = nmenu[22].nm_CommKey            = numbers[6];
  2256.         nmenu[23].nm_Flags            = CHECKIT;
  2257.         nmenu[23].nm_MutualExclude    = 191;
  2258.         nmenu[24].nm_Type            = NM_SUB;
  2259.         nmenu[24].nm_Label            = nmenu[23].nm_CommKey            = numbers[7];
  2260.         nmenu[24].nm_Flags            = CHECKIT;
  2261.         nmenu[24].nm_MutualExclude    = 127;
  2262.         nmenu[25].nm_Type            = NM_ITEM;
  2263.         nmenu[25].nm_Label            = ls[MSG_DRIVE_UNIT];
  2264.         nmenu[26].nm_Type            = NM_SUB;
  2265.         nmenu[26].nm_Label            = numbers[0];
  2266.         nmenu[26].nm_Flags            = CHECKIT;
  2267.         nmenu[26].nm_MutualExclude    = 254;
  2268.         nmenu[27].nm_Type            = NM_SUB;
  2269.         nmenu[27].nm_Label            = numbers[1];
  2270.         nmenu[27].nm_Flags            = CHECKIT;
  2271.         nmenu[27].nm_MutualExclude    = 253;
  2272.         nmenu[28].nm_Type            = NM_SUB;
  2273.         nmenu[28].nm_Label            = numbers[2];
  2274.         nmenu[28].nm_Flags            = CHECKIT;
  2275.         nmenu[28].nm_MutualExclude    = 251;
  2276.         nmenu[29].nm_Type            = NM_SUB;
  2277.         nmenu[29].nm_Label            = numbers[3];
  2278.         nmenu[29].nm_Flags            = CHECKIT;
  2279.         nmenu[29].nm_MutualExclude    = 247;
  2280.         nmenu[30].nm_Type            = NM_SUB;
  2281.         nmenu[30].nm_Label            = numbers[4];
  2282.         nmenu[30].nm_Flags            = CHECKIT;
  2283.         nmenu[30].nm_MutualExclude    = 239;
  2284.         nmenu[31].nm_Type            = NM_SUB;
  2285.         nmenu[31].nm_Label            = numbers[5];
  2286.         nmenu[31].nm_Flags            = CHECKIT;
  2287.         nmenu[31].nm_MutualExclude    = 223;
  2288.         nmenu[32].nm_Type            = NM_SUB;
  2289.         nmenu[32].nm_Label            = numbers[6];
  2290.         nmenu[32].nm_Flags            = CHECKIT;
  2291.         nmenu[32].nm_MutualExclude    = 191;
  2292.         nmenu[33].nm_Type            = NM_SUB;
  2293.         nmenu[33].nm_Label            = numbers[7];
  2294.         nmenu[33].nm_Flags            = CHECKIT;
  2295.         nmenu[33].nm_MutualExclude    = 127;
  2296.         nmenu[34].nm_Type            = NM_ITEM;
  2297.         nmenu[34].nm_Label            = ls[MSG_DRIVE_DRIVELOCK];
  2298.         nmenu[34].nm_CommKey        = "L";
  2299.         nmenu[34].nm_Flags            = CHECKIT | MENUTOGGLE | (app->cdstr->cdx->cdx_Flags & SPECIALF_LOCKED ? CHECKED : 0);
  2300.         nmenu[35].nm_Type            = NM_ITEM;
  2301.         nmenu[35].nm_Label            = NM_BARLABEL;
  2302.         nmenu[36].nm_Type            = NM_ITEM;
  2303.         nmenu[36].nm_Label            = ls[MSG_DRIVE_OPEN];
  2304.         nmenu[36].nm_CommKey        = "<";
  2305.         nmenu[37].nm_Type            = NM_ITEM;
  2306.         nmenu[37].nm_Label            = ls[MSG_DRIVE_CLOSE];
  2307.         nmenu[37].nm_CommKey        = ">";
  2308.         nmenu[38].nm_Type            = NM_ITEM;
  2309.         nmenu[38].nm_Label            = ls[MSG_DRIVE_STOP];
  2310.         nmenu[38].nm_CommKey        = "!";
  2311.         nmenu[39].nm_Type            = NM_ITEM;
  2312.         nmenu[39].nm_Label            = NM_BARLABEL;
  2313.         nmenu[40].nm_Type            = NM_ITEM;
  2314.         nmenu[40].nm_Label            = ls[MSG_MENU_INFO];
  2315.  
  2316.         nmenu[41].nm_Type            = NM_TITLE;
  2317.         nmenu[41].nm_Label            = ls[MSG_FRONTEND_MENU];
  2318.         nmenu[42].nm_Type            = NM_ITEM;
  2319.         nmenu[42].nm_Label            = ls[MSG_FRONTEND_MWB];
  2320.         nmenu[42].nm_CommKey        = "M";
  2321.         nmenu[42].nm_Flags            = CHECKIT | MENUTOGGLE | (app->magicwbmode ? CHECKED : 0);
  2322.         nmenu[43].nm_Type            = NM_ITEM;
  2323.         nmenu[43].nm_Label            = ls[MSG_FRONTEND_GUIELEMENTS];
  2324.         nmenu[44].nm_Type            = NM_SUB;
  2325.         nmenu[44].nm_Label            = ls[MSG_FRONTEND_GUIELEMENTS_DIRECTCHOICE1];
  2326.         nmenu[44].nm_Flags            = CHECKIT | MENUTOGGLE | (app->flag_main & FLAG_MAIN_DIRECTCHOICE0 ? CHECKED : 0);
  2327.         nmenu[45].nm_Type            = NM_SUB;
  2328.         nmenu[45].nm_Label            = ls[MSG_FRONTEND_GUIELEMENTS_DIRECTCHOICE2];
  2329.         nmenu[45].nm_Flags            = CHECKIT | MENUTOGGLE | (app->flag_main & FLAG_MAIN_DIRECTCHOICE1 ? CHECKED : 0);
  2330.         nmenu[46].nm_Type            = NM_SUB;
  2331.         nmenu[46].nm_Label            = ls[MSG_FRONTEND_GUIELEMENTS_TITLE];
  2332.         nmenu[46].nm_Flags            = CHECKIT | MENUTOGGLE | (app->flag_main & FLAG_MAIN_TITLE ? CHECKED : 0);
  2333.         nmenu[47].nm_Type            = NM_SUB;
  2334.         nmenu[47].nm_Label            = ls[MSG_FRONTEND_GUIELEMENTS_TIT];
  2335.         nmenu[47].nm_Flags            = CHECKIT | MENUTOGGLE | (app->flag_main & FLAG_MAIN_TIME ? CHECKED : 0);
  2336.         nmenu[48].nm_Type            = NM_SUB;
  2337.         nmenu[48].nm_Label            = ls[MSG_FRONTEND_GUIELEMENTS_PMR];
  2338.         nmenu[48].nm_Flags            = CHECKIT | MENUTOGGLE | (app->flag_main & FLAG_MAIN_MODE ? CHECKED : 0);
  2339.         nmenu[49].nm_Type            = NM_SUB;
  2340.         nmenu[49].nm_Label            = ls[MSG_FRONTEND_GUIELEMENTS_PANEL];
  2341.         nmenu[49].nm_Flags            = CHECKIT | MENUTOGGLE | (app->flag_main & FLAG_MAIN_PANEL ? CHECKED : 0);
  2342.         nmenu[50].nm_Type            = NM_SUB;
  2343.         nmenu[50].nm_Label            = ls[MSG_FRONTEND_GUIELEMENTS_SLIDER];
  2344.         nmenu[50].nm_Flags            = CHECKIT | MENUTOGGLE | (app->flag_main & FLAG_MAIN_TRACKSLIDER ? CHECKED : 0);
  2345.         nmenu[51].nm_Type            = NM_ITEM;
  2346.         nmenu[51].nm_Label            = NM_BARLABEL;
  2347.         nmenu[52].nm_Type            = NM_ITEM;
  2348.         nmenu[52].nm_Label            = ls[MSG_FRONTEND_PUBSCREEN];
  2349.         nmenu[52].nm_CommKey        = "S";
  2350.         nmenu[53].nm_Type            = NM_ITEM;
  2351.         nmenu[53].nm_Label            = NM_BARLABEL;
  2352.         nmenu[54].nm_Type            = NM_ITEM;
  2353.         nmenu[54].nm_Label            = ls[MSG_FRONTEND_SNAPSHOTWINDOWS];
  2354.         nmenu[54].nm_CommKey        = "W";
  2355.  
  2356.         nmenu[55].nm_Type            = NM_TITLE;
  2357.         nmenu[55].nm_Label            = ls[MSG_AREXX_MENU];
  2358.         nmenu[56].nm_Type            = NM_ITEM;
  2359.         nmenu[56].nm_Label            = ls[MSG_AREXX_EXECUTESCRIPT];
  2360.         nmenu[56].nm_CommKey        = "X";
  2361.         nmenu[57].nm_Type            = NM_ITEM;
  2362.         nmenu[57].nm_Label            = NM_BARLABEL;
  2363.  
  2364.         nmenu[17 + app->cdstr->lun].nm_Flags    |= CHECKED;
  2365.         nmenu[26 + app->cdstr->unit].nm_Flags    |= CHECKED;
  2366.  
  2367.         /* Dafür der ganze Aufwand... */
  2368.         for (i = 0; i < dircount; i++)
  2369.         {
  2370.             nmenu[58 + i].nm_Type    = NM_ITEM;
  2371.             nmenu[58 + i].nm_Label    = ((struct DirNode *)FindNode(app->arexxdir, i))->dn_Name;
  2372.         }
  2373.  
  2374.         nmenu[58 + dircount].nm_Type = NM_END;
  2375.  
  2376.         if (app->menustrip = CreateMenus(nmenu, GTMN_FullMenu, TRUE, TAG_END))
  2377.         {
  2378.             LayoutMenus(app->menustrip, app->visualinfo, GTMN_NewLookMenus, TRUE, TAG_END);
  2379.             success = TRUE;
  2380.         }
  2381.         FreeVec(nmenu);
  2382.     }
  2383.  
  2384.     return (success);
  2385. }
  2386. void RemoveMenus(Application *app)
  2387. {
  2388.     WORD win;
  2389.  
  2390.     for (win = ANZ_WINDOWS - 1; win >= 0; win--)
  2391.         if (app->appwin[win].window) ClearMenuStrip(app->appwin[win].window);
  2392. }
  2393. void AttachMenus(Application *app)
  2394. {
  2395.     WORD win;
  2396.  
  2397.     for (win = ANZ_WINDOWS - 1; win >= 0; win--)
  2398.         if (app->appwin[win].window) ResetMenuStrip(app->appwin[win].window, app->menustrip);
  2399. }
  2400.