src/camidion/chordhelper/midieditor/SequenceTrackListTableModel.java

   1 package camidion.chordhelper.midieditor;
   2
   3 import java.io.ByteArrayOutputStream;
   4 import java.io.IOException;
   5 import java.io.UnsupportedEncodingException;
   6 import java.nio.charset.Charset;
   7 import java.util.ArrayList;
   8 import java.util.List;
   9 import java.util.Map;
  10 import java.util.Set;
  11
  12 import javax.sound.midi.MidiSystem;
  13 import javax.sound.midi.Sequence;
  14 import javax.sound.midi.Track;
  15 import javax.swing.DefaultListSelectionModel;
  16 import javax.swing.ListSelectionModel;
  17 import javax.swing.table.AbstractTableModel;
  18
  19 import camidion.chordhelper.music.MIDISpec;
  20
  21 /**
  22  * MIDIシーケンス（トラックリスト）のテーブルデータモデル
  23  */
  24 public class SequenceTrackListTableModel extends AbstractTableModel {
  25         /**
  26          * 列の列挙型
  27          */
  28         public enum Column {
  29                 /** トラック番号 */
  30                 TRACK_NUMBER("No.", Integer.class, 20),
  31                 /** イベント数 */
  32                 EVENTS("Events", Integer.class, 40),
  33                 /** Mute */
  34                 MUTE("Mute", Boolean.class, 30),
  35                 /** Solo */
  36                 SOLO("Solo", Boolean.class, 30),
  37                 /** 録音するMIDIチャンネル */
  38                 RECORD_CHANNEL("RecCh", String.class, 40),
  39                 /** MIDIチャンネル */
  40                 CHANNEL("Ch", String.class, 30),
  41                 /** トラック名 */
  42                 TRACK_NAME("Track name", String.class, 100);
  43                 String title;
  44                 Class<?> columnClass;
  45                 int preferredWidth;
  46                 /**
  47                  * 列の識別子を構築します。
  48                  * @param title 列のタイトル
  49                  * @param widthRatio 幅の割合
  50                  * @param columnClass 列のクラス
  51                  * @param perferredWidth 列の適切な幅
  52                  */
  53                 private Column(String title, Class<?> columnClass, int preferredWidth) {
  54                         this.title = title;
  55                         this.columnClass = columnClass;
  56                         this.preferredWidth = preferredWidth;
  57                 }
  58         }
  59         /**
  60          * 親のプレイリスト
  61          */
  62         PlaylistTableModel sequenceListTableModel;
  63         /**
  64          * ラップされたMIDIシーケンス
  65          */
  66         private Sequence sequence;
  67         /**
  68          * ラップされたMIDIシーケンスのtickインデックス
  69          */
  70         private SequenceTickIndex sequenceTickIndex;
  71         /**
  72          * MIDIファイル名
  73          */
  74         private String filename = "";
  75         /**
  76          * テキスト部分の文字コード（タイトル、歌詞など）
  77          */
  78         public Charset charset = Charset.defaultCharset();
  79         /**
  80          * トラックリスト
  81          */
  82         private List<TrackEventListTableModel> trackModelList = new ArrayList<>();
  83         /**
  84          * 選択されているトラックのインデックス
  85          */
  86         ListSelectionModel trackListSelectionModel = new DefaultListSelectionModel(){
  87                 {
  88                         setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
  89                 }
  90         };
  91         /**
  92          * MIDIシーケンスとファイル名から {@link SequenceTrackListTableModel} を構築します。
  93          * @param sequenceListTableModel 親のプレイリスト
  94          * @param sequence MIDIシーケンス
  95          * @param filename ファイル名
  96          */
  97         public SequenceTrackListTableModel(
  98                 PlaylistTableModel sequenceListTableModel,
  99                 Sequence sequence,
 100                 String filename
 101         ) {
 102                 this.sequenceListTableModel = sequenceListTableModel;
 103                 setSequence(sequence);
 104                 setFilename(filename);
 105         }
 106         @Override
 107         public int getRowCount() {
 108                 return sequence == null ? 0 : sequence.getTracks().length;
 109         }
 110         @Override
 111         public int getColumnCount() {
 112                 return Column.values().length;
 113         }
 114         /**
 115          * 列名を返します。
 116          * @return 列名
 117          */
 118         @Override
 119         public String getColumnName(int column) {
 120                 return Column.values()[column].title;
 121         }
 122         /**
 123          * 指定された列の型を返します。
 124          * @return 指定された列の型
 125          */
 126         @Override
 127         public Class<?> getColumnClass(int column) {
 128                 SequenceTrackListTableModel.Column c = Column.values()[column];
 129                 switch(c) {
 130                 case MUTE:
 131                 case SOLO: if( ! isOnSequencer() ) return String.class;
 132                         // FALLTHROUGH
 133                 default: return c.columnClass;
 134                 }
 135         }
 136         @Override
 137         public Object getValueAt(int row, int column) {
 138                 SequenceTrackListTableModel.Column c = Column.values()[column];
 139                 switch(c) {
 140                 case TRACK_NUMBER: return row;
 141                 case EVENTS: return sequence.getTracks()[row].size();
 142                 case MUTE:
 143                         return isOnSequencer() ? sequenceListTableModel.sequencerModel.getSequencer().getTrackMute(row) : "";
 144                 case SOLO:
 145                         return isOnSequencer() ? sequenceListTableModel.sequencerModel.getSequencer().getTrackSolo(row) : "";
 146                 case RECORD_CHANNEL:
 147                         return isOnSequencer() ? trackModelList.get(row).getRecordingChannel() : "";
 148                 case CHANNEL: {
 149                         int ch = trackModelList.get(row).getChannel();
 150                         return ch < 0 ? "" : ch + 1 ;
 151                 }
 152                 case TRACK_NAME: return trackModelList.get(row).toString();
 153                 default: return "";
 154                 }
 155         }
 156         /**
 157          * セルが編集可能かどうかを返します。
 158          */
 159         @Override
 160         public boolean isCellEditable(int row, int column) {
 161                 SequenceTrackListTableModel.Column c = Column.values()[column];
 162                 switch(c) {
 163                 case MUTE:
 164                 case SOLO:
 165                 case RECORD_CHANNEL: return isOnSequencer();
 166                 case CHANNEL:
 167                 case TRACK_NAME: return true;
 168                 default: return false;
 169                 }
 170         }
 171         /**
 172          * 列の値を設定します。
 173          */
 174         @Override
 175         public void setValueAt(Object val, int row, int column) {
 176                 SequenceTrackListTableModel.Column c = Column.values()[column];
 177                 switch(c) {
 178                 case MUTE:
 179                         sequenceListTableModel.sequencerModel.getSequencer().setTrackMute(row, ((Boolean)val).booleanValue());
 180                         break;
 181                 case SOLO:
 182                         sequenceListTableModel.sequencerModel.getSequencer().setTrackSolo(row, ((Boolean)val).booleanValue());
 183                         break;
 184                 case RECORD_CHANNEL:
 185                         trackModelList.get(row).setRecordingChannel((String)val);
 186                         break;
 187                 case CHANNEL: {
 188                         Integer ch;
 189                         try {
 190                                 ch = new Integer((String)val);
 191                         }
 192                         catch( NumberFormatException e ) {
 193                                 ch = -1;
 194                                 break;
 195                         }
 196                         if( --ch <= 0 || ch > MIDISpec.MAX_CHANNELS )
 197                                 break;
 198                         TrackEventListTableModel trackTableModel = trackModelList.get(row);
 199                         if( ch == trackTableModel.getChannel() ) break;
 200                         trackTableModel.setChannel(ch);
 201                         setModified(true);
 202                         fireTableCellUpdated(row, Column.EVENTS.ordinal());
 203                         break;
 204                 }
 205                 case TRACK_NAME:
 206                         trackModelList.get(row).setString((String)val);
 207                         break;
 208                 default:
 209                         break;
 210                 }
 211                 fireTableCellUpdated(row,column);
 212         }
 213         /**
 214          * MIDIシーケンスを返します。
 215          * @return MIDIシーケンス
 216          */
 217         public Sequence getSequence() { return sequence; }
 218         /**
 219          * シーケンスtickインデックスを返します。
 220          * @return シーケンスtickインデックス
 221          */
 222         public SequenceTickIndex getSequenceTickIndex() {
 223                 return sequenceTickIndex;
 224         }
 225         /**
 226          * MIDIシーケンスを設定します。
 227          * @param sequence MIDIシーケンス（nullを指定するとトラックリストが空になる）
 228          */
 229         private void setSequence(Sequence sequence) {
 230                 //
 231                 // 旧シーケンスの録音モードを解除
 232                 sequenceListTableModel.sequencerModel.getSequencer().recordDisable(null); // The "null" means all tracks
 233                 //
 234                 // トラックリストをクリア
 235                 int oldSize = trackModelList.size();
 236                 if( oldSize > 0 ) {
 237                         trackModelList.clear();
 238                         fireTableRowsDeleted(0, oldSize-1);
 239                 }
 240                 // 新シーケンスに置き換える
 241                 if( (this.sequence = sequence) == null ) {
 242                         // 新シーケンスがない場合
 243                         sequenceTickIndex = null;
 244                         return;
 245                 }
 246                 // tickインデックスを再構築
 247                 fireTimeSignatureChanged();
 248                 //
 249                 // トラックリストを再構築
 250                 Track tracks[] = sequence.getTracks();
 251                 for(Track track : tracks) {
 252                         trackModelList.add(new TrackEventListTableModel(this, track));
 253                 }
 254                 // 文字コードの判定
 255                 byte b[] = MIDISpec.getNameBytesOf(sequence);
 256                 if( b != null && b.length > 0 ) {
 257                         try {
 258                                 String autoDetectedName = new String(b, "JISAutoDetect");
 259                                 Set<Map.Entry<String,Charset>> entrySet;
 260                                 entrySet = Charset.availableCharsets().entrySet();
 261                                 for( Map.Entry<String,Charset> entry : entrySet ) {
 262                                         Charset cs = entry.getValue();
 263                                         if( ! autoDetectedName.equals(new String(b, cs)) )
 264                                                 continue;
 265                                         charset = cs;
 266                                         break;
 267                                 }
 268                         } catch (UnsupportedEncodingException e) {
 269                                 e.printStackTrace();
 270                         }
 271                 }
 272                 // トラックが挿入されたことを通知
 273                 fireTableRowsInserted(0, tracks.length-1);
 274         }
 275         /**
 276          * 拍子が変更されたとき、シーケンスtickインデックスを再作成します。
 277          */
 278         public void fireTimeSignatureChanged() {
 279                 sequenceTickIndex = new SequenceTickIndex(sequence);
 280         }
 281         private boolean isModified = false;
 282         /**
 283          * 変更されたかどうかを返します。
 284          * @return 変更済みのときtrue
 285          */
 286         public boolean isModified() { return isModified; }
 287         /**
 288          * 変更されたかどうかを設定します。
 289          * @param isModified 変更されたときtrue
 290          */
 291         public void setModified(boolean isModified) { this.isModified = isModified; }
 292         /**
 293          * ファイル名を設定します。
 294          * @param filename ファイル名
 295          */
 296         public void setFilename(String filename) { this.filename = filename; }
 297         /**
 298          * ファイル名を返します。
 299          * @return ファイル名
 300          */
 301         public String getFilename() { return filename; }
 302         @Override
 303         public String toString() {
 304                 byte b[] = MIDISpec.getNameBytesOf(sequence);
 305                 return b == null ? "" : new String(b, charset);
 306         }
 307         /**
 308          * シーケンス名を設定します。
 309          * @param name シーケンス名
 310          * @return 成功したらtrue
 311          */
 312         public boolean setName(String name) {
 313                 if( name.equals(toString()) )
 314                         return false;
 315                 byte b[] = name.getBytes(charset);
 316                 if( ! MIDISpec.setNameBytesOf(sequence, b) )
 317                         return false;
 318                 setModified(true);
 319                 fireTableDataChanged();
 320                 return true;
 321         }
 322         /**
 323          * このシーケンスのMIDIデータのバイト列を返します。
 324          * @return MIDIデータのバイト列（失敗した場合null）
 325          */
 326         public byte[] getMIDIdata() {
 327                 if( sequence == null || sequence.getTracks().length == 0 ) {
 328                         return null;
 329                 }
 330                 try( ByteArrayOutputStream out = new ByteArrayOutputStream() ) {
 331                         MidiSystem.write(sequence, 1, out);
 332                         return out.toByteArray();
 333                 } catch ( IOException e ) {
 334                         e.printStackTrace();
 335                         return null;
 336                 }
 337         }
 338         /**
 339          * 指定のトラックが変更されたことを通知します。
 340          * @param track トラック
 341          */
 342         public void fireTrackChanged(Track track) {
 343                 int row = indexOf(track);
 344                 if( row < 0 ) return;
 345                 fireTableRowsUpdated(row, row);
 346                 sequenceListTableModel.fireSequenceModified(this);
 347         }
 348         /**
 349          * 選択されているトラックモデルを返します。
 350          * @param index トラックのインデックス
 351          * @return トラックモデル（見つからない場合null）
 352          */
 353         public TrackEventListTableModel getSelectedTrackModel() {
 354                 if( trackListSelectionModel.isSelectionEmpty() )
 355                         return null;
 356                 int index = trackListSelectionModel.getMinSelectionIndex();
 357                 Track tracks[] = sequence.getTracks();
 358                 if( tracks.length != 0 ) {
 359                         Track track = tracks[index];
 360                         for( TrackEventListTableModel model : trackModelList )
 361                                 if( model.getTrack() == track )
 362                                         return model;
 363                 }
 364                 return null;
 365         }
 366         /**
 367          * 指定のトラックがある位置のインデックスを返します。
 368          * @param track トラック
 369          * @return トラックのインデックス（先頭 0、トラックが見つからない場合 -1）
 370          */
 371         public int indexOf(Track track) {
 372                 Track tracks[] = sequence.getTracks();
 373                 for( int i=0; i<tracks.length; i++ )
 374                         if( tracks[i] == track )
 375                                 return i;
 376                 return -1;
 377         }
 378         /**
 379          * 新しいトラックを生成し、末尾に追加します。
 380          * @return 追加したトラックのインデックス（先頭 0）
 381          */
 382         public int createTrack() {
 383                 Track newTrack = sequence.createTrack();
 384                 trackModelList.add(new TrackEventListTableModel(this, newTrack));
 385                 int lastRow = getRowCount() - 1;
 386                 fireTableRowsInserted(lastRow, lastRow);
 387                 sequenceListTableModel.fireSelectedSequenceModified();
 388                 trackListSelectionModel.setSelectionInterval(lastRow, lastRow);
 389                 return lastRow;
 390         }
 391         /**
 392          * 選択されているトラックを削除します。
 393          */
 394         public void deleteSelectedTracks() {
 395                 if( trackListSelectionModel.isSelectionEmpty() )
 396                         return;
 397                 int minIndex = trackListSelectionModel.getMinSelectionIndex();
 398                 int maxIndex = trackListSelectionModel.getMaxSelectionIndex();
 399                 Track tracks[] = sequence.getTracks();
 400                 for( int i = maxIndex; i >= minIndex; i-- ) {
 401                         if( ! trackListSelectionModel.isSelectedIndex(i) )
 402                                 continue;
 403                         sequence.deleteTrack(tracks[i]);
 404                         trackModelList.remove(i);
 405                 }
 406                 fireTableRowsDeleted(minIndex, maxIndex);
 407                 sequenceListTableModel.fireSelectedSequenceModified();
 408         }
 409         /**
 410          * このシーケンスモデルのシーケンスをシーケンサーが操作しているか調べます。
 411          * @return シーケンサーが操作していたらtrue
 412          */
 413         public boolean isOnSequencer() {
 414                 return sequence == sequenceListTableModel.sequencerModel.getSequencer().getSequence();
 415         }
 416         /**
 417          * 録音しようとしているチャンネルの設定されたトラックがあるか調べます。
 418          * @return 該当トラックがあればtrue
 419          */
 420         public boolean hasRecordChannel() {
 421                 int rowCount = getRowCount();
 422                 for( int row=0; row < rowCount; row++ ) {
 423                         Object value = getValueAt(row, Column.RECORD_CHANNEL.ordinal());
 424                         if( ! "OFF".equals(value) ) return true;
 425                 }
 426                 return false;
 427         }
 428 }