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