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