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