home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Utilities / ACDPlay / src / V1.6 / PanelCommands.c.BAK < prev    next >
Text File  |  1998-01-28  |  6KB  |  245 lines
  1. /* PanelCommands.c */
  2.  
  3. #include "Constants.h"
  4.  
  5. #include <exec/types.h>
  6. #include <exec/memory.h>
  7. #include <exec/libraries.h>
  8. #include <intuition/intuition.h>
  9. #include <intuition/intuitionbase.h>
  10. #include <intuition/gadgetclass.h>
  11. #include <libraries/gadtools.h>
  12. #include <libraries/commodities.h>
  13. #include <libraries/asl.h>
  14. #include <graphics/rastport.h>
  15. #include <devices/scsidisk.h>
  16. #include <devices/cd.h>
  17. #include <libraries/screennotify.h>
  18. #include <pragma/screennotify_lib.h>
  19. #include "AsmLib/CD-ROM.h"
  20. #include "Locale.h"
  21. #include "Structures/Application.h"
  22. #include "Structures/DirNode.h"
  23. #include "Structures/MyPubScreenNode.h"
  24.  
  25. #include <clib/alib_protos.h>
  26. #include <clib/dos_protos.h>
  27. #include <clib/exec_protos.h>
  28. #include <clib/asl_protos.h>
  29. #include <clib/gadtools_protos.h>
  30. #include <clib/graphics_protos.h>
  31. #include <clib/intuition_protos.h>
  32. #include <clib/commodities_protos.h>
  33. #include <clib/icon_protos.h>
  34. #include <clib/locale_protos.h>
  35. #include <clib/wb_protos.h>
  36. #include <string.h>
  37. #include <stdlib.h>
  38. #include <stdio.h>
  39. #include <math.h>
  40. #include "ACDPlay_protos.h"
  41.  
  42. ULONG DirectChoice(Application *app, UWORD track)
  43. {
  44.     ULONG suc = RETURN_OK;
  45.     register struct CDStruct *cdstr = app->cdstr;
  46.  
  47.     track = FitInteger(track, 1, cdstr->num_track);
  48.  
  49.     if (cdstr->active != AUDIO_STAT_NO_DISK)
  50.         if (suc = PlayListStart(cdstr, track))
  51.             if (cdstr->active == AUDIO_STAT_PAUSED)
  52.                 suc = CDPauseA(cdstr->cdx, TRUE);
  53.  
  54.     cdstr->useraction = TRUE;
  55.  
  56.     CDUpdateA(cdstr->cdx);
  57.     UpdateGadgets(app);
  58.  
  59.     return(suc ? RETURN_SCSIERR : RETURN_OK);
  60. }
  61.  
  62. ULONG EjectButton(Application *app)
  63. {
  64.     ULONG suc;
  65.  
  66.     /* Gibt es eine Möglichkeit, ein und denselben Button zum Öffnen */
  67.     /* und Schließen des Laufwerks zu Verwenden? Ich sehe keine. :-( */
  68.  
  69.     /* Mann müsste auslesen können ob die Schublade offen ist.    */
  70.     /* Ich glaube aus diesem Grund sperrt auch OptyPlayer die     */
  71.     /* manuelle Bedienung der Schublade. Frag doch mal Patrick ob */
  72.     /* er da was machen kann [mak]                                  */
  73.  
  74.     /* Hab' ich schon... :-) */
  75.  
  76.     /* Endlich! Es funktioniert! :) */
  77.  
  78.     StopButton(app);
  79.  
  80.     /* Wenn (CD vorhanden ist) oder (Schublade gerade geschlossen wurde) : öffnen */
  81.     if (!CDTestUnitA(app->cdstr->cdx) || (app->cdstr->cdx->cdx_Flags & SPECIALF_JUSTCLOSED))
  82.         suc = CDEjectA(app->cdstr->cdx, TRUE);
  83.     else
  84.         suc = CDEjectA(app->cdstr->cdx, FALSE);
  85.  
  86.     return(suc ? RETURN_SCSIERR : RETURN_OK);
  87. }
  88.  
  89. ULONG JumpBackwardButton(Application *app)
  90. {
  91.     BOOL success = TRUE;
  92.     register struct CDStruct *cdstr = app->cdstr;
  93.  
  94.     if (cdstr->active != AUDIO_STAT_NO_DISK)
  95.         if (success = PlayListPrev(cdstr))
  96.             if (cdstr->active == AUDIO_STAT_PAUSED)
  97.                 success = CDPauseA(cdstr->cdx, TRUE);
  98.  
  99.     cdstr->useraction = TRUE;
  100.  
  101.     return(success ? RETURN_SCSIERR : RETURN_OK);
  102. }
  103.  
  104. ULONG JumpForwardButton(Application *app)
  105. {
  106.     BOOL success = TRUE;
  107.     register struct CDStruct *cdstr = app->cdstr;
  108.  
  109.     if (cdstr->active != AUDIO_STAT_NO_DISK)
  110.         if (success = PlayListNext(cdstr))
  111.             if (cdstr->active == AUDIO_STAT_PAUSED)
  112.                 success = CDPauseA(cdstr->cdx, TRUE);
  113.  
  114.     cdstr->useraction = TRUE;
  115.  
  116.     return(success ? RETURN_SCSIERR : RETURN_OK);
  117. }
  118.  
  119. ULONG SearchBackwardButton(Application *app, WORD val)
  120. {
  121.     ULONG suc;
  122.     register struct CDxRequest *cdx = app->cdstr->cdx;
  123.  
  124.     /* Was bringt das eigentlich? */
  125.  
  126.     /* Der Compiler wird gezwungen die Variable in einem Register
  127.        zu halten, was eine Codeersparnis bringt und das Programm
  128.        beschleunigt, außerdem wird damit nicht immer wieder von dem
  129.        Applicationzeiger ausgegangen, wie das sonst oft der Fall ist.
  130.        Allerdings bringt das nur was, wenn das Register nicht anderweitig
  131.        gebraucht wird, und immer zwischengespeichert werden muß. ACDPlay
  132.        wurde damit ca. 2k kürzer. */
  133.  
  134.     switch (app->cdstr->active)
  135.     {
  136.         case AUDIO_STAT_STOPPED:
  137.         case AUDIO_STAT_PLAYING:
  138.         case AUDIO_STAT_PAUSED:
  139.             suc = CDJumpA(cdx, -75 * val, JUMPMODE_PLAY_REL);
  140.             if (app->cdstr->active == AUDIO_STAT_PAUSED)
  141.                 suc |= CDPauseA(cdx, TRUE);
  142.             break;
  143.     }
  144.  
  145.     return(suc ? RETURN_SCSIERR : RETURN_OK);
  146. }
  147.  
  148. ULONG SearchForwardButton(Application *app, WORD val)
  149. {
  150.     ULONG suc;
  151.     register struct CDxRequest *cdx = app->cdstr->cdx;
  152.  
  153.     switch (app->cdstr->active)
  154.     {
  155.         case AUDIO_STAT_STOPPED:
  156.         case AUDIO_STAT_PLAYING:
  157.         case AUDIO_STAT_PAUSED:
  158.             suc = CDJumpA(cdx, 75 * val, JUMPMODE_PLAY_REL);
  159.             if (app->cdstr->active == AUDIO_STAT_PAUSED)
  160.                 suc |= CDPauseA(cdx, TRUE);
  161.             break;
  162.  
  163.     }
  164.  
  165.     return(suc ? RETURN_SCSIERR : RETURN_OK);
  166. }
  167.  
  168. ULONG StopButton(Application *app)
  169. {
  170.     app->cdstr->useraction = TRUE;
  171.     return (CDStopA(app->cdstr->cdx) ? RETURN_SCSIERR : RETURN_OK);
  172. }
  173.  
  174. ULONG PauseButton(Application *app)
  175. {
  176.     ULONG suc = RETURN_OK;
  177.     register struct CDxRequest *cdx = app->cdstr->cdx;
  178.  
  179.     switch (app->cdstr->active)
  180.     {
  181.         case AUDIO_STAT_STOPPED:
  182.             PlayListStart(app->cdstr);
  183.         case AUDIO_STAT_PLAYING:
  184.             suc = CDPauseA(cdx, TRUE);
  185.             break;
  186.         case AUDIO_STAT_PAUSED:
  187.             suc = CDPauseA(cdx, FALSE);
  188.             break;
  189.     }
  190.  
  191.     cdstr->useraction = TRUE;
  192.     
  193.     suc |= CDUpdateA(cdx);    /* Damit der neue AudioStatus gleich übernommen wird */
  194.  
  195.     return(suc ? RETURN_SCSIERR : RETURN_OK);
  196. }
  197.  
  198. ULONG PlayButton(Application *app)
  199. {
  200.     ULONG suc;
  201.     register struct CDStruct *cdstr = app->cdstr;
  202.  
  203.     switch (cdstr->active)
  204.     {
  205.         case AUDIO_STAT_PLAYING:
  206.             suc = CDPlayA(cdstr->cdx, cdstr->cur_track, 1);
  207.             break;
  208.         case AUDIO_STAT_STOPPED:
  209.             PlayListStart(cdstr);
  210.             break;
  211.         case AUDIO_STAT_PAUSED:
  212.             suc = CDPauseA(cdstr->cdx, FALSE);
  213.             break;
  214.     }
  215.  
  216.     return(suc ? RETURN_SCSIERR : RETURN_OK);
  217. }
  218.  
  219. ULONG Trackslider(Application *app, UWORD newpos)
  220. {
  221.     ULONG suc;
  222.     register struct CDxRequest *cdx = app->cdstr->cdx;
  223.  
  224.     /* Bug: Wenn im Pausemodus bis an den Start zurückgescrollt und dann auf Play gedrückt wird,
  225.     ist man an der Stelle, an der man vorher war (nur im Pausemodus).
  226.     Dies kann verhindert werden, indem man _immer_ "newpos + 1" nimmt, dann kann man aber nicht
  227.     ganz bis an den Start zurückgehen.
  228.     Wenn man immer "newpos" nimmt, stimmt die Position nicht mit dem gewünschten Wert überein */
  229.  
  230.     suc = CDUpdateA(cdx);
  231.  
  232.     switch (app->cdstr->active)
  233.     {
  234.         case AUDIO_STAT_PLAYING:
  235.         case AUDIO_STAT_PAUSED:
  236.             suc |= CDJumpA(cdx, (cdx->cdx_TrackLength / 100 * (newpos?newpos+1:0)) - cdx->cdx_CurrentRelAddr, JUMPMODE_PLAY_REL);
  237.             if (app->cdstr->active == AUDIO_STAT_PAUSED)
  238.                 suc |= CDPauseA(cdx, TRUE);
  239.             suc |= CDUpdateA(cdx);
  240.             UpdateTimeGadget(app);
  241.             break;
  242.     }
  243.  
  244.     return(suc ? RETURN_SCSIERR : RETURN_OK);
  245. }