/* Sequencer.java -- A MIDI sequencer object
   Copyright (C) 2005 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package javax.sound.midi;

import java.io.IOException;
import java.io.InputStream;

/**
 * A Sequencer object plays MIDI sequences described as Sequence objects.
 * This class provides methods for loading and unloading sequences, as well
 * as basic transport controls.
 * 
 * @author Anthony Green (green@redhat.com)
 * @since 1.3
 *
 */
public interface Sequencer extends MidiDevice
{
  /**
   * Set the Sequence object for this sequencer.
   * 
   * @param seq the Sequence to process
   * @throws InvalidMidiDataException if the sequence is invalid for any reason
   */
  public void setSequence(Sequence seq) throws InvalidMidiDataException;
  
  /**
   * Set the sequence for this sequencer.  istream reads on a valid MIDI file.
   * 
   * @param istream an input stream for a valid MIDI file
   * @throws IOException if an I/O exception happens
   * @throws InvalidMidiDataException if the MIDI file contains bad data
   */
  public void setSequence(InputStream istream) 
      throws IOException, InvalidMidiDataException;
  
  /**
   * Get the current sequence object for this sequencer.
   * 
   * @return the current sequence object.  May be null.
   */
  public Sequence getSequence();
  
  /**
   * Start playback of the current sequence.
   */
  public void start();
  
  /**
   * Stop playback of the current sequence.
   */
  public void stop();
  
  /**
   * Returns true if the sequence is playing.
   * 
   * @return true if the sequence is playing and false otherwise
   */
  public boolean isRunning();
  
  /**
   * Start playback and record of MIDI events.
   * Any tracks enabled for recording will have their events replaced.
   * Any newly recorded events, and all events from non-recording tracks
   * will be sent to the sequencer's transmitter.
   */
  public void startRecording();
  
  /**
   * Stop recording, although continue playing.
   */
  public void stopRecording();
  
  /**
   * Returns true if sequence is recording.
   * 
   * @return true if the sequence is recording and false otherwise
   */
  public boolean isRecording();
  
  /**
   * Enable recording for a specific track using data from a specific channel.
   * 
   * @param track the track to enable for recording 
   * @param channel the channel from which to record
   */
  public void recordEnable(Track track, int channel);
  
  /**
   * Disable recording for a specific track.
   * 
   * @param track the track to disable recording for
   */
  public void recordDisable(Track track);
  
  /**
   * Get the current tempo in beats per minute.
   * 
   * @return the current tempo in beats per minute
   */
  public float getTempoInBPM();
  
  /**
   * Sets the current tempo in beats per minute.
   * 
   * @param bpm the new tempo in bears per minutes
   */
  public void setTempoInBPM(float bpm);
  
  /**
   * Get the current tempo in microseconds per quarter note.
   * 
   * @return the current tempo in microseconds per quarter note.
   */
  public float getTempoInMPQ();
  
  /**
   * Sets the current tempo in microseconds per quarter note.
   * 
   * @param mpq the new tempo in microseconds per quarter note.
   */
  public void setTempoInMPQ(float mpq);
  
  /**
   * Set a scaling factor for the playback tempo, which is 1.0 by default.
   * 
   * @param factor the new tempo scaling factor
   */
  public void setTempoFactor(float factor);
  
  /**
   * Get the current scaling factor for the playback tempo.
   * 
   * @return the current tempo scaling factor 
   */
  public float getTempoFactor();
  
  /**
   * Get the length of the current sequence in MIDI ticks.
   *  
   * @return the length of the current sequence in MIDI ticks
   */
  public long getTickLength();
  
  /**
   * Get the current playback position of the sequencer in MIDI ticks.
   * 
   * @return the current playback position of the sequencer in MIDI ticks
   */
  public long getTickPosition();
  
  /**
   * Set the current playback position of the sequencer in MIDI ticks.
   * 
   * @param tick the new playback position of the sequencer in MIDI ticks
   */
  public void setTickPosition(long tick);

  /**
   * Get the length of the current sequence in microseconds.
   *  
   * @return the length of the current sequence in microseconds
   */
  public long getMicrosecondLength();
  
  /**
   * Get the current playback position of the sequencer in microseconds.
   * 
   * @return the current playback position of the sequencer in microseconds
   */
  public long getMicrosecondPosition();
  
  /**
   * Set the current playback position of the sequencer in microseconds.
   * 
   * @param microsecond the new playback position of the sequencer in microseconds
   */
  public void setMicrosecondPosition(long microsecond);

  /**
   * Set the source of timing information.  sync must be found in the array
   * returned by getMasterSyncModes().
   * FIXME: What happens if it isn't?
   * 
   * @param sync the new source of timing information
   */
  public void setMasterSyncMode(SyncMode sync);
  
  /**
   * Get the source of timing information.
   * 
   * @return the current source of timing information
   */
  public SyncMode getMasterSyncMode();
  
  /**
   * Get an array of timing sources supported by this sequencer.
   * 
   * @return an array of timing sources supported by this sequencer
   */
  public SyncMode[] getMasterSyncModes();
  
  /**
   * Set the slave synchronization mode for this sequencer.  sync must be
   * found in the array returned by getSlaveSyncModes().
   * FIXME: What happens if it isn't?
   * 
   * @param sync the new slave sync mode for this sequencer
   */
  public void setSlaveSyncMode(SyncMode sync);
  
  /**
   * Get the current slave synchronization mode.
   * 
   * @return the current slave synchronization mode
   */
  public SyncMode getSlaveSyncMode();
  
  /**
   * Get an array of slave sync modes supported by this sequencer.
   * 
   * @return an array of slave sync modes supported by this sequencer
   */
  public SyncMode[] getSlaveSyncModes();
  
  /**
   * Sets the mute state for a specific track.
   * 
   * @param track the track to modify
   * @param mute the new mute state
   */
  public void setTrackMute(int track, boolean mute);
  
  /**
   * Get the mute state of a specific track.
   * 
   * @param track the track to query
   * @return the mute state for track
   */
  public boolean getTrackMute(int track);
  
  /**
   * Sets the solo state for a specific track.
   * 
   * @param track the track to modify
   * @param solo the new solo state
   */
  public void setTrackSolo(int track, boolean solo);
  
  /**
   * Get the solo state for a specific track.
   * 
   * @param track the track to query
   * @return the solo state for track
   */
  public boolean getTrackSolo(int track);
  
  /**
   * Add a meta event listening object to this sequencer.  It will receive
   * notification whenever the sequencer processes a meta event.
   * A listener may fail to get added if this sequencer doesn't support
   * meta events.
   * 
   * @param listener the listener to add
   * @return true if listener was added, false othewise
   */
  public boolean addMetaEventListener(MetaEventListener listener);
  
  /**
   * Remove a meta event listener from this sequencer.
   * 
   * @param listener the listener to remove
   */
  public void removeMetaEventListener(MetaEventListener listener);
  
  /**
   * Add a controller event listening object to this sequencer.  It will 
   * receive notification whenever the sequencer processes a controller 
   * event for a specified controller number..
   * 
   * @param listener the listener to add
   * @param controllers the conroller numbers to listen to
   * @return the controller numbers being listened to
   */
  public int[] addControllerEventListener(ControllerEventListener listener, 
                                          int controllers[]);
  
  /**
   * Remove a controller listener from this sequencer for the specified
   * controller numbers.
   * 
   * @param listener the listener to remove
   * @param controllers the controllers to unlisten
   * @return the controller numbers being unlistened
   */
  public int[] removeControllerEventListener(ControllerEventListener listener,
                                             int controllers[]);
  
  /**
   * A SyncMode object represents the mechanism by which a MIDI sequencer
   * synchronizes time with a master or slave device.
   * 
   * @author green@redhat.com
   *
   */
  public static class SyncMode
  {
    /**
     * A master sync mode indicating the use of an internal sequencer clock.
     */
    public static final SyncMode INTERNAL_CLOCK = new SyncMode("Internal Clock");
    
    /**
     * A master or slave sync mode indicating the use of MIDI clock messages.
     */
    public static final SyncMode MIDI_SYNC = new SyncMode("MIDI Sync");
    
    /**
     * A master or slave sync mode indicating the use of MIDI Time Code 
     * messages.
     */
    public static final SyncMode MIDI_TIME_CODE = new SyncMode("MIDI Time Code");
    
    /**
     * A slave sync mode indicating that no timing info will be transmitted.
     */
    public static final SyncMode NO_SYNC = new SyncMode("No Timing");

    // The name
    private String name;
    
    /**
     * Create a new SyncMode object
     * @param name the SyncMode name
     */
    protected SyncMode(String name)
    {
      this.name = name;
    }
    
    /**
     * SyncMode objects are only equal when identical.
     */
    public final boolean equals(Object o)
    {
      return super.equals(o);
    }
    
    /**
     * SyncMode objects use the Object hashCode.
     */
    public int hashCode()
    {
      return super.hashCode();
    }
    
    /**
     * Use the SyncMode name as the string representation.
     * @see java.lang.Object#toString()
     */
    public final String toString()
    {
      return name;
    }
  }
}
