MooDialog.java

   1 import javax.swing.*;
   2 import java.awt.*;
   3 import java.awt.event.*;
   4 import javax.sound.midi.*;
   5 import java.io.*;
   6 import java.beans.*;
   7
   8 /**
   9  * The GUI-class representing the popupdialogs in the Track menu.
  10  *
  11  * @author Björn Lanneskog
  12  */
  13
  14 public class MooDialog extends JDialog {
  15
  16         private JLabel labelA, labelB, labelC;
  17         private JTextField textFieldA, textFieldB, textFieldC;
  18         private JComboBox trackListA, trackListB;
  19         private JButton okButton, cancelButton;
  20         public static final int ADD_TRACK = 1,
  21                                 DELETE_TRACK = 2,
  22                                 COPY_TRACK = 3,
  23                                 MOVE_TRACK = 4,
  24                                 JUMP = 5,
  25                                 CONTENTS = 6,
  26                                 INSERT_MEASURE = 7,
  27                                 DELETE_MEASURE = 8;
  28
  29         /**
  30          * Constructor of the dialogs.
  31          */
  32          public MooDialog(int type) {
  33                 super(Moosique.getGUI(), false);
  34
  35                 Container pane = getContentPane();
  36                 pane.setLayout(null);
  37
  38                 Track[] tracks = Moosique.getSequence().getTracks();
  39
  40                 switch (type) {
  41                         case ADD_TRACK:         makeAddDialog(pane, tracks); break;
  42                         case DELETE_TRACK:      makeDelDialog(pane, tracks); break;
  43                         case COPY_TRACK:        makeCopyDialog(pane, tracks); break;
  44                         case MOVE_TRACK:        makeMoveDialog(pane, tracks); break;
  45                         case JUMP:              makeJumpDialog(pane); break;
  46                         case CONTENTS:          makeTextDialog(pane, "Manual.txt"); break;
  47                         case INSERT_MEASURE:    makeInsertMeasureDialog(pane); break;
  48                         case DELETE_MEASURE:    makeDeleteMeasureDialog(pane); break;
  49                 }
  50          }
  51
  52         /**
  53          * Builds the add track popupdialog.
  54          * @param pane          The container to put the dialog in.
  55          * @param tracks        A array containing miditracks.
  56          */
  57         private void makeAddDialog(Container pane, Track[] tracks) {
  58
  59                 setTitle("Add track");
  60                 labelA = new JLabel("Name of track", JLabel.CENTER);
  61                 pane.add(labelA);
  62                 textFieldA = new JTextField();
  63                 pane.add(textFieldA);
  64                 labelB = new JLabel("Add after", JLabel.CENTER);
  65                 pane.add(labelB);
  66                 trackListA = new JComboBox();
  67                 for (int i = 1; i <= tracks.length; i++) trackListA.addItem("Track " + i);
  68                 pane.add(trackListA);
  69                 cancelButton = new JButton("Cancel");
  70                 pane.add(cancelButton);
  71                 okButton = new JButton("OK");
  72                 pane.add(okButton);
  73
  74                 labelA.setBounds(50, 10, 100, 20);
  75                 textFieldA.setBounds(40, 35, 120, 20);
  76                 labelB.setBounds(50, 70, 100, 20);
  77                 trackListA.setBounds(40, 95, 120, 20);
  78                 cancelButton.setBounds(10, 150, 80, 30);
  79                 okButton.setBounds(120, 150, 60, 30);
  80
  81                 setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - this.getWidth()) / 2,
  82                 (Toolkit.getDefaultToolkit().getScreenSize().height - this.getHeight()) / 2);
  83                 setResizable(false);
  84                 pack();
  85                 setSize(200,220);
  86                 setVisible(true);
  87         }
  88
  89         /**
  90          * Builds the delete track popupdialog.
  91          * @param pane          The container to put the dialog in.
  92          * @param tracks        A array containing miditracks.
  93          */
  94         private void makeDelDialog(Container pane, Track[] tracks) {
  95
  96                 setTitle("Delete track");
  97                 labelB = new JLabel("Delete track", JLabel.CENTER);
  98                 pane.add(labelB);
  99                 trackListA = new JComboBox();
 100                 for (int i = 1; i <= tracks.length; i++) trackListA.addItem("Track " + i);
 101                 pane.add(trackListA);
 102                 cancelButton = new JButton("Cancel");
 103                 pane.add(cancelButton);
 104                 okButton = new JButton("OK");
 105                 pane.add(okButton);
 106
 107                 labelB.setBounds(50, 10, 100, 20);
 108                 trackListA.setBounds(40, 35, 120, 20);
 109                 cancelButton.setBounds(10, 90, 80, 30);
 110                 okButton.setBounds(120, 90, 60, 30);
 111
 112                 setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - this.getWidth()) / 2,
 113                 (Toolkit.getDefaultToolkit().getScreenSize().height - this.getHeight()) / 2);
 114                 setResizable(false);
 115                 pack();
 116                 setSize(200,165);
 117                 setVisible(true);
 118         }
 119
 120         /**
 121          * Builds the copy track popupdialog.
 122          * @param pane          The container to put the dialog in.
 123          * @param tracks        A array containing miditracks.
 124          */
 125         private void makeCopyDialog(Container pane, Track[] tracks) {
 126
 127                 setTitle("Copy Track");
 128                 labelA = new JLabel("Track to copy", JLabel.CENTER);
 129                 pane.add(labelA);
 130                 trackListA = new JComboBox();
 131                 for (int i = 1; i <= tracks.length; i++) trackListA.addItem("Track " + i);
 132                 pane.add(trackListA);
 133                 labelB = new JLabel("Insert after", JLabel.CENTER);
 134                 pane.add(labelB);
 135                 trackListB = new JComboBox();
 136                 for (int i = 1; i <= tracks.length; i++) trackListB.addItem("Track " + i);
 137                 pane.add(trackListB);
 138                 cancelButton = new JButton("Cancel");
 139                 pane.add(cancelButton);
 140                 okButton = new JButton("OK");
 141                 pane.add(okButton);
 142
 143                 labelA.setBounds(50, 10, 100, 20);
 144                 trackListA.setBounds(40, 35, 120, 20);
 145                 labelB.setBounds(50, 70, 100, 20);
 146                 trackListB.setBounds(40, 95, 120, 20);
 147                 cancelButton.setBounds(10, 150, 80, 30);
 148                 okButton.setBounds(120, 150, 60, 30);
 149
 150                 setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - this.getWidth()) / 2,
 151                 (Toolkit.getDefaultToolkit().getScreenSize().height - this.getHeight()) / 2);
 152                 setResizable(false);
 153                 pack();
 154                 setSize(200,220);
 155                 setVisible(true);
 156         }
 157
 158         /**
 159          * Builds the move track popupdialog
 160          * @param pane          The container to put the dialog in.
 161          * @param tracks        A array containing miditracks.
 162          */
 163         private void makeMoveDialog(Container pane, Track[] tracks) {
 164
 165                 setTitle("Move track");
 166                 labelA = new JLabel("Track to move", JLabel.CENTER);
 167                 pane.add(labelA);
 168                 trackListA = new JComboBox();
 169                 for (int i = 1; i <= tracks.length; i++) trackListA.addItem("Track " + i);
 170                 pane.add(trackListA);
 171                 labelB = new JLabel("Insert after", JLabel.CENTER);
 172                 pane.add(labelB);
 173                 trackListB = new JComboBox();
 174                 for (int i = 1; i <= tracks.length; i++) trackListB.addItem("Track " + i);
 175                 pane.add(trackListB);
 176                 cancelButton = new JButton("Cancel");
 177                 pane.add(cancelButton);
 178                 okButton = new JButton("OK");
 179                 pane.add(okButton);
 180
 181                 labelA.setBounds(40, 10, 120, 20);
 182                 trackListA.setBounds(40, 35, 120, 20);
 183                 labelB.setBounds(50, 70, 100, 20);
 184                 trackListB.setBounds(40, 95, 120, 20);
 185                 cancelButton.setBounds(10, 150, 80, 30);
 186                 okButton.setBounds(120, 150, 60, 30);
 187
 188                 setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - this.getWidth()) / 2,
 189                 (Toolkit.getDefaultToolkit().getScreenSize().height - this.getHeight()) / 2);
 190                 setResizable(false);
 191                 pack();
 192                 setSize(200,220);
 193                 setVisible(true);
 194         }
 195
 196         /**
 197          * Builds the jump popupdialog.
 198          * @param pane          The container to put the dialog in.
 199          * @param tracks        A array containing miditracks.
 200          */
 201         private void makeJumpDialog(Container pane) {
 202
 203                 setTitle("Jump");
 204                 labelA = new JLabel("Msr", JLabel.CENTER);
 205                 pane.add(labelA);
 206                 labelB = new JLabel("Beat", JLabel.CENTER);
 207                 pane.add(labelB);
 208                 labelC = new JLabel("Tick", JLabel.CENTER);
 209                 pane.add(labelC);
 210                 textFieldA = new JTextField();
 211                 pane.add(textFieldA);
 212                 textFieldB = new JTextField();
 213                 pane.add(textFieldB);
 214                 textFieldC = new JTextField();
 215                 pane.add(textFieldC);
 216                 cancelButton = new JButton("Cancel");
 217                 pane.add(cancelButton);
 218                 okButton = new JButton("OK");
 219                 pane.add(okButton);
 220
 221                 labelA.setBounds(30, 25, 50, 20);
 222                 labelB.setBounds(105, 25, 50, 20);
 223                 labelC.setBounds(180, 25, 50, 20);
 224                 textFieldA.setBounds(30, 45, 50, 20);
 225                 textFieldB.setBounds(105, 45, 50, 20);
 226                 textFieldC.setBounds(180, 45, 50, 20);
 227                 cancelButton.setBounds(35, 90, 80, 30);
 228                 okButton.setBounds(155, 90, 60, 30);
 229
 230                 setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - this.getWidth()) / 2,
 231                 (Toolkit.getDefaultToolkit().getScreenSize().height - this.getHeight()) / 2);
 232                 setResizable(false);
 233                 pack();
 234                 setSize(260,165);
 235                 setVisible(true);
 236         }
 237
 238         /**
 239          * Builds the insert measure popupdialog.
 240          * @param pane          The container to put the dialog in.
 241          */
 242         private void makeInsertMeasureDialog(Container pane){
 243
 244                 setTitle("Insert Measure");
 245                 labelA = new JLabel("Insert at:", JLabel.RIGHT);
 246                 pane.add(labelA);
 247                 labelB = new JLabel("Measure count:", JLabel.RIGHT);
 248                 pane.add(labelB);
 249                 textFieldA = new JTextField();
 250                 pane.add(textFieldA);
 251                 textFieldB = new JTextField();
 252                 pane.add(textFieldB);
 253                 cancelButton = new JButton("Cancel");
 254                 pane.add(cancelButton);
 255                 okButton = new JButton("OK");
 256                 pane.add(okButton);
 257
 258                 labelA.setBounds(20, 20, 110 ,20);
 259                 labelB.setBounds(20, 50, 110, 20);
 260                 textFieldA.setBounds(140 ,20 , 40, 20);
 261                 textFieldB.setBounds(140,50, 40, 20);
 262                 cancelButton.setBounds(20 ,95 , 80, 30);
 263                 okButton.setBounds(120, 95, 60, 30);
 264
 265                 setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - this.getWidth()) / 2,
 266                 (Toolkit.getDefaultToolkit().getScreenSize().height - this.getHeight()) / 2);
 267                 setResizable(false);
 268                 pack();
 269                 setSize(210,175);
 270                 setVisible(true);
 271         }
 272
 273         /**
 274          * Builds the delete measure popupdialog.
 275          * @param pane          The container to put the dialog in.
 276          */
 277         private void makeDeleteMeasureDialog(Container pane) {
 278
 279                 setTitle("Delete Measure");
 280                 labelA = new JLabel("Delete at:", JLabel.RIGHT);
 281                 pane.add(labelA);
 282                 labelB = new JLabel("Measure count:", JLabel.RIGHT);
 283                 pane.add(labelB);
 284                 textFieldA = new JTextField();
 285                 pane.add(textFieldA);
 286                 textFieldB = new JTextField();
 287                 pane.add(textFieldB);
 288                 cancelButton = new JButton("Cancel");
 289                 pane.add(cancelButton);
 290                 okButton = new JButton("OK");
 291                 pane.add(okButton);
 292
 293                 labelA.setBounds(20, 20, 110 ,20);
 294                 labelB.setBounds(20, 50, 110, 20);
 295                 textFieldA.setBounds(140 ,20 , 40, 20);
 296                 textFieldB.setBounds(140,50, 40, 20);
 297                 cancelButton.setBounds(20 ,95 , 80, 30);
 298                 okButton.setBounds(120, 95, 60, 30);
 299
 300                 setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - this.getWidth()) / 2,
 301                 (Toolkit.getDefaultToolkit().getScreenSize().height - this.getHeight()) / 2);
 302                 setResizable(false);
 303                 pack();
 304                 setSize(210,175);
 305                 setVisible(true);
 306         }
 307
 308         private void makeTextDialog(Container pane, String filename) {
 309                 setTitle("Contents");
 310                 File manual = new File(filename);
 311                 String s;
 312                 try {
 313                         BufferedReader br = new BufferedReader(new FileReader(manual));
 314                         char[] chars = new char[(int)manual.length()];
 315                         br.read(chars, 0, (int)manual.length());
 316                         s = new String(chars);
 317                 } catch (Exception ex) {
 318                         s = "Manual not found";
 319                 }
 320                 JTextArea contents = new JTextArea(s, 30, 40);
 321                 contents.setAutoscrolls(true);
 322                 pane.add(contents);
 323                 contents.setBounds(10, 10, 500, 350);
 324                 setResizable(false);
 325                 pack();
 326                 setSize(600,400);
 327                 setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - this.getWidth()) / 2,
 328                 (Toolkit.getDefaultToolkit().getScreenSize().height - this.getHeight()) / 2);
 329                 setVisible(true);
 330         }
 331
 332         private MooNote note;
 333         private JOptionPane optionPane;
 334         private JTextField pitch;
 335         private JTextField velocity;
 336         private JTextField length;
 337
 338         /**
 339          * Creates a new note preference dialog.
 340          * @param mn    the note that will be graphically represented
 341          */
 342         public MooDialog(MooNote mn) {
 343                 super(Moosique.getGUI(), "Note properties", false);
 344                 note = mn;
 345                 pitch = new JTextField(new Integer(note.getPitch()).toString(),3);
 346                 JPanel pitchpanel = new JPanel();
 347                 pitchpanel.add(new Label("Pitch: "));
 348                 pitchpanel.add(pitch);
 349
 350
 351                 velocity = new JTextField(new Integer(note.getVelocity()).toString(),3);
 352                 JPanel velocitypanel = new JPanel();
 353                 velocitypanel.add(new Label("Velocity: "));
 354                 velocitypanel.add(velocity);
 355
 356                 length = new JTextField(new Integer(note.getDuration()).toString(),5);
 357                 JPanel lengthpanel = new JPanel();
 358                 lengthpanel.add(new Label("Length: "));
 359                 lengthpanel.add(length);
 360
 361                 Object[] array = {"Set the note properties",
 362                                 pitchpanel,
 363                                 velocitypanel,
 364                                 lengthpanel};
 365
 366                 final String btnString1 = "Enter";
 367                 final String btnString2 = "Cancel";
 368                 Object[] options = {btnString1, btnString2};
 369
 370                 optionPane = new JOptionPane(array,
 371                                             JOptionPane.QUESTION_MESSAGE,
 372                                             JOptionPane.YES_NO_OPTION,
 373                                             null,
 374                                             options,
 375                                             options[0]);
 376                 setContentPane(optionPane);
 377                 setDefaultCloseOperation(DISPOSE_ON_CLOSE);
 378
 379                 ActionListener intValidator = new ActionListener() {
 380                     public void actionPerformed(ActionEvent e) {
 381                                         if (e.getSource() instanceof JTextField){
 382                                                 JTextField s = (JTextField)e.getSource();
 383                                                 int num = Integer.parseInt(s.getText());
 384                                                 if (num < 0)
 385                                                         num = 0;
 386                                                 else if (num > 127 && s != length)
 387                                                         num = 127;
 388                                                 s.setText(new Integer(num).toString());
 389                                         }
 390                     }
 391                 };
 392                 pitch.addActionListener(intValidator);
 393                 velocity.addActionListener(intValidator);
 394                 length.addActionListener(intValidator);
 395
 396                 optionPane.addPropertyChangeListener(new PropertyChangeListener() {
 397                     public void propertyChange(PropertyChangeEvent e) {
 398                         String prop = e.getPropertyName();
 399
 400                         if (isVisible()
 401                          && (e.getSource() == optionPane)
 402                          && (prop.equals(JOptionPane.VALUE_PROPERTY) ||
 403                              prop.equals(JOptionPane.INPUT_VALUE_PROPERTY))) {
 404                             Object value = optionPane.getValue();
 405
 406                             if (value == JOptionPane.UNINITIALIZED_VALUE) {
 407                                 //ignore reset
 408                                 return;
 409                             }
 410
 411                             // Reset the JOptionPane's value.
 412                             // If you don't do this, then if the user
 413                             // presses the same button next time, no
 414                             // property change event will be fired.
 415                             optionPane.setValue(
 416                                     JOptionPane.UNINITIALIZED_VALUE);
 417
 418                             if (value.equals(btnString1)) {
 419                                                         note.setPitch(Integer.parseInt(pitch.getText()));
 420                                                         note.setVelocity(Integer.parseInt(velocity.getText()));
 421                                                         note.setDuration(Integer.parseInt(length.getText()));
 422
 423                                 setVisible(false);
 424                             } else { // user closed dialog or clicked cancel
 425                                 setVisible(false);
 426                             }
 427                         }
 428                     }
 429                 });
 430                 pack();
 431         }
 432 }