home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Utilities / ACDPlay / src / V1.5 / Events.c.BAK < prev    next >
Text File  |  1997-12-02  |  40KB  |  1,187 lines
  1. /* Events.c */
  2.  
  3. #include "Constants.h"
  4. #include "Locale.h"
  5.  
  6. #include <exec/types.h>
  7. #include <exec/memory.h>
  8. #include <exec/libraries.h>
  9. #include <intuition/intuition.h>
  10. #include <intuition/intuitionbase.h>
  11. #include <intuition/gadgetclass.h>
  12. #include <libraries/gadtools.h>
  13. #include <libraries/commodities.h>
  14. #include <libraries/asl.h>
  15. #include <devices/scsidisk.h>
  16. #include <devices/cd.h>
  17. #include <graphics/rastport.h>
  18. #include <pragma/screennotify_lib.h>
  19. #include "AsmLib/CD-ROM.h"
  20. #include "Structures/Application.h"
  21. #include "Structures/DirNode.h"
  22. #include "Structures/MyPubScreenNode.h"
  23.  
  24. #include <clib/exec_protos.h>
  25. #include <clib/dos_protos.h>
  26. #include <clib/commodities_protos.h>
  27. #include <clib/intuition_protos.h>
  28. #include <clib/gadtools_protos.h>
  29. #include <string.h>
  30. #include "ACDPlay_protos.h"
  31.  
  32. extern char *ls[ANZ_MSG];
  33.  
  34. BOOL HandleEvents(Application *app)
  35. {
  36.     struct IntuiMessage *imsg;
  37.     struct Gadget *gad;
  38.     struct Window *actwin;
  39.     USHORT code, qualifier;
  40.     ULONG class, seconds, micros;
  41.     BOOL done = FALSE;
  42.     BOOL exitloop = FALSE;
  43.     BOOL changegui = FALSE;
  44.     WORD win;
  45.     int i;
  46.  
  47.     while (imsg = GT_GetIMsg(app->idcmp))
  48.     {
  49.         /* Daten auslesen, damit Msg beantwortet werden kann */
  50.         class     = imsg->Class;
  51.         code      = imsg->Code;
  52.         qualifier = imsg->Qualifier;
  53.         seconds    = imsg->Seconds;
  54.         micros    = imsg->Micros;
  55.         gad        = (Gadget *)imsg->IAddress;
  56.  
  57.         actwin    = imsg->IDCMPWindow;
  58.  
  59.         /* Windownummer rausfinden */
  60.         for (i = 0; i < ANZ_WINDOWS; i++)
  61.             if (app->appwin[i].window == actwin)
  62.             {
  63.                 win = i;
  64.                 break;
  65.             }
  66.  
  67.         /* Msg beantworten */
  68.         GT_ReplyIMsg(imsg);
  69.  
  70.           switch (class)
  71.         {
  72.             case IDCMP_MENUPICK:
  73.                 while (code != MENUNULL)
  74.                 {
  75.                     switch (MENUNUM(code))    /* Menu-Nummer ermitteln */
  76.                     {
  77.                         case 0:        /* Projekt */
  78.                             switch (ITEMNUM(code))
  79.                             {
  80.                                   case 0:        /* "Über..."-Fenster */
  81.                                       OpenAppWin(app, WINDOW_ABOUT);
  82.                                       break;
  83.                                   case 2:        /* "Verbergen" */
  84.                                        CloseApplication(app);
  85.                                      CreateAppIcon(app);
  86.                                       exitloop = TRUE;
  87.                                       break;
  88.                                   case 3:        /* "Entfernen" */
  89.                                       done = TRUE;
  90.                                       break;
  91.                               }
  92.                               break;
  93.  
  94.                           case 1:        /* CD */
  95.                               switch (ITEMNUM(code))
  96.                               {
  97.                                 case 0: /* Titelauswahlfenster */
  98.                                     OpenAppWin(app, WINDOW_TITLES);
  99.                                       break;
  100.                                 case 1: /* Titelprogrammierung */
  101.                                       OpenAppWin(app, WINDOW_PROGRAM);
  102.                                       break;
  103.                                 case 2: /* Titeleingabe */
  104.                                     OpenAppWin(app, WINDOW_EDIT);
  105.                                     break;
  106.                                 case 4: /* Lautstärke */
  107.                                     OpenAppWin(app, WINDOW_VOLUME);
  108.                                       break;
  109.                                   case 5: /* A-B-Repeat */
  110.                                       OpenAppWin(app, WINDOW_AB);
  111.                                       break;
  112.                                 case 6: /* Save Audio */
  113.                                     OpenAppWin(app, WINDOW_SAVEAUDIO);
  114.                                     OpenAppWin(app, WINDOW_AB);
  115.                                     OpenAppWin(app, WINDOW_SAVING);
  116.                                     break;
  117.                                   case 8: /* Informationen */
  118.                                       OpenAppWin(app, WINDOW_CDINFO);
  119.                                       break;
  120.                             }
  121.                             break;
  122.  
  123.                         case 2:        /* Laufwerk */
  124.                             switch (ITEMNUM(code))
  125.                             {
  126.                                 case 0: /* LUN */
  127.                                 case 1: /* Unit */
  128.                                     {
  129.                                         struct CDxRequest *cdx = app->cdstr->cdx;
  130.                                         BOOL suc;
  131.  
  132.                                         if (ITEMNUM(code)==1)
  133.                                             suc = CDChangeDeviceA(cdx, SUBNUM(code), cdx->cdx_LUN);  /* neue Unit */
  134.                                         else
  135.                                             suc = CDChangeDeviceA(cdx, cdx->cdx_Unit, SUBNUM(code)); /* neue LUN */
  136.  
  137.                                         if (!suc)    /* Wechsel nicht erfolgreich? */
  138.                                         {
  139.                                             DisplayBeep(NULL);
  140.  
  141.                                             RemoveMenus(app);
  142.                                             ItemAddress(app->menustrip, code)->Flags &= ~CHECKED;
  143.                                             ItemAddress(app->menustrip, FULLMENUNUM(2,0,cdx->cdx_LUN))->Flags |= CHECKED;
  144.                                             ItemAddress(app->menustrip, FULLMENUNUM(2,1,cdx->cdx_Unit))->Flags |= CHECKED;
  145.                                             AttachMenus(app);
  146.                                         }
  147.                                         else
  148.                                         {
  149.                                             UpdateUnitLUN(app);
  150.                                         }
  151.                                     }
  152.                                     break;
  153.                                 case 2: /* Laufwerkssperre */
  154.                                     CDLockA(app->cdstr->cdx, (ItemAddress(app->menustrip, code)->Flags) & CHECKED);
  155.                                     break;
  156.                                   case 4: /* Öffnen */
  157.                                       CDEjectA(app->cdstr->cdx, TRUE);
  158.                                       break;
  159.                                   case 5: /* Schließen */
  160.                                       CDEjectA(app->cdstr->cdx, FALSE);
  161.                                       break;
  162.                                 case 6: /* Stoppen */
  163.                                     StopButton(app);
  164.                                     break;
  165.                                 case 8: /* Informationen */
  166.                                     OpenAppWin(app, WINDOW_DRIVEINFO);
  167.                                     break;
  168.                             }
  169.                             break;
  170.  
  171.                         case 3:        /* GUI */
  172.                             switch (ITEMNUM(code))
  173.                             {
  174.                                 case 0:    /* Magic-WB-Modus */
  175.                                     app->magicwbmode = (ItemAddress(app->menustrip, code)->Flags) & CHECKED;
  176.                                     changegui = TRUE;
  177.                                     break;
  178.                                 case 1:        /* GUI-Elemente */
  179.                                     switch (SUBNUM(code))
  180.                                     {
  181.                                         case 0:    /* Direktwahl 1-10 */
  182.                                             app->flag_main ^= FLAG_MAIN_DIRECTCHOICE0;
  183.                                             break;
  184.                                         case 1:    /* Direktwahl 11-20 */
  185.                                             app->flag_main ^= FLAG_MAIN_DIRECTCHOICE1;
  186.                                             break;
  187.                                         case 2:    /* Titel */
  188.                                             app->flag_main ^= FLAG_MAIN_TITLE;
  189.                                             break;
  190.                                         case 3:    /* Index/Spur/Zeit */
  191.                                             app->flag_main ^= FLAG_MAIN_TIME;
  192.                                             break;
  193.                                         case 4:    /* Spielmodus/Wiederholung */
  194.                                             app->flag_main ^= FLAG_MAIN_MODE;
  195.                                             break;
  196.                                         case 5:    /* Bedienungspanel */
  197.                                             app->flag_main ^= FLAG_MAIN_PANEL;
  198.                                             break;
  199.                                         case 6:    /* Trackslider */
  200.                                             app->flag_main ^= FLAG_MAIN_TRACKSLIDER;
  201.                                             break;
  202.                                     }
  203.                                     changegui = TRUE;
  204.                                     break;
  205.                                  case 3:        /* Public Screen */
  206.                                     OpenAppWin(app, WINDOW_PUBSCREEN);
  207.                                     break;
  208.                                 case 5:        /* Fixieren */
  209.                                     if (!SaveConfig(app, "ENVARC:acdplay.cfg") || !SaveConfig(app, "ENV:acdplay.cfg"))
  210.                                         ShowMsgA(ls[MSG_ERROR_TITLE], ls[MSG_NO_SAVECFGFILE], NULL);
  211.                                     break;
  212.                               }
  213.                               break;
  214.  
  215.                         case 4: /* ARexx */
  216.                             MakeBusy(app, TRUE);
  217.                             ActivateCxObj(app->broker, 0L);
  218.                             if (ITEMNUM(code) == 0)
  219.                             {
  220.                                 if (GetFileName(app, ASL_AREXX))
  221.                                 {
  222.                                     ExecuteARexxA(app->appasl[ASL_AREXX].pathname, app->arexx_mp, app);
  223.                                     exitloop = TRUE;
  224.                                 }
  225.                             }
  226.                             else
  227.                             {
  228.                                 char command[45];    /* 30 + "ARexx/" + Nullbyte */
  229.                                 strcpy(command, "ARexx/");
  230.                                 AddPart(command, ((struct DirNode *)FindNode(app->arexxdir, ITEMNUM(code) - 2))->dn_Name, 45);
  231.                                 ExecuteARexxA(command, app->arexx_mp, app);
  232.                                 exitloop = TRUE;
  233.                             }
  234.                             ActivateCxObj(app->broker, 1L);
  235.                             CDReadTOCA(app->cdstr->cdx);
  236.                             CDUpdateA(app->cdstr->cdx);
  237.                             MakeBusy(app, FALSE);
  238.                             break;
  239.                     }
  240.  
  241.                     if ((!exitloop) && (!done))
  242.                         code = (ItemAddress(app->menustrip, code))->NextSelect;
  243.                     else
  244.                         code = MENUNULL;
  245.                 }
  246.  
  247.                 if (changegui)        /* Fenster schließen und öffnen, um Änderungen */
  248.                 {                    /* am Layout durchzuführen */
  249.                     CloseAppWin(app, WINDOW_MAIN, FALSE);
  250.                     OpenAppWin(app, WINDOW_MAIN);
  251.                     actwin = app->appwin[WINDOW_MAIN].window
  252.                 }
  253.                 break;
  254.  
  255.             case IDCMP_CHANGEWINDOW:
  256.                 if (actwin->Flags & WFLG_ZOOMED)
  257.                 {
  258.                     app->appwin[win].minsize[LEFT]    = actwin->LeftEdge;
  259.                     app->appwin[win].minsize[TOP]    = actwin->TopEdge;
  260.  
  261.                 }
  262.                 else
  263.                 {
  264.                     app->appwin[win].maxsize[LEFT]    = actwin->LeftEdge;
  265.                     app->appwin[win].maxsize[TOP]    = actwin->TopEdge;
  266.                 }
  267.                 break;
  268.  
  269.             case IDCMP_REFRESHWINDOW:
  270.                 GT_BeginRefresh(actwin);
  271.                 GT_EndRefresh(actwin, TRUE);
  272.                 break;
  273.         }
  274.  
  275.         switch (win)
  276.         {
  277.             case WINDOW_MAIN:        /* Hauptfenster */
  278.                 switch (class)
  279.                 {
  280.                     static BOOL backward_pressed, forward_pressed;
  281.                     static WORD searched;
  282.  
  283.                     case IDCMP_RAWKEY:
  284.                         switch (code)
  285.                         {
  286.                             case 76:    /* Cursor hoch */
  287.                                 JumpBackwardButton(app);
  288.                                 break;
  289.                             case 77:    /* Cursor runter */
  290.                                 JumpForwardButton(app);
  291.                                 break;
  292.                             case 78:    /* Cursor rechts */
  293.                                 SearchForwardButton(app, 10);
  294.                                 break;
  295.                             case 79:    /* Cursor links */
  296.                                 SearchBackwardButton(app, 10);
  297.                                 break;
  298.                         }
  299.                         break;
  300.  
  301.                     case IDCMP_VANILLAKEY:
  302.                         switch (code)
  303.                         {
  304.                             case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
  305.                                 if ((qualifier & IEQUALIFIER_LSHIFT) || (qualifier & IEQUALIFIER_RSHIFT))
  306.                                     DirectChoice(app, code - 48 + 10);
  307.                                 else if ((qualifier & IEQUALIFIER_LALT) || (qualifier & IEQUALIFIER_RALT))
  308.                                     DirectChoice(app, code - 48 + 20);
  309.                                 else
  310.                                     DirectChoice(app, code - 48);
  311.                                 break;
  312.                             case '0':
  313.                                 if ((qualifier & IEQUALIFIER_LSHIFT) || (qualifier & IEQUALIFIER_RSHIFT))
  314.                                     DirectChoice(app, 20);
  315.                                 else if ((qualifier & IEQUALIFIER_LALT) || (qualifier & IEQUALIFIER_RALT))
  316.                                     DirectChoice(app, 30);
  317.                                 else
  318.                                     DirectChoice(app, 10);
  319.                                 break;
  320.                         }
  321.                         break;
  322.  
  323.                     case IDCMP_GADGETUP:
  324.                         switch (gad->GadgetID)
  325.                         {
  326.                             case GADGET_MAIN_DIRECTCHOICE0: case GADGET_MAIN_DIRECTCHOICE0 + 1: case GADGET_MAIN_DIRECTCHOICE0 + 2: case GADGET_MAIN_DIRECTCHOICE0 + 3: case GADGET_MAIN_DIRECTCHOICE0 + 4: case GADGET_MAIN_DIRECTCHOICE0 + 5: case GADGET_MAIN_DIRECTCHOICE0 + 6: case GADGET_MAIN_DIRECTCHOICE0 + 7: case GADGET_MAIN_DIRECTCHOICE0 + 8: case GADGET_MAIN_DIRECTCHOICE0 + 9:
  327.                             case GADGET_MAIN_DIRECTCHOICE1: case GADGET_MAIN_DIRECTCHOICE1 + 1: case GADGET_MAIN_DIRECTCHOICE1 + 2: case GADGET_MAIN_DIRECTCHOICE1 + 3: case GADGET_MAIN_DIRECTCHOICE1 + 4: case GADGET_MAIN_DIRECTCHOICE1 + 5: case GADGET_MAIN_DIRECTCHOICE1 + 6: case GADGET_MAIN_DIRECTCHOICE1 + 7: case GADGET_MAIN_DIRECTCHOICE1 + 8: case GADGET_MAIN_DIRECTCHOICE1 + 9:
  328.                                 DirectChoice(app, gad->GadgetID + 1 - GADGET_MAIN_DIRECTCHOICE0);
  329.                                 break;
  330.  
  331.                             case GADGET_MAIN_TIMESHOW:
  332.                                 app->cdstr->timemode++;
  333.                                 if (app->cdstr->timemode > TIMEMODE_ALLREM)
  334.                                     app->cdstr->timemode = TIMEMODE_TRACKCUR;
  335.  
  336.                                 DoTimeBuffer(app);
  337.                                 ChangeButtonText(app, WINDOW_MAIN, GADGET_MAIN_TIMESHOW, app->timeshowbuf);
  338.                                 // app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TIMESHOW] = ChangeButtonTextA(app, actwin, app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TIMESHOW - 1], app->timeshowbuf);
  339.                                 break;
  340.  
  341.                             case GADGET_MAIN_PLAYMODE:
  342.                                 if (code != app->cdstr->playmode)
  343.                                 {
  344.                                     /* Gegebenenfalls Reinitialisieren der Flags */
  345.                                     switch (app->cdstr->playmode)
  346.                                     {
  347.                                         case PLAYMODE_RNDCD:
  348.                                             InitRandomTracks(app->cdstr->cdtitles);
  349.                                             break;
  350.                                         case PLAYMODE_RNDPRG:
  351.                                             InitRandomTracks(app->cdstr->progtitles);
  352.                                             break;
  353.                                     }
  354.  
  355.                                     app->cdstr->playmode = code;
  356.  
  357.                                     switch (app->cdstr->playmode)
  358.                                     {
  359.                                         case PLAYMODE_CD:
  360.                                             switch (app->cdstr->active)
  361.                                             {
  362.                                                 case AUDIO_STAT_PLAYING:
  363.                                                 case AUDIO_STAT_PAUSED:
  364.                                                     CDPlayA(app->cdstr->cdx, app->cdstr->cdx->cdx_TOCData->FirstAudioTrack, 1);
  365.                                                     if (app->cdstr->active == AUDIO_STAT_PAUSED)
  366.                                                         CDPauseA(app->cdstr->cdx, TRUE);
  367.                                                     app->cdstr->useraction = TRUE;
  368.                                                     break;
  369.                                             }
  370.                                             break;
  371.  
  372.                                         case PLAYMODE_RNDCD:
  373.                                             switch(app->cdstr->active)
  374.                                             {
  375.                                                 case AUDIO_STAT_PLAYING:
  376.                                                 case AUDIO_STAT_PAUSED:
  377.                                                     CDPlayA(app->cdstr->cdx, GetRandomTrack(app), 1);
  378.                                                     if (app->cdstr->active == AUDIO_STAT_PAUSED)
  379.                                                         CDPauseA(app->cdstr->cdx, TRUE);
  380.                                                     app->cdstr->useraction = TRUE;
  381.                                                     break;
  382.                                             }
  383.                                             break;
  384.  
  385.                                         case PLAYMODE_PRG:
  386.                                         case PLAYMODE_RNDPRG:
  387.                                             switch (app->cdstr->active)
  388.                                             {
  389.                                                 case AUDIO_STAT_PLAYING:
  390.                                                 case AUDIO_STAT_PAUSED:
  391.                                                     if (IsListEmpty(app->cdstr->progtitles))
  392.                                                         CDStopA(app->cdstr->cdx);
  393.                                                     else
  394.                                                         ProgramStart(app);
  395.                                                     if (app->cdstr->active == AUDIO_STAT_PAUSED)
  396.                                                         CDPauseA(app->cdstr->cdx, TRUE);
  397.                                                     app->cdstr->useraction = TRUE;
  398.                                                     break;
  399.                                             }
  400.                                             break;
  401.                                     }
  402.                                 }
  403.                                 break;
  404.                             case GADGET_MAIN_REPEATMODE:
  405.                                 app->cdstr->repeatmode = code;
  406.                                 break;
  407.  
  408.                             case GADGET_MAIN_CDOUT:
  409.                                 EjectButton(app);
  410.                                 break;
  411.                             case GADGET_MAIN_JUMPBWRD:
  412.                                 JumpBackwardButton(app);
  413.                                 break;
  414.                             case GADGET_MAIN_JUMPFWRD:
  415.                                 JumpForwardButton(app);
  416.                                 break;
  417.                             case GADGET_MAIN_SRCHBWRD:
  418.                             case GADGET_MAIN_SRCHFWRD:
  419.                                 searched = 0;
  420.                                 if (app->cdstr->searchmode == SEARCHMODE_STANDARD)
  421.                                 {
  422.                                     backward_pressed = FALSE;
  423.                                     forward_pressed = FALSE;
  424.                                 }
  425.                                 else
  426.                                     CDFastModeA(app->cdstr->cdx, FASTMODE_OFF, app->cdstr->searchmode-1);
  427.                                 break;
  428.                             case GADGET_MAIN_STOP:
  429.                                 StopButton(app);
  430.                                 break;
  431.                             case GADGET_MAIN_PAUSE:
  432.                                 PauseButton(app);
  433.                                 break;
  434.                             case GADGET_MAIN_PLAY:
  435.                                 PlayButton(app);
  436.                                 break;
  437.                         /*    case GADGET_MAIN_TRACKSLIDER:
  438.                                 Trackslider(app, code);
  439.                                 break;*/
  440.                         }
  441.                         break;
  442.  
  443.                     case IDCMP_GADGETDOWN:
  444.                         switch (gad->GadgetID)
  445.                         {
  446.                             case GADGET_MAIN_SRCHBWRD:
  447.                                 if (app->cdstr->searchmode == SEARCHMODE_STANDARD)
  448.                                     backward_pressed = TRUE;
  449.                                 else
  450.                                 {
  451.                                     CDFastModeA(app->cdstr->cdx, FASTMODE_BACKWARD, app->cdstr->searchmode-1);
  452.                                     searched = 1;
  453.                                 }
  454.                                 break;
  455.                             case GADGET_MAIN_SRCHFWRD:
  456.                                 if (app->cdstr->searchmode == SEARCHMODE_STANDARD)
  457.                                     forward_pressed = TRUE;
  458.                                 else
  459.                                 {
  460.                                     CDFastModeA(app->cdstr->cdx, FASTMODE_FORWARD, app->cdstr->searchmode-1);
  461.                                     searched = 1;
  462.                                 }
  463.                                 break;
  464.                         }
  465.                         break;
  466.  
  467.                     case IDCMP_MOUSEBUTTONS:
  468.                         if (code == SELECTUP)
  469.                         {
  470.                             if (app->cdstr->searchmode == SEARCHMODE_STANDARD)
  471.                             {
  472.                                 backward_pressed = FALSE;
  473.                                 forward_pressed = FALSE;
  474.                             }
  475.                             else if (searched)
  476.                                 CDFastModeA(app->cdstr->cdx, FASTMODE_OFF, app->cdstr->searchmode-1);
  477.                             searched = 0;
  478.                         }
  479.                         break;
  480.  
  481.                     case IDCMP_CLOSEWINDOW:
  482.                         if (app->flag_tool & FLAG_TOOL_QUITONCLOSE)
  483.                         {
  484.                             done = TRUE;
  485.                         }
  486.                         else
  487.                         {
  488.                             CloseApplication(app);
  489.                             CreateAppIcon(app);
  490.                             exitloop = TRUE;
  491.                         }
  492.                         break;
  493.  
  494.                     case IDCMP_MOUSEMOVE:
  495.                         if (gad->GadgetID == GADGET_MAIN_TRACKSLIDER)
  496.                         {
  497.                             Trackslider(app, code);
  498.                         }
  499.                         break;
  500.  
  501.                     case IDCMP_INTUITICKS:
  502.                         if (backward_pressed || forward_pressed)
  503.                         {
  504.                             WORD value;
  505.                             if (searched < 10)
  506.                                 value = 2;
  507.                             else if (searched > 9 && searched < 20)
  508.                                 value = 4;
  509.                             else if (searched > 19 && searched < 30)
  510.                                 value = 8;
  511.                             else if (searched > 29 && searched < 40)
  512.                                 value = 16;
  513.                             else if (searched > 39 && searched < 50)
  514.                                 value = 32;
  515.                             else
  516.                                 value = 64;
  517.  
  518.                             searched++;
  519.  
  520.                             if (backward_pressed) SearchBackwardButton(app, value);
  521.                             else SearchForwardButton(app, value);
  522.                         }
  523.  
  524.                         /* Hier wird alles ziemlich aktualisiert.          */
  525.                         /* Ich denke, daß das ziemlich wichtig ist.           */
  526.                         /* Man hat dann wirklich das Gefühl, daß schneller */
  527.                         /* gespult wird. */
  528.                         /* Ich hoffe, es ist nicht zu rechenzeitintensiv.. */
  529.                         /* Allerdings spult man ja auch nicht andauernd... */
  530.  
  531.                         if (searched)
  532.                         {
  533.                             CDUpdateA(app->cdstr->cdx);
  534.                             UpdateGadgets(app);
  535.                         }
  536.                         break;
  537.                 }
  538.                 break;
  539.  
  540.             case WINDOW_ABOUT:        /* Über-Fenster */
  541.                 switch (class)
  542.                 {
  543.                     case IDCMP_GADGETUP:
  544.                     case IDCMP_CLOSEWINDOW:
  545.                         CloseAppWin(app, WINDOW_ABOUT, TRUE);
  546.                         exitloop = TRUE;    /* Damit nicht mehr auf den IDCMP zugegriffen
  547.                                             wird, sprich, damit ACDPlay nicht abstürzt */
  548.                         break;
  549.  
  550.                     case IDCMP_INTUITICKS:
  551.                         UpdateScrollObject(app->scroller, app->appwin[WINDOW_ABOUT].window);
  552.                         break;
  553.                 }
  554.                 break;
  555.  
  556.             case WINDOW_CDINFO:        /* CD-Fenster */
  557.                 switch (class)
  558.                 {
  559.                     case IDCMP_GADGETUP:
  560.                     case IDCMP_CLOSEWINDOW:
  561.                         CloseAppWin(app, WINDOW_CDINFO, TRUE);
  562.                         exitloop = TRUE;    /* Damit nicht mehr auf den IDCMP zugegriffen
  563.                                             wird, sprich, damit ACDPlay nicht abstürzt */
  564.                         break;
  565.  
  566.                     case IDCMP_NEWSIZE:
  567.                         ManageNewSize(app, WINDOW_CDINFO);
  568.                         break;
  569.                 }
  570.                 break;
  571.  
  572.             case WINDOW_DRIVEINFO:        /* Laufwerks-Fenster */
  573.                 switch (class)
  574.                 {
  575.                     case IDCMP_GADGETUP:
  576.                     case IDCMP_CLOSEWINDOW:
  577.                         CloseAppWin(app, WINDOW_DRIVEINFO, TRUE);
  578.                         exitloop = TRUE;    /* Damit nicht mehr auf den IDCMP zugegriffen
  579.                                             wird, sprich, damit ACDPlay nicht abstürzt */
  580.                         break;
  581.  
  582.                     case IDCMP_NEWSIZE:
  583.                         ManageNewSize(app, WINDOW_DRIVEINFO);
  584.                         break;
  585.                 }
  586.                 break;
  587.  
  588.             case WINDOW_PUBSCREEN:        /* Pubscreen-Fenster */
  589.                 switch (class)
  590.                 {
  591.                     case IDCMP_GADGETUP:
  592.                         switch (gad->GadgetID)
  593.                         {
  594.                             case GADGET_PUBSCREEN_LISTVIEW:
  595.                                 {
  596.                                     static ULONG startseconds, startmicros;
  597.  
  598.                                     if (DoubleClick(startseconds, startmicros, seconds, micros))
  599.                                     {
  600.                                         if (strcmp(app->pubscreenname, ((MyPubScreenNode *)FindNode(app->pubscreenlist, code))->mpsn_pubscreenname))
  601.                                         {
  602.                                             strcpy(app->pubscreenname, ((MyPubScreenNode *)FindNode(app->pubscreenlist, code))->mpsn_pubscreenname);
  603.                                             CloseAppWin(app, WINDOW_PUBSCREEN, TRUE);
  604.                                             CloseApplication(app);
  605.                                             OpenApplication(app);
  606.                                         }
  607.                                         else CloseAppWin(app, WINDOW_PUBSCREEN, TRUE);
  608.                                         exitloop = TRUE;
  609.                                     }
  610.                                     else
  611.                                     {
  612.                                         startseconds     = seconds;
  613.                                         startmicros        = micros;
  614.                                     }
  615.                                 }
  616.                                 break;
  617.  
  618.                             case GADGET_PUBSCREEN_UPDATE:
  619.                                 GetPubScreenList(app);
  620.                                 break;
  621.                         }
  622.                         break;
  623.                     case IDCMP_CLOSEWINDOW:
  624.                         CloseAppWin(app, WINDOW_PUBSCREEN, TRUE);
  625.                         exitloop = TRUE;    /* Damit nicht mehr auf den IDCMP zugegriffen
  626.                                             wird, sprich, damit ACDPlay nicht abstürzt */
  627.                         break;
  628.                     case IDCMP_NEWSIZE:
  629.                         ManageNewSize(app, WINDOW_PUBSCREEN);
  630.                         break;
  631.                 }
  632.                 break;
  633.  
  634.             case WINDOW_TITLES:        /* Titelauswahl-Fenster */
  635.                 switch (class)
  636.                 {
  637.                     case IDCMP_GADGETUP:
  638.                         {
  639.                             static ULONG startseconds, startmicros;
  640.  
  641.                             if (DoubleClick(startseconds, startmicros, seconds, micros))
  642.                                 DirectChoice(app, code + 1);
  643.                             else
  644.                             {
  645.                                 startseconds     = seconds;
  646.                                 startmicros        = micros;
  647.                             }
  648.                         }
  649.                         break;
  650.                     case IDCMP_CLOSEWINDOW:
  651.                         CloseAppWin(app, WINDOW_TITLES, TRUE);
  652.                         exitloop = TRUE;    /* Damit nicht mehr auf den IDCMP zugegriffen
  653.                                             wird, sprich, damit ACDPlay nicht abstürzt */
  654.                         break;
  655.                     case IDCMP_NEWSIZE:
  656.                         ManageNewSize(app, WINDOW_TITLES);
  657.                         break;
  658.                 }
  659.                 break;
  660.  
  661.             case WINDOW_EDIT:        /* Titeleingabe-Fenster */
  662.                 switch (class)
  663.                 {
  664.                     case IDCMP_GADGETUP:
  665.                         {
  666.                             SHORT anzvisible;        /* Wieviele Einträge im LV zu sehen */
  667.  
  668.                             switch(gad->GadgetID)    /* Eintrag merken */
  669.                             {
  670.                                 case GADGET_EDIT_TITLE:
  671.                                     if (app->appwin[WINDOW_CDINFO].window)
  672.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TITLE], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, NULL, TAG_END);
  673.                                     strncpy(app->cdstr->cdname, ((struct StringInfo *)gad->SpecialInfo)->Buffer, MAXCDNAME);
  674.                                     if (app->appwin[WINDOW_CDINFO].window)
  675.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TITLE], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, app->cdstr->cdname, TAG_END);
  676.                                     break;
  677.                                 case GADGET_EDIT_ARTIST:
  678.                                     if (app->appwin[WINDOW_CDINFO].window)
  679.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_AUTHOR], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, NULL, TAG_END);
  680.                                     strncpy(app->cdstr->artistname, ((struct StringInfo *)gad->SpecialInfo)->Buffer, MAXARTISTNAME);
  681.                                     if (app->appwin[WINDOW_CDINFO].window)
  682.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_AUTHOR], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, app->cdstr->artistname, TAG_END);
  683.                                     break;
  684.                                 case GADGET_EDIT_LISTVIEW:
  685.                                     if (app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE]->Flags & GFLG_DISABLED)
  686.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL, GA_Disabled, FALSE, TAG_END);
  687.                                     ActivateGadget(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL);
  688.  
  689.                                     /* String ggf. löschen */
  690.                                     if (IsDefaultTitle(((struct StringInfo *)app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE]->SpecialInfo)->Buffer, code + 1))
  691.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, NULL, TAG_END);
  692.  
  693.                                     app->edit_pos = code;
  694.                                     break;
  695.                                 case GADGET_EDIT_TRACKTITLE:
  696.                                     /* Titel-Gadget in WINDOW_MAIN */
  697.                                     if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW] && (app->edit_pos + 1) == app->cdstr->cur_track)
  698.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, NULL, TAG_END);
  699.                                     /* Listen */
  700.                                     if (app->appwin[WINDOW_TITLES].window) GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Labels, ~0, TAG_END);
  701.                                     GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Labels, ~0, TAG_END);
  702.                                     if (app->appwin[WINDOW_PROGRAM].window)
  703.                                     {
  704.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVCD], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, ~0, TAG_END);
  705.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVPRG], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, ~0, TAG_END);
  706.                                     }
  707.                                     strncpy(FindNode(app->cdstr->cdtitles, app->edit_pos)->ln_Name, ((struct StringInfo *)gad->SpecialInfo)->Buffer, MAXTITLENAME);
  708.                                     /* Listen */
  709.                                     if (app->appwin[WINDOW_TITLES].window) GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Labels, app->cdstr->cdtitles, TAG_END);
  710.                                     GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Labels, app->cdstr->cdtitles, TAG_END);
  711.                                     if (app->appwin[WINDOW_PROGRAM].window)
  712.                                     {
  713.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVCD], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, app->cdstr->cdtitles, TAG_END);
  714.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVPRG], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, app->cdstr->progtitles, TAG_END);
  715.                                     }
  716.                                     /* Titel-Gadget in WINDOW_MAIN */
  717.                                     if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW] && (app->edit_pos + 1) == app->cdstr->cur_track)
  718.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, (FindNode(app->cdstr->cdtitles, app->cdstr->cur_track - 1))->ln_Name, TAG_END);
  719.  
  720.                                     if (app->edit_pos + 1 < app->cdstr->num_track)
  721.                                     {
  722.                                         app->edit_pos++;
  723.  
  724.                                         anzvisible = (app->appwin[WINDOW_EDIT].maxsize[HEIGHT] - YOFFSET - 4 * BUTTONHEIGHT - 4 * INTERHEIGHT - 2 - 4) / app->font->ta_YSize;
  725.  
  726.                                         GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Selected, app->edit_pos, TAG_END);
  727.                                         if (app->edit_pos > anzvisible - 1)
  728.                                             GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Top, app->edit_pos - anzvisible + 1, TAG_END);
  729.                                         ActivateGadget(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL);
  730.  
  731.                                         /* String ggf. löschen */
  732.                                         if (IsDefaultTitle(((struct StringInfo *)app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE]->SpecialInfo)->Buffer, app->edit_pos + 1))
  733.                                             GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, NULL, TAG_END);
  734.                                     }
  735.                                     break;
  736.                                 case GADGET_EDIT_SAVE:
  737.                                     if (SaveTitles(app))
  738.                                     {
  739.                                         CloseAppWin(app, WINDOW_EDIT, TRUE);
  740.                                         exitloop = TRUE;
  741.                                     }
  742.                                     else
  743.                                         ShowMsgA(ls[MSG_ERROR_TITLE], ls[MSG_NOSAVE_TITLES], NULL);
  744.  
  745.                                     break;
  746.                             }
  747.                             if (gad->GadgetID == GADGET_EDIT_TITLE || gad->GadgetID == GADGET_EDIT_ARTIST)
  748.                             {
  749.                                 /* Window-Titel updaten */
  750.                                 UpdateWinTitle(app);
  751.                             }
  752.                         }
  753.                         break;
  754.                     case IDCMP_CLOSEWINDOW:
  755.                         CloseAppWin(app, WINDOW_EDIT, TRUE);
  756.                         exitloop = TRUE;    /* Damit nicht mehr auf den IDCMP zugegriffen
  757.                                             wird, sprich, damit ACDPlay nicht abstürzt */
  758.                         break;
  759.  
  760.                     case IDCMP_NEWSIZE:
  761.                         ManageNewSize(app, WINDOW_EDIT);
  762.                         break;
  763.                 }
  764.                 break;
  765.  
  766.             case WINDOW_PROGRAM:        /* Programmierfenster */
  767.                 switch (class)
  768.                 {
  769.                     case IDCMP_GADGETUP:
  770.                         switch(gad->GadgetID)
  771.                         {
  772.                             case GADGET_PROGRAM_LVCD:
  773.                                 {
  774.                                     static ULONG startseconds, startmicros;
  775.  
  776.                                     if (DoubleClick(startseconds, startmicros, seconds, micros))
  777.                                         ProgramAppendElement(app, code + 1);
  778.                                     else
  779.                                     {
  780.                                         startseconds     = seconds;
  781.                                         startmicros        = micros;
  782.                                     }
  783.                                 }
  784.                                 break;
  785.  
  786.                             case GADGET_PROGRAM_LVPRG:
  787.                                 {
  788.                                     static ULONG startseconds, startmicros;
  789.  
  790.                                     if (DoubleClick(startseconds, startmicros, seconds, micros))
  791.                                         ProgramDeleteElement(app, code);
  792.                                     else
  793.                                     {
  794.                                         startseconds     = seconds;
  795.                                         startmicros        = micros;
  796.                                     }
  797.                                 }
  798.                                 break;
  799.  
  800.                             case GADGET_PROGRAM_COPYALL:
  801.                                 ProgramCopyAll(app);
  802.                                 break;
  803.                             case GADGET_PROGRAM_DEL:
  804.                                 ProgramDelete(app);
  805.                                 break;
  806.                             case GADGET_PROGRAM_LOAD:
  807.                                 ProgramLoad(app);
  808.                                 break;
  809.                             case GADGET_PROGRAM_SAVE:
  810.                                 if (!ProgramSave(app))
  811.                                     ShowMsgA(ls[MSG_ERROR_TITLE], ls[MSG_NOSAVE_PROGRAM], NULL);
  812.                                 break;
  813.                         }
  814.                         break;
  815.                     case IDCMP_CLOSEWINDOW:
  816.                         CloseAppWin(app, WINDOW_PROGRAM, TRUE);
  817.                         exitloop = TRUE;
  818.                         break;
  819.  
  820.                     case IDCMP_NEWSIZE:
  821.                         ManageNewSize(app, WINDOW_PROGRAM);
  822.                         break;
  823.                 }
  824.                 break;
  825.  
  826.             case WINDOW_VOLUME:
  827.                 switch (class)
  828.                 {
  829.                     case IDCMP_MOUSEMOVE:
  830.                         switch (gad->GadgetID)
  831.                         {
  832.                             case GADGET_VOLUME_LEFT:
  833.                                 app->cdstr->cdx->cdx_Volume[0] = code;
  834.                                 break;
  835.                             case GADGET_VOLUME_RIGHT:
  836.                                 app->cdstr->cdx->cdx_Volume[1] = code;
  837.                                 break;
  838.                             case GADGET_VOLUME_MASTER:
  839.                                 {
  840.                                     /* Differenz die für links/rechts zum Masterslider addiert/subtrahiert wird */
  841.                                     WORD diff = (code && code!=255)?(app->cdstr->cdx->cdx_Volume[0] - app->cdstr->cdx->cdx_Volume[1])/2:0;
  842.                                     app->cdstr->cdx->cdx_Volume[0] = (app->cdstr->cdx->cdx_Flags & SPECIALF_ATAPI)?(UBYTE)code:(UBYTE)FitInteger(code + diff, 0, 255);
  843.                                     app->cdstr->cdx->cdx_Volume[1] = (app->cdstr->cdx->cdx_Flags & SPECIALF_ATAPI)?(UBYTE)code:(UBYTE)FitInteger(code - diff, 0, 255);
  844.                                     GT_SetGadgetAttrs(app->appwin[WINDOW_VOLUME].gadget[GADGET_VOLUME_LEFT], app->appwin[WINDOW_VOLUME].window, NULL, GTSL_Level, app->cdstr->cdx->cdx_Volume[0], TAG_END);
  845.                                     GT_SetGadgetAttrs(app->appwin[WINDOW_VOLUME].gadget[GADGET_VOLUME_RIGHT], app->appwin[WINDOW_VOLUME].window, NULL, GTSL_Level, app->cdstr->cdx->cdx_Volume[1], TAG_END);
  846.                                 }
  847.                                 break;
  848.                         }
  849.                         if (gad->GadgetID != GADGET_VOLUME_MASTER)
  850.                             GT_SetGadgetAttrs(app->appwin[WINDOW_VOLUME].gadget[GADGET_VOLUME_MASTER], app->appwin[WINDOW_VOLUME].window, NULL, GTSL_Level, (app->cdstr->cdx->cdx_Volume[0]+app->cdstr->cdx->cdx_Volume[1])/2, TAG_END);
  851.  
  852.                         CDVolumeA(app->cdstr->cdx, SET_VOLUME);
  853.                         break;
  854.                     case IDCMP_CLOSEWINDOW:
  855.                         CloseAppWin(app, WINDOW_VOLUME, TRUE);
  856.                         exitloop = TRUE;
  857.                         break;
  858.                     case IDCMP_NEWSIZE:
  859.                         ManageNewSize(app, WINDOW_VOLUME);
  860.                         /* RefreshGList() reicht nicht */
  861.                         GT_RefreshWindow(app->appwin[WINDOW_VOLUME].window, NULL);
  862.                         break;
  863.                 }
  864.                 break;
  865.  
  866.             case WINDOW_AB:
  867.                 switch (class)
  868.                 {
  869.                     case IDCMP_GADGETUP:
  870.                         switch(gad->GadgetID)
  871.                         {
  872.                             case GADGET_AB_A:
  873.                                 CDUpdateA(app->cdstr->cdx);
  874.                                 app->cdstr->a_track = app->cdstr->cdx->cdx_CurrentTrack;
  875.                                 app->cdstr->a_adr    = app->cdstr->cdx->cdx_CurrentRelAddr + app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->a_track].Address;
  876.                                 break;
  877.                             case GADGET_AB_B:
  878.                                 CDUpdateA(app->cdstr->cdx);
  879.                                 app->cdstr->b_track = app->cdstr->cdx->cdx_CurrentTrack;
  880.                                 app->cdstr->b_adr    = app->cdstr->cdx->cdx_CurrentRelAddr + app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->b_track].Address;
  881.                                 break;
  882.                             case GADGET_AB_A_TIME:
  883.                             case GADGET_AB_B_TIME:
  884.                                 {
  885.                                     char *str = (char *)((struct StringInfo *)gad->SpecialInfo)->Buffer;
  886.                                     short mins, secs, frms;
  887.  
  888.                                     str[2] = 0;
  889.                                     mins = FitInteger(atoi(str), 0, 99);
  890.                                     str[5] = 0;
  891.                                     secs = FitInteger(atoi(str + 3), 0, 59);
  892.                                     frms = FitInteger(atoi(str + 6), 0, 74);
  893.  
  894.                                     if (gad->GadgetID == GADGET_AB_A_TIME)
  895.                                         app->cdstr->a_adr = FitInteger(mins * 60 * 75 + secs * 75 + frms, 0, app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->a_track + 1].Address - app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->a_track].Address) + app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->a_track].Address;
  896.                                     else
  897.                                         app->cdstr->b_adr = FitInteger(mins * 60 * 75 + secs * 75 + frms, 0, app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->b_track + 1].Address - app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->b_track].Address) + app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->b_track].Address;
  898.                                 }
  899.                                 break;
  900.                             case GADGET_AB_A_TRACK:
  901.                             case GADGET_AB_B_TRACK:
  902.                                 {
  903.                                     short entry = FitInteger(((struct StringInfo *)gad->SpecialInfo)->LongInt, 1, app->cdstr->num_track);
  904.  
  905.                                     /* Überprüfen, ob die Zeit-Angabe noch stimmt */
  906.                                     if (gad->GadgetID == GADGET_AB_A_TRACK)
  907.                                     {
  908.                                         app->cdstr->a_adr = FitInteger(app->cdstr->a_adr - app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->a_track].Address, 0, app->cdstr->cdx->cdx_TOCData->Entry[entry + 1].Address - app->cdstr->cdx->cdx_TOCData->Entry[entry].Address) + app->cdstr->cdx->cdx_TOCData->Entry[entry].Address;
  909.                                         app->cdstr->a_track = entry;
  910.                                     }
  911.                                     else
  912.                                     {
  913.                                         app->cdstr->b_adr = FitInteger(app->cdstr->b_adr - app->cdstr->cdx->cdx_TOCData->Entry[app->cdstr->b_track].Address, 0,  app->cdstr->cdx->cdx_TOCData->Entry[entry + 1].Address - app->cdstr->cdx->cdx_TOCData->Entry[entry].Address) + app->cdstr->cdx->cdx_TOCData->Entry[entry].Address;
  914.                                         app->cdstr->b_track = entry;
  915.                                     }
  916.                                 }
  917.                                 break;
  918.                         }
  919.  
  920.                         /* Anzeigen aktualisieren */
  921.                         DoABBuffer(app);
  922.                         DoSizeBuffer(app);
  923.                         break;
  924.  
  925.                     case IDCMP_CLOSEWINDOW:
  926.                         CloseAppWin(app, WINDOW_AB, TRUE);
  927.                         exitloop = TRUE;
  928.                         break;
  929.                     case IDCMP_NEWSIZE:
  930.                         {
  931.                             /* Alles retten */
  932.                             char time_a[9], time_b[9];
  933.                             UBYTE track_a = ((struct StringInfo *)app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TRACK]->SpecialInfo)->LongInt;
  934.                             UBYTE track_b = ((struct StringInfo *)app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TRACK]->SpecialInfo)->LongInt;
  935.                             strcpy(time_a, ((struct StringInfo *)app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TIME]->SpecialInfo)->Buffer);
  936.                             strcpy(time_b, ((struct StringInfo *)app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TIME]->SpecialInfo)->Buffer);
  937.  
  938.                             ManageNewSize(app, WINDOW_AB);
  939.  
  940.                             /* Alles restaurieren */
  941.                             GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TRACK], app->appwin[WINDOW_AB].window, NULL, GTIN_Number, track_a, TAG_END);
  942.                             GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TRACK], app->appwin[WINDOW_AB].window, NULL, GTIN_Number, track_b, TAG_END);
  943.                             GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TIME], app->appwin[WINDOW_AB].window, NULL, GTST_String, time_a, TAG_END);
  944.                             GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TIME], app->appwin[WINDOW_AB].window, NULL, GTST_String, time_b, TAG_END);
  945.                         }
  946.                         break;
  947.                 }
  948.                 break;
  949.  
  950.             case WINDOW_SAVEAUDIO:        /* Audio-Save-Fenster */
  951.                 switch (class)
  952.                 {
  953.                     case IDCMP_GADGETUP:
  954.                         switch(gad->GadgetID)
  955.                         {
  956.                             case GADGET_SAVEAUDIO_FORMAT:
  957.                                 app->cdstr->fileformat = code;
  958.                                 break;
  959.  
  960.                             case GADGET_SAVEAUDIO_FILENAME:
  961.                                 strcpy(app->appasl[ASL_SAVEAUDIO].pathname, ((struct StringInfo *)app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FILENAME]->SpecialInfo)->Buffer);
  962.  
  963.                                 /* In Ordner- und Dateiname zerlegen */
  964.                                 strncpy(app->appasl[ASL_SAVEAUDIO].filename, FilePart(app->appasl[ASL_SAVEAUDIO].pathname), FILENAMELENGTH);
  965.                                 i = (int)(PathPart(app->appasl[ASL_SAVEAUDIO].pathname) - (STRPTR)app->appasl[ASL_SAVEAUDIO].pathname);
  966.                                 strncpy(app->appasl[ASL_SAVEAUDIO].dirname, app->appasl[ASL_SAVEAUDIO].pathname, i);
  967.  
  968.                                 /* dirname hat noch kein Nullzeichen... */
  969.                                 app->appasl[ASL_SAVEAUDIO].dirname[i] = 0;
  970.                                 break;
  971.  
  972.                             case GADGET_SAVEAUDIO_GETFILE:
  973.                                 if (GetFileName(app, ASL_SAVEAUDIO))
  974.                                      GT_SetGadgetAttrs(app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FILENAME], app->appwin[WINDOW_SAVEAUDIO].window, NULL, GTST_String, app->appasl[ASL_SAVEAUDIO].pathname, TAG_END);
  975.                                 break;
  976.  
  977.                             case GADGET_SAVEAUDIO_SAVE:
  978.                                 /* Überprüfen, ob noch genug Platz ist */
  979.                                 if (CalcAudioSize(app->cdstr->a_adr, app->cdstr->b_adr, 44100) <= ExamineDiskSpace(app->appasl[ASL_SAVEAUDIO].dirname)) {
  980.                                         CopyRange(app);
  981.                                 }
  982.                                 else {
  983.                                         struct EasyStruct req = {
  984.                                                 sizeof(struct EasyStruct),    /* es_StructSize */
  985.                                                 0,                            /* es_Flags */
  986.                                                 ls[MSG_WARNING_TITLE],        /* es_Title */
  987.                                                 ls[MSG_NO_DISKSPACE],        /* es_TextFormat */
  988.                                                 ls[MSG_YESNO_REQ] };        /* es_GadFormat */
  989.  
  990.                                         if (EasyRequestArgs(NULL, &req, NULL, NULL))
  991.                                                 CopyRange(app);
  992.                                 }
  993.                                 break;
  994.                         }
  995.                         break;
  996.  
  997.                     case IDCMP_CLOSEWINDOW:
  998.                         CloseAppWin(app, WINDOW_SAVEAUDIO, TRUE);
  999.                         exitloop = TRUE;    /* Damit nicht mehr auf den IDCMP zugegriffen
  1000.                                             wird, sprich, damit ACDPlay nicht abstürzt */
  1001.                         break;
  1002.                     case IDCMP_NEWSIZE:
  1003.                         {
  1004.                             char tempstr[DISKPATHLENGTH + 1];
  1005.                             strcpy(tempstr, ((struct StringInfo *)app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FILENAME]->SpecialInfo)->Buffer);
  1006.                             ManageNewSize(app, WINDOW_SAVEAUDIO);
  1007.                             GT_SetGadgetAttrs(app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FILENAME], app->appwin[WINDOW_SAVEAUDIO].window, NULL, GTST_String, tempstr, TAG_END);
  1008.                         }
  1009.                         break;
  1010.                 }
  1011.                 break;
  1012.  
  1013.             case WINDOW_SAVING:        /* Zustandsanzeige für Audiosaving */
  1014.                 switch (class)
  1015.                 {
  1016.                     case IDCMP_GADGETUP:
  1017.                         switch(gad->GadgetID)
  1018.                         {
  1019.                             case GADGET_SAVING_CANCEL:
  1020.                                 CloseAppWin(app, WINDOW_SAVING, TRUE);
  1021.                                 exitloop = TRUE;
  1022.                                 break;
  1023.                         }
  1024.                         break;
  1025.                 }
  1026.                 break;
  1027.         }
  1028.  
  1029.         if (exitloop || done) break;        /* while-Schleife gegebenenfalls beenden */
  1030.     }
  1031.     return (done);
  1032. }
  1033.  
  1034. BOOL HandleCommodityEvents(Application *app)
  1035. {
  1036.     CxMsg     *cmsg;
  1037.     ULONG     msgid, msgtype;
  1038.     static  UWORD delaycount = 0;
  1039.     BOOL     done = FALSE;
  1040.  
  1041.     while (cmsg = (CxMsg *)GetMsg(app->broker_mp))
  1042.     {
  1043.         msgid = CxMsgID(cmsg);                /* Informationen auslesen, damit die */
  1044.         msgtype = CxMsgType(cmsg);            /* Message möglichst schnell beantwortet */
  1045.         ReplyMsg((struct Message *)cmsg);    /* werden kann... */
  1046.  
  1047.         switch (msgtype)
  1048.         {
  1049.             case CXM_COMMAND:                /* Ein Kommando wurde gesandt */
  1050.                 switch (msgid)
  1051.                 {
  1052.                     case CXCMD_DISABLE:        /* Abschalten */
  1053.                         ActivateCxObj(app->broker, 0L);
  1054.                         break;
  1055.                     case CXCMD_ENABLE:        /* Anschalten */
  1056.                         ActivateCxObj(app->broker, 1L);
  1057.                         CDReadTOCA(app->cdstr->cdx);
  1058.                         CDUpdateA(app->cdstr->cdx);
  1059.                         break;
  1060.                     case CXCMD_KILL:        /* Entfernen */
  1061.                         done = TRUE;
  1062.                         break;
  1063.                     case CXCMD_APPEAR:        /* Fenster öffnen */
  1064.                         FreeAppIcon(app);
  1065.                         OpenApplication(app);
  1066.                         break;
  1067.                     case CXCMD_DISAPPEAR:    /* Fenster schließen */
  1068.                         CloseApplication(app);
  1069.                         CreateAppIcon(app);
  1070.                         break;
  1071.                 }
  1072.                 break;
  1073.             case CXM_IEVENT:
  1074.                 switch (msgid)
  1075.                 {
  1076.                     case EVENT_HOTKEYPRESSED:
  1077.                         if (app->screen == NULL)
  1078.                         {
  1079.                             FreeAppIcon(app);
  1080.                             OpenApplication(app);
  1081.                         }
  1082.                         else
  1083.                             switch (app->hotkeymode)
  1084.                             {
  1085.                                 case HOTKEYMODE_SCREENTOFRONT:
  1086.                                     OpenApplication(app);
  1087.                                     break;
  1088.                                 case HOTKEYMODE_FRONTMOST:
  1089.                                     {
  1090.                                         /* Zuerst locken... */
  1091.                                         ULONG lockreturn = LockIBase(0);
  1092.  
  1093.                                         if (((struct IntuitionBase *)IntuitionBase)->FirstScreen == app->screen)
  1094.                                             OpenApplication(app);
  1095.                                         else
  1096.                                         {
  1097.                                             if (GetPubScreenName(((struct IntuitionBase *)IntuitionBase)->FirstScreen, app->pubscreenname))
  1098.                                             {
  1099.                                                 /* Hier wird zuerst der Screenname überschrieben, und dann die Application */
  1100.                                                 /* geschlossen. Ich hoffe, das ist in Ordnung... */
  1101.                                                 CloseApplication(app);
  1102.                                                 OpenApplication(app);
  1103.                                             }
  1104.                                             else
  1105.                                             {
  1106.                                                 DisplayBeep(((struct IntuitionBase *)IntuitionBase)->FirstScreen);
  1107.                                             }
  1108.                                         }
  1109.                                         UnlockIBase(lockreturn);
  1110.                                     }
  1111.                                     break;
  1112.                                 case HOTKEYMODE_HIDE:
  1113.                                     CloseApplication(app);
  1114.                                     break;
  1115.                             }
  1116.                         break;
  1117.                     case EVENT_TIMER:
  1118.                         if (++delaycount == app->cdstr->updatedelay)
  1119.                         {
  1120.                             /* Sicherheitshalber, damit die Diskdaten in jedem Fall stimmen */
  1121.                             if (app->cdstr->updatedelay > 30)
  1122.                                 CDReadTOCA(app->cdstr->cdx);
  1123.                             CDUpdateA(app->cdstr->cdx);
  1124.                             UpdateGadgets(app);
  1125.  
  1126.                             delaycount = 0;
  1127.                         }
  1128.                         break;
  1129.                 }
  1130.                 break;
  1131.         }
  1132.     }
  1133.     return (done);
  1134. }
  1135.  
  1136. void HandleScreenNotify(Application *app)
  1137. {
  1138.     struct ScreenNotifyMessage *smsg;
  1139.  
  1140.     while (smsg = (struct ScreenNotifyMessage *)GetMsg(app->scrnotify_mp))
  1141.     {
  1142.         if ((smsg->snm_Type == SCREENNOTIFY_TYPE_WORKBENCH) && (app->Flags & APPF_WORKBENCH))
  1143.             if (smsg->snm_Value)
  1144.             {
  1145.                 /* Nur öffnen wenn auch durch CloseWorkBench() geschlossen */
  1146.                 if ((!app->screen) && (app->Flags & APPF_SNCLOSED))
  1147.                 {
  1148.                     OpenApplication(app);
  1149.                     /* Application ist jetzt wieder offen: */
  1150.                     /* Flag wird in OpenApplication gelöscht */
  1151.                 }
  1152.             }
  1153.             else
  1154.             {
  1155.                 if (app->screen)
  1156.                 {
  1157.                     CloseApplication(app);
  1158.                     /* Application wurde durch CloseWorkBench() geschlossen: */
  1159.                     /* Kann also durch OpenWorkBench() wieder geöffnet werden */
  1160.                     app->Flags |= APPF_SNCLOSED;
  1161.                 }
  1162.             }
  1163.  
  1164.         /* Erst antworten wenn alle Fenster geschlossen/offen sind */
  1165.         ReplyMsg((struct Message *)smsg);
  1166.     }
  1167. }
  1168.  
  1169. void HandleAppIconEvents(struct Application *app)
  1170. {
  1171.     struct AppMessage *appmsg    = NULL;
  1172.     LONG num;
  1173.  
  1174.     while (appmsg = (struct AppMessage *)GetMsg(app->appicon_mp))
  1175.     {
  1176.         num = appmsg->am_NumArgs;
  1177.         ReplyMsg((struct Message *)appmsg);
  1178.  
  1179.         if (!num)
  1180.         {
  1181.             FreeAppIcon(app);
  1182.             OpenApplication(app);
  1183.             break;
  1184.         }
  1185.     }
  1186. }
  1187.