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