home *** CD-ROM | disk | FTP | other *** search
/ Chip 2005 April / CHIP_CD_2005-04.iso / service / winamp / skin / MMD3.wal / scripts / volumebasstreble.m < prev    next >
Encoding:
Text File  |  2002-11-26  |  16.5 KB  |  843 lines
  1. //--------------------------------------------------------------------
  2. // Animated Volume/Treble/Bass knobs
  3. //--------------------------------------------------------------------
  4. // volumebasstreble.m
  5. //--------------------------------------------------------------------
  6. // - Volume
  7. // - Treble
  8. // - Bass
  9. // - Knob-LEDs
  10. //--------------------------------------------------------------------
  11. // Script by:        Barti Bartman alias Sven Kistner for MMD3
  12. // Last Modified:    26.11.2002
  13. //--------------------------------------------------------------------
  14. //
  15. // BIG THANKS GOES TO:
  16. // ThePlague.............for the great ideas and inspirations
  17. // Dennis Ostermann......for code parts of the new script
  18. //
  19. //--------------------------------------------------------------------
  20. // Feel free to use parts of this script in your own projects
  21. // I know the code looks a litle bit strange. Sorry for that...
  22. // ...I am more a graphic artist than a coder...but it works :)
  23. //--------------------------------------------------------------------
  24.  
  25. #include "../../../lib/std.mi"
  26.  
  27. Function updateVolume(int v);
  28. Function initVolume();
  29. Function updateTreble(int v);
  30. Function updateTrebleKnob(int v);
  31. Function initTreble();
  32. Function initTicker();
  33. Function int getTreble();
  34. Function SetTreble(float v);
  35. Function SetBass(float v);
  36. Function updateBass(int v);
  37. Function updateBassKnob(int v);
  38. Function initBass();
  39. Function int getBass();
  40.  
  41. Global AnimatedLayer Bass, Treble, Volume, Volume2,VolumeLED, BassLED, TrebleLED;
  42. Global Layer BassInfo, TrebleInfo, VolumeInfo, VolumeInfo2;
  43. Global Boolean InUse=0;
  44. Global Timer SongTickerTimer;
  45. Global Layout dummynormal;
  46. Global group mainnormal;
  47. Global Text SongTicker;
  48. Global Slider HiddenVolume;
  49. Global Int VolChanging, VolFrames;
  50. Global Int TrebleChanging, TrebFrames, TickerExist;
  51. Global Int BassChanging, BassFrames;
  52. Global Int VolumeIsPlaying,TrebleIsPlaying,BassIsPlaying,MouseIsDown,lmx,lmy,specialTreble,specialBass;
  53. Global Timer VolKnobTimer,Vol2KnobTimer,BassKnobTimer,TrebleKnobTimer;
  54. Global Map bassMap, trebleMap, volMap,volMap2;
  55. Global int WinX,WinY;
  56.  
  57.  
  58. System.onScriptLoaded() {
  59.  
  60.     dummynormal = System.getContainer("main").getLayout("normal");
  61.     mainnormal = dummynormal.getObject("main.mmd3");
  62.  
  63.     Volume = mainnormal.getObject("VolumeAnim");
  64.     VolumeLED = mainnormal.getObject("VolumeAnimLED");
  65.     Volume2 = mainnormal.getObject("VolumeAnim2");
  66.  
  67.     VolumeInfo = mainnormal.getObject("volumeaniminfo");
  68.  
  69.     VolumeInfo2 = mainnormal.getObject("volumeaniminfo2");
  70.     HiddenVolume = mainnormal.getObject("HiddenVolume");
  71.  
  72.     Bass = mainnormal.getObject("BassAnim");
  73.     BassLED = mainnormal.getObject("BassAnimLED");
  74.     BassInfo = mainnormal.getObject("bassaniminfo");
  75.  
  76.     Treble = mainnormal.getObject("TrebleAnim");
  77.     TrebleLED = mainnormal.getObject("TrebleAnimLED");
  78.     TrebleInfo = mainnormal.getObject("trebleaniminfo");
  79.  
  80.     VolumeIsPlaying=0;
  81.     MouseIsDown=0;
  82.     specialTreble=0;
  83.  
  84.     volMap = new Map;
  85.     volMap.loadMap("player.map.volume");
  86.     volMap2 = new Map;
  87.     volMap2.loadMap("player.map.volume2");
  88.     bassMap = new Map;
  89.     bassMap.loadMap("player.map.bass");
  90.     trebleMap = new Map;
  91.     trebleMap.loadMap("player.map.treble");
  92.  
  93.     VolKnobTimer = new Timer;
  94.     VolKnobTimer.setDelay(10);
  95.  
  96.     Vol2KnobTimer = new Timer;
  97.     Vol2KnobTimer.setDelay(10);
  98.  
  99.     BassKnobTimer = new Timer;
  100.     BassKnobTimer.setDelay(10);
  101.  
  102.     TrebleKnobTimer = new Timer;
  103.     TrebleKnobTimer.setDelay(10);
  104.  
  105.     initVolume();
  106.     initBass();
  107.     initTreble();
  108.  
  109. }
  110.  
  111.  
  112. initTicker() {
  113.     SongTicker = mainnormal.getObject("songticker");
  114.     SongTickerTimer = new Timer;
  115.     SongTickerTimer.setDelay(1000);
  116. }
  117.  
  118. SongTickerTimer.onTimer() {
  119.     SongTicker.setText("");
  120.     SongTickerTimer.stop();
  121. }
  122.  
  123. initVolume() {
  124.  
  125.     VolumeInfo.setAlpha(0);
  126.     VolumeInfo2.setAlpha(0);
  127.  
  128.     VolChanging = 0;
  129.     VolFrames = Volume.getLength();
  130.     VolFrames = VolFrames - 1;
  131.     TickerExist = VolumeInfo.getTop();
  132.  
  133.     float u;
  134.     u = System.getVolume();
  135.     u = u / 255;
  136.     int k = u * VolFrames;
  137.     Volume.gotoFrame(k);
  138.     Volume2.gotoFrame(k);
  139.  
  140.     if (TickerExist) initTicker();
  141. }
  142.  
  143.  
  144.  
  145. //------------------------------------------------------------
  146. // Volume functions
  147. //------------------------------------------------------------
  148.     Volume.onLeftButtonDown(int x, int y) {
  149.         VolChanging = 1;
  150.         MouseIsDown = 1;
  151.  
  152.         lmx=getMousePosX();
  153.         lmy=getMousePosY();
  154.  
  155.         WinX=getMousePosX()-x+Volume.getLeft()+(Volume.getWidth()/2);
  156.         WinY=getMousePosY()-y+Volume.getTop()+(Volume.getHeight()/2);
  157.  
  158.         x = x - Volume.getLeft();
  159.         y = y - Volume.getTop();
  160.  
  161.         if (volMap.inRegion(x, y)) {
  162.             float v = volMap.getValue(x, y);
  163.  
  164.             if (v>252) v=255;
  165.             float k = v / 255;
  166.             int g = k * VolFrames;
  167.  
  168.             Volume.setStartFrame( Volume.getCurFrame() );
  169.             Volume2.setStartFrame( Volume2.getCurFrame() );
  170.             Volume.setEndFrame(g);
  171.             Volume2.setEndFrame(g);
  172.             Volume.setSpeed(40);
  173.             Volume2.setSpeed(40);
  174.             VolumeIsPlaying=1;
  175.             Volume.play();
  176.             Volume2.play();
  177.         }
  178.  
  179.         VolKnobTimer.start();
  180.     }
  181.  
  182.  
  183.  
  184.     VolKnobTimer.onTimer()
  185.     {
  186.         float dx,dy,dWinX,dWinY,Temp,AniVol,Vol;
  187.         int Gate,Gate2;
  188.         int x=getMousePosX();
  189.         int y=getMousePosY();
  190.         dx=x;
  191.         dy=y;
  192.         dWinx=WinX;
  193.         dWinY=WinY;
  194.  
  195.         if ( (x-lmx)>2 || (x-lmx)<-2 || (y-lmy)>2 || (y-lmy)<-2 ) {
  196.  
  197.             if (VolumeIsPlaying==1) {
  198.                 Volume.stop();
  199.                 Volume2.stop();
  200.                 VolumeIsPlaying=0;
  201.             }
  202.  
  203.             if ((WinY<y) && (WinX>x) )
  204.             {
  205.                 if (Gate==0)
  206.                 {
  207.                     Temp=((dWinX-dx)/((dWinY-dy)*-1));
  208.                     Vol=(atan(Temp)-0.523598775)*48.89239852;
  209.                     Gate2=1;
  210.                 }
  211.                 else Vol=255;
  212.             }
  213.  
  214.             else if  ((WinY>y) && (WinX>x))
  215.             {
  216.                 Temp=(dWinY-dy)/(dWinX-dx);
  217.                 Vol=51.2+atan(Temp)*48.89239852;
  218.                 Gate=0;
  219.                 Gate2=0;
  220.  
  221.             }
  222.  
  223.             else if  ((WinY>y) && (WinX<x))
  224.             {
  225.                 Temp=((dWinX-dx)*-1)/(dWinY-dy);
  226.                 Vol=128.0+atan(Temp)*48.89239852;
  227.                 Gate=0;
  228.                 Gate2=0;
  229.  
  230.             }
  231.  
  232.             else if  ((WinY<y) && (WinX<x) )
  233.             {
  234.                 if (Gate2==0)
  235.                 {
  236.                     Temp=((dWinY-dy)*-1)/((dWinX-dx)*-1);
  237.                     Vol=204.8+atan(Temp)*48.89239852;
  238.                     Gate=1;
  239.                 }
  240.                 else Vol=0;
  241.             }
  242.  
  243.             UpdateVolume(Vol);
  244.         }
  245.     }
  246.  
  247.  
  248.     Volume.onLeftButtonUp(int x, int y)
  249.     {
  250.         VolKnobTimer.stop();
  251.         SongTickerTimer.start();
  252.         VolChanging=0;
  253.         MouseIsDown = 0;
  254.     }
  255.  
  256.  
  257.     Vol2KnobTimer.onTimer()
  258.     {
  259.         float Vol;
  260.         float x=getMousePosX();
  261.         float l=Volume2.getWidth();
  262.  
  263.         if (x!=lmx) {
  264.  
  265.             if (VolumeIsPlaying==1) {
  266.                 Volume.stop();
  267.                 Volume2.stop();
  268.                 VolumeIsPlaying=0;
  269.             }
  270.  
  271.             Vol = (x - WinX) * (255.0 / l);
  272.             UpdateVolume(Vol);
  273.         }
  274.     }
  275.  
  276.     Volume2.onLeftButtonDown(int x, int y) {
  277.         VolChanging = 1;
  278.         MouseIsDown = 1;
  279.  
  280.         lmx=getMousePosX();
  281.         lmy=getMousePosY();
  282.  
  283.         WinX=getMousePosX()-x+Volume2.getLeft();
  284.  
  285.         x = x - Volume2.getLeft();
  286.         y = y - Volume2.getTop();
  287.  
  288.         if (volMap2.inRegion(x, y)) {
  289.             float v = volMap2.getValue(x, y);
  290.             if (v>252) v=255;
  291.             float k = v / 255;
  292.             int g = k * VolFrames;
  293.  
  294.             Volume.setStartFrame( Volume.getCurFrame() );
  295.             Volume2.setStartFrame( Volume2.getCurFrame() );
  296.             Volume.setEndFrame(g);
  297.             Volume2.setEndFrame(g);
  298.             Volume.setSpeed(40);
  299.             Volume2.setSpeed(40);
  300.             VolumeIsPlaying=1;
  301.             Volume.play();
  302.             Volume2.play();
  303.         }
  304.  
  305.  
  306.         Vol2KnobTimer.start();
  307.     }
  308.  
  309.  
  310.     Volume2.onLeftButtonUp(int x, int y)
  311.     {
  312.         Vol2KnobTimer.stop();
  313.         SongTickerTimer.start();
  314.         VolChanging=0;
  315.         MouseIsDown = 0;
  316.     }
  317.  
  318.  
  319.     Volume.onFrame(int vf) {
  320.  
  321.         VolumeLED.gotoFrame(vf);
  322.  
  323.         if (VolumeIsPlaying) {
  324.             int v=11.6*vf;
  325.             System.setVolume(v);
  326.  
  327.             if (MouseIsDown) {
  328.                 float k = v / 255;
  329.                 int p = k * 100;
  330.                 SongTickerTimer.stop();
  331.                 SongTickerTimer.start();
  332.                 SongTicker.setAlternateText("VOLUME: " + System.integerToString(p) + "%");
  333.             }
  334.         }
  335.     }
  336.  
  337.  
  338.     Volume.onStop() {
  339.         VolumeIsPlaying=0;
  340.     }
  341.  
  342.  
  343.     updateVolume(float v) {
  344.         if (v < 0) v=0;
  345.         if (v >255) v=255;
  346.  
  347.         float k = v / 255;
  348.         int g = k * VolFrames;
  349.         if ( !Volume.isPlaying() ) {
  350.             Volume.gotoFrame(g);
  351.             Volume2.gotoFrame(g);
  352.         }
  353.  
  354.         System.setVolume(v);
  355.  
  356.         int p = k * 100;
  357.         SongTickerTimer.stop();
  358.         SongTickerTimer.start();
  359.         SongTicker.setAlternateText("VOLUME: " + System.integerToString(p) + "%");
  360.     }
  361.  
  362.  
  363.     HiddenVolume.onPostedPosition(int p) {
  364.         if (!VolChanging) {
  365.  
  366.             Float f = getVolume();
  367.             Float sf = f/2.55;
  368.             f = f * VolFrames;
  369.             f = f / 255;
  370.  
  371.             if ( !Volume.isPlaying() ) {
  372.                 Volume.gotoFrame(f);
  373.                 Volume2.gotoFrame(f);
  374.             }
  375.  
  376.             SongTickerTimer.stop();
  377.             SongTickerTimer.start();
  378.             SongTicker.setAlternateText("VOLUME: " + System.integerToString(sf) + "%");
  379.  
  380.         }
  381.     }
  382. //------------------------------------------------------------
  383. // End of Volume functions
  384. //------------------------------------------------------------
  385.  
  386.  
  387.  
  388.  
  389.  
  390.  
  391. //------------------------------------------------------------
  392. // Treble functions
  393. //------------------------------------------------------------
  394.     initTreble() {
  395.         TrebleInfo.setAlpha(0);
  396.         TrebleChanging = 0;
  397.  
  398.         TrebFrames = Treble.getLength();
  399.         TrebFrames = TrebFrames - 1;
  400.         float u;
  401.         u = getTreble();
  402.         u = u / 255;
  403.         int k = u * TrebFrames;
  404.         Treble.gotoFrame(k);
  405.     }
  406.  
  407.     TrebleKnobTimer.onTimer()
  408.     {
  409.         float dx,dy,dWinX,dWinY,Temp,Treb;
  410.         int Gate,Gate2;
  411.         int x=getMousePosX();
  412.         int y=getMousePosY();
  413.         dx=x;
  414.         dy=y;
  415.         dWinx=WinX;
  416.         dWinY=WinY;
  417.  
  418.  
  419.         if ( (x-lmx)>2 || (x-lmx)<-2 || (y-lmy)>2 || (y-lmy)<-2 ) {
  420.  
  421.             if (TrebleIsPlaying==1) {
  422.                 Treble.stop();
  423.                 TrebleIsPlaying=0;
  424.             }
  425.  
  426.             if ((WinY<y) && (WinX>x) )
  427.             {
  428.                 if (Gate==0)
  429.                 {
  430.                     Temp=((dWinX-dx)/((dWinY-dy)*-1));
  431.                     Treb=(atan(Temp)-0.523598775)*48.89239852;        // 1/6 PI ~ 0.523598775
  432.                     Gate2=1;                                        // 256 : 1/2/3 PI ~ 48.89239852
  433.                 }
  434.                 else Treb=255;
  435.  
  436.  
  437.  
  438.             }
  439.             else if  ((WinY>y) && (WinX>x))
  440.             {
  441.                 Temp=(dWinY-dy)/(dWinX-dx);
  442.                 Treb=51.2+atan(Temp)*48.89239852;
  443.                 Gate=0;
  444.                 Gate2=0;
  445.  
  446.             }
  447.             else if  ((WinY>y) && (WinX<x))
  448.             {
  449.                 Temp=((dWinX-dx)*-1)/(dWinY-dy);
  450.                 Treb=128.0+atan(Temp)*48.89239852;
  451.                 Gate=0;
  452.                 Gate2=0;
  453.  
  454.             }
  455.             else if  ((WinY<y) && (WinX<x) )
  456.             {
  457.                 if (Gate2==0)
  458.                 {
  459.                     Temp=((dWinY-dy)*-1)/((dWinX-dx)*-1);
  460.                     Treb=204.8+atan(Temp)*48.89239852;
  461.                     Gate=1;
  462.                 }
  463.                 else Treb=0;
  464.  
  465.  
  466.             }
  467.  
  468.             UpdateTreble(Treb);
  469.             UpdateTrebleKnob(Treb);
  470.         }
  471.  
  472.     }
  473.  
  474.  
  475.     Treble.onLeftButtonDown(int x, int y) {
  476.         trebleChanging = 1;
  477.         MouseIsDown = 1;
  478.         specialTreble=0;
  479.  
  480.         WinX=getMousePosX()-x+Treble.getLeft()+(Treble.getWidth()/2);
  481.         WinY=getMousePosY()-y+Treble.getTop()+(Treble.getHeight()/2);
  482.  
  483.         lmx=getMousePosX();
  484.         lmy=getMousePosY();
  485.  
  486.         x = x - Treble.getLeft();
  487.         y = y - Treble.getTop();
  488.  
  489.         if (trebleMap.inRegion(x, y)) {
  490.             float v = trebleMap.getValue(x, y);
  491.  
  492.             if (v>252) v=255;
  493.             float k = v / 255;
  494.             int g = k * TrebFrames;
  495.  
  496.             Treble.setStartFrame( Treble.getCurFrame() );
  497.             Treble.setEndFrame(g);
  498.             Treble.setSpeed(40);
  499.             TrebleIsPlaying=1;
  500.             Treble.play();
  501.         }
  502.         TrebleKnobTimer.start();
  503.     }
  504.  
  505.     Treble.onLeftButtonUp(int x, int y) {
  506.         TrebleKnobTimer.stop();
  507.         SongTickerTimer.start();
  508.         trebleChanging=0;
  509.         MouseIsDown = 0;
  510.     }
  511.  
  512.  
  513.     Treble.onFrame(int vf) {
  514.  
  515.         TrebleLED.gotoframe(vf);
  516.  
  517.         int v=11.6*vf;
  518.  
  519.         if (TrebleIsPlaying) {
  520.             if (!specialTreble) SetTreble(v);
  521.         }
  522.  
  523.         float k = v / 255;
  524.         int p = k * 100-50;
  525.         string vz="";
  526.         if (p>0) vz="+";
  527.         SongTickerTimer.stop();
  528.         SongTicker.setAlternateText("TREBLE: " + vz + System.integerToString(p) + "%");
  529.         SongTickerTimer.start();
  530.     }
  531.  
  532.  
  533.     Treble.onStop() {
  534.         TrebleIsPlaying=0;
  535.         specialTreble=0;
  536.     }
  537.  
  538.  
  539.     updateTreble(float v) {
  540.         if (v < 0) v=0;
  541.         if (v >255) v=255;
  542.         float k = v / 255;
  543.         int g = k * TrebFrames;
  544.         if ( !Treble.isPlaying() ) {
  545.             Treble.gotoFrame(g);
  546.         }
  547.  
  548.         SetTreble(v);
  549.  
  550.     }
  551.  
  552.  
  553.     SetTreble(float v) {
  554.         v -=127;
  555.  
  556.         setEq(1);
  557.  
  558.         int move;
  559.         InUse = 1;
  560.         for(int i=5; i<10; i++) {
  561.             move = v*1.27/(10-i);
  562.             setEqBand(i, move);
  563.         }
  564.         InUse = 0;
  565.  
  566.     }
  567.  
  568.     updateTrebleKnob(float v) {
  569.         if (v < 0) v=0;
  570.         if (v >255) v=255;
  571.         trebleChanging = 1;
  572.         specialTreble = 1;
  573.         float k = v / 255;
  574.         int g = k * TrebFrames;
  575.  
  576.         Treble.setStartFrame( Treble.getCurFrame() );
  577.         Treble.setEndFrame(g);
  578.         Treble.setSpeed(40);
  579.         TrebleIsPlaying=1;
  580.         Treble.play();
  581.     }
  582.  
  583.  
  584.     getTreble() {
  585.  
  586.         float average=0;
  587.  
  588.         for(int i=5; i<10; i++) average += ( (getEqBand(i)+127)*(i-4)*(i-4)*(i-4)  );
  589.         average /= 198;
  590.  
  591.         int rTreble = average;
  592.  
  593.         if (rTreble < 0) rTreble=0;
  594.         if (rTreble >255) rTreble=255;
  595.  
  596.         return rTreble;
  597.     }
  598.  
  599.  
  600.  
  601. //------------------------------------------------------------
  602. // End of Treble functions
  603. //------------------------------------------------------------
  604.  
  605.  
  606.  
  607.  
  608.  
  609. //------------------------------------------------------------
  610. // Bass functions
  611. //------------------------------------------------------------
  612.  
  613.     initBass() {
  614.  
  615.         BassInfo.setAlpha(0);
  616.  
  617.         BassChanging = 0;
  618.         BassFrames = Bass.getLength();
  619.         BassFrames = BassFrames - 1;
  620.  
  621.         float u;
  622.         u = getBass();
  623.         u = u / 255;
  624.         int k = u * BassFrames;
  625.         Bass.gotoFrame(k);
  626.  
  627.  
  628.     }
  629.  
  630.  
  631.     BassKnobTimer.onTimer()
  632.     {
  633.         float dx,dy,dWinX,dWinY,Temp,theBass;
  634.         int Gate,Gate2;
  635.         int x=getMousePosX();
  636.         int y=getMousePosY();
  637.         dx=x;
  638.         dy=y;
  639.         dWinx=WinX;
  640.         dWinY=WinY;
  641.  
  642.         if ( (x-lmx)>2 || (x-lmx)<-2 || (y-lmy)>2 || (y-lmy)<-2 ) {
  643.  
  644.             if (BassIsPlaying==1) {
  645.                 Bass.stop();
  646.                 BassIsPlaying=0;
  647.             }
  648.  
  649.  
  650.             if ((WinY<y) && (WinX>x) )
  651.             {
  652.                 if (Gate==0)
  653.                 {
  654.                     Temp=((dWinX-dx)/((dWinY-dy)*-1));
  655.                     theBass=(atan(Temp)-0.523598775)*48.89239852;        // 1/6 PI ~ 0.523598775
  656.                     Gate2=1;                                        // 256 : 1/2/3 PI ~ 48.89239852
  657.                 }
  658.                 else theBass=255;
  659.  
  660.  
  661.  
  662.             }
  663.             else if  ((WinY>y) && (WinX>x))
  664.             {
  665.                 Temp=(dWinY-dy)/(dWinX-dx);
  666.                 theBass=51.2+atan(Temp)*48.89239852;
  667.                 Gate=0;
  668.                 Gate2=0;
  669.  
  670.             }
  671.             else if  ((WinY>y) && (WinX<x))
  672.             {
  673.                 Temp=((dWinX-dx)*-1)/(dWinY-dy);
  674.                 theBass=128.0+atan(Temp)*48.89239852;
  675.                 Gate=0;
  676.                 Gate2=0;
  677.  
  678.             }
  679.             else if  ((WinY<y) && (WinX<x) )
  680.             {
  681.                 if (Gate2==0)
  682.                 {
  683.                     Temp=((dWinY-dy)*-1)/((dWinX-dx)*-1);
  684.                     theBass=204.8+atan(Temp)*48.89239852;
  685.                     Gate=1;
  686.                 }
  687.                 else theBass=0;
  688.  
  689.  
  690.             }
  691.  
  692.             UpdateBass(theBass);
  693.             UpdateBassKnob(theBass);
  694.         }
  695.  
  696.     }
  697.  
  698.     Bass.onLeftButtonDown(int x, int y) {
  699.         BassChanging = 1;
  700.         MouseIsDown = 1;
  701.         specialBass=0;
  702.  
  703.         WinX=getMousePosX()-x+Bass.getLeft()+(Bass.getWidth()/2);
  704.         WinY=getMousePosY()-y+Bass.getTop()+(Bass.getHeight()/2);
  705.  
  706.         lmx=getMousePosX();
  707.         lmy=getMousePosY();
  708.  
  709.         x = x - Bass.getLeft();
  710.         y = y - Bass.getTop();
  711.  
  712.         if (BassMap.inRegion(x, y)) {
  713.             float v = BassMap.getValue(x, y);
  714.  
  715.             if (v>252) v=255;
  716.             float k = v / 255;
  717.             int g = k * BassFrames;
  718.  
  719.             Bass.setStartFrame( Bass.getCurFrame() );
  720.             Bass.setEndFrame(g);
  721.             Bass.setSpeed(40);
  722.             BassIsPlaying=1;
  723.             Bass.play();
  724.         }
  725.         BassKnobTimer.start();
  726.     }
  727.  
  728.     Bass.onLeftButtonUp(int x, int y) {
  729.         BassChanging=0;
  730.         BassKnobTimer.stop();
  731.         SongTickerTimer.start();
  732.         MouseIsDown = 0;
  733.     }
  734.  
  735.  
  736.  
  737.     Bass.onFrame(int vf) {
  738.         BassLED.gotoframe(vf);
  739.  
  740.         int v=11.6*vf;
  741.  
  742.         if (BassIsPlaying) {
  743.             if (!specialBass) SetBass(v);
  744.         }
  745.  
  746.         float k = v / 255;
  747.         int p = k * 100-50;
  748.         string vz="";
  749.         if (p>0) vz="+";
  750.         SongTickerTimer.stop();
  751.         SongTicker.setAlternateText("Bass: " + vz + System.integerToString(p) + "%");
  752.         SongTickerTimer.start();
  753.     }
  754.  
  755.  
  756.     Bass.onStop() {
  757.         BassIsPlaying=0;
  758.         specialBass=0;
  759.     }
  760.  
  761.  
  762.     updateBass(float v) {
  763.         if (v < 0) v=0;
  764.         if (v >255) v=255;
  765.         float k = v / 255;
  766.         int g = k * BassFrames;
  767.         if ( !Bass.isPlaying() ) {
  768.             Bass.gotoFrame(g);
  769.         }
  770.  
  771.         SetBass(v);
  772.  
  773.         int p = k * 100-50;
  774.  
  775.     }
  776.  
  777.  
  778.     SetBass(float v) {
  779.         v -=127;
  780.  
  781.         setEq(1);
  782.  
  783.         int move;
  784.         InUse = 1;
  785.         for(int i=0; i<5; i++) {
  786.             move = v*1.27/(i+1);
  787.             setEqBand(i, move);
  788.         }
  789.         InUse = 0;
  790.  
  791.     }
  792.  
  793.     updateBassKnob(float v) {
  794.         if (v < 0) v=0;
  795.         if (v >255) v=255;
  796.  
  797.         BassChanging = 1;
  798.         specialBass = 1;
  799.         float k = v / 255;
  800.         int g = k * BassFrames;
  801.  
  802.         Bass.setStartFrame( Bass.getCurFrame() );
  803.         Bass.setEndFrame(g);
  804.         Bass.setSpeed(40);
  805.         BassIsPlaying=1;
  806.         Bass.play();
  807.     }
  808.  
  809.  
  810.     getBass() {
  811.  
  812.         float average=0;
  813.  
  814.         for(int i=0; i<5; i++) average += ( (getEqBand(i)+127)*(5-i)*(5-i)*(5-i)  );
  815.         average /= 198;
  816.  
  817.         int rBass = average;
  818.  
  819.         if (rBass < 0) rBass=0;
  820.         if (rBass >255) rBass=255;
  821.  
  822.         return rBass;
  823.     }
  824.  
  825. //------------------------------------------------------------
  826. // End of Bass functions
  827. //------------------------------------------------------------
  828.  
  829.  
  830. System.onEqBandChanged(int band, int newvalue) {
  831.  
  832.     if(!InUse) {
  833.  
  834.         if (band<5) {
  835.             int rb=getBass();
  836.             updateBassKnob(rb);
  837.         } else {
  838.  
  839.             int rb=getTreble();
  840.             updateTrebleKnob(rb);
  841.         }
  842.     }
  843. }