home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 25 / CDROM25.iso / Share / linux / lg / issue29 / HAMILTON / Program.java < prev    next >
Encoding:
Java Source  |  1998-01-24  |  10.6 KB  |  222 lines

  1. package Jcd; // -- Listing-7 -- Program.java//   1
  2.                                             //   2
  3. import java.io.*;                           //   3
  4. import java.util.*;                         //   4
  5. import java.awt.*;                          //   5
  6. import java.awt.event.*;                    //   6
  7.                                             //   7
  8. import Jcd.Drive;                           //   8
  9. import Jcd.Monitor;                         //   9
  10.                                             //  10
  11. class Program                               //  11
  12.   extends Form implements Observer {       
  13.                                             //  12
  14.   private abstract class DoAction           //  13
  15.     implements ActionListener {         
  16.     public void actionPerformed(            //  14
  17.       ActionEvent event) {   
  18.       this.invoke();                        //  15
  19.     }                                       //  16
  20.     abstract void invoke();                 //  17
  21.   }                                         //  18
  22.                                             //  19
  23.   private static final int INITIAL_BUTTONS = 20;
  24.   private static final int LISTING_SIZE =26;//  21
  25.   private static final int GRID_SIZE =8;    //  22
  26.                                             //  23
  27.   private static final int ADD_MODE = 0;    //  24
  28.   private static final int DEL_MODE = 1;    //  25
  29.   private static final int PLAY_MODE  = 2;  //  26
  30.   private static final String EDIT_LABELS[] = 
  31.     { "Add ", "Del ", "Play" };             //  27 
  32.                                             //  28
  33.   private SmartDrive cdPlayer;              //  29
  34.                                             //  30
  35.   private TextField programListing =        //  31 
  36.     new TextField(Program.LISTING_SIZE);
  37.                                             //  32
  38.   private Panel trackPanel  = new Panel();  //  33
  39.   private Panel buttonPanel = new Panel();  //  34
  40.                                             //  35
  41.   private Button editButton;                //  36
  42.                                             //  37
  43.   private int mode = ADD_MODE;              //  38
  44.                                             //  39
  45.   public Program(SmartDrive drive)          //  40
  46.   {                                         //  41
  47.     super("Jcd Program");                   //  42
  48.                                             //  43
  49.     int n;                                  //  44
  50.                                             //  45
  51.     cdPlayer = drive;                       //  46
  52.                                             //  47
  53.     programListing.setEditable(false);      //  48
  54.                                             //  49
  55.     addCenter(programListing);              //  50
  56.     addCenter(trackPanel);                  //  51
  57.                                             //  52
  58.     editButton = new Button("Add ");        //  53
  59.     addButton(buttonPanel,                  //  54
  60.               editButton,                   //  55
  61.               new DoAction() {              //  56
  62.                 void invoke() {
  63.                  setEditMode(); 
  64.                 } 
  65.               });
  66.     addButton(buttonPanel,                  //  57
  67.               new Button("Shuffle"),        //  58
  68.               new DoAction() { void invoke() 
  69.                     {shuffleProgram();} });
  70.     addButton(buttonPanel,                  //  60
  71.               new Button("Reset"),          //  61
  72.               new DoAction() {              //  62
  73.               void invoke() {resetProgram();}});
  74.     addButton(buttonPanel,                  //  63
  75.               new Button("Clear"),          //  64
  76.               new DoAction() { void invoke() 
  77.                     { clearProgram(); } }); //  65
  78.     addButton(buttonPanel,                  //  66
  79.               new Button("Dismiss"),        //  67
  80.               new DoAction() { void invoke()
  81.                     { dismiss(); } });      //  68
  82.                                             //  69
  83.     addCenter(buttonPanel);                 //  70
  84.                                             //  71
  85.     addWindowListener(                      //  72
  86.       // Use anonymous class - save defining 
  87.       // another class
  88.       new WindowAdapter() {                 //  73
  89.         public void windowClosing(WindowEvent e) {
  90.           dismiss();                        //  75
  91.         }                                   //  76
  92.       }                                     //  77
  93.     );                                      //  78
  94.                                             //  79
  95.     n = cdPlayer.monitor.numberOfTracks;    //  80
  96.     updateTrackPanel(n > 0 ? 
  97.       n : Program.INITIAL_BUTTONS);         //  81
  98.                                             //  82
  99.     cdPlayer.monitor.addObserver(this);     //  83
  100.                                             //  84
  101.     pack();                                 //  85
  102.     show();                                 //  86
  103.   }                                         //  87
  104.                                             //  88
  105.   public void update(Observable o, Object arg)
  106.   {                                         //  90
  107.     if (cdPlayer.monitor.cdChanged) {       //  91
  108.       updateTrackPanel(
  109.        cdPlayer.monitor.numberOfTracks);    //  92
  110.     }                                       //  93
  111.   }                                         //  94
  112.                                             //  95
  113.   void addButton(Panel panel, Button button,//  96
  114.                  DoAction action)        
  115.   {                                         //  97
  116.     panel.add(button);                      //  98
  117.     button.addActionListener(action);       //  99
  118.   }                                         // 100
  119.                                             // 101
  120.   void clearProgram() {                     // 102
  121.     cdPlayer.tracksToPlay.clear();          // 103
  122.     displayProgram();                       // 104
  123.   }                                         // 105
  124.                                             // 106
  125.   void dismiss()                            // 107
  126.   {                                         // 108
  127.     setVisible(false);                      // 109
  128.     dispose();                              // 110
  129.   }                                         // 111
  130.                                             // 112
  131.   void displayProgram()                     // 113
  132.   {                                         // 114
  133.     String str =                            // 115
  134.       cdPlayer.monitor.cdChanged ?
  135.         "[]" : cdPlayer.tracksToPlay.toString();
  136.     programListing.setText(str.substring(1, 
  137.                            str.length() - 1));  
  138.   }                                         // 118
  139.                                             // 119
  140.   void pickTrack(int tracknum) {            // 120
  141.     switch (mode) {                         // 121
  142.     case ADD_MODE:                          // 122
  143.       cdPlayer.tracksToPlay.addTrack(tracknum);
  144.       break;                                // 124
  145.     case DEL_MODE:                          // 125
  146.       cdPlayer.tracksToPlay.removeTrack(tracknum);
  147.       break;                                // 127
  148.     case PLAY_MODE:                         // 128
  149.       cdPlayer.tracksToPlay.skipTo(tracknum);
  150.       try {                                 // 130
  151.         cdPlayer.play(tracknum);            // 131
  152.       }                                     // 132
  153.       catch (DriveException except) {       // 133
  154.         System.out.println("Exception " + except);
  155.       }                                     // 135
  156.       break;                                // 136
  157.     }                                       // 137
  158.     displayProgram();                       // 138
  159.   }                                         // 139
  160.                                             // 140
  161.   void resetProgram() {                     // 141
  162.     cdPlayer.tracksToPlay.reset();          // 142
  163.     displayProgram();                       // 143
  164.   }                                         // 144
  165.                                             // 145
  166.   void setEditMode() {                      // 146
  167.     mode++;                                 // 147
  168.     if (mode > PLAY_MODE) mode = ADD_MODE;  // 148
  169.     editButton.setLabel(EDIT_LABELS[mode]); // 149
  170.   }                                         // 150
  171.                                             // 151
  172.   void shuffleProgram()                     // 152
  173.   {                                         // 153
  174.     int n = cdPlayer.monitor.numberOfTracks;// 154
  175.     Vector choices = new Vector(n);         // 155
  176.     Random random = new Random();           // 156
  177.                                             // 157
  178.     cdPlayer.tracksToPlay.clear();          // 158
  179.     // Make a list of all choices.
  180.     for (int i=1; i <= n; i++)              // 159
  181.       choices.addElement(new Integer(i));   // 160
  182.                                             // 161
  183.     // Remove at random until none are left.
  184.     for (int i=1; i <= n; i++) {            // 162
  185.       int which = (int) (random.nextFloat() *
  186.                          choices.size());   // 163
  187.       int track = ((Integer)
  188.         choices.elementAt(which)).intValue(); 
  189.       cdPlayer.tracksToPlay.addTrack(track);// 165
  190.       choices.removeElementAt(which);       // 166
  191.     }                                       // 167
  192.     displayProgram();                       // 168
  193.   }                                         // 169
  194.                                             // 170
  195.   private void updateTrackPanel(int n)      // 171
  196.   {                                         // 172
  197.     int prev_n = trackPanel.getComponentCount();  
  198.     if (n != prev_n) {                      // 174
  199.       Component button[] = 
  200.         trackPanel.getComponents();         // 175
  201.       trackPanel.setLayout(                 // 177
  202.         new GridLayout(n / Program.GRID_SIZE + 1, 
  203.                        Program.GRID_SIZE)); 
  204.       for (int i = n; i < prev_n; i++)      // 178
  205.         trackPanel.remove(button[i]);       // 179
  206.       for (int i = prev_n; i < n; i++) {    // 180
  207.         class TrackAction extends DoAction {// 181
  208.           int track;                        // 182
  209.           public TrackAction(int i) {track=i;} 
  210.           void invoke() {pickTrack(track);} // 184
  211.         }                                   // 185
  212.         addButton(                          // 186
  213.           trackPanel,
  214.           new Button(Integer.toString(i+1)),
  215.           new TrackAction(i + 1));
  216.       }                                     // 189
  217.     }                                       // 190
  218.     displayProgram();                       // 191
  219.     pack();                                 // 192
  220.   }                                         // 193
  221. }                                           // 194
  222.