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