Back to index...

	/*
	* Copyright (c) 1999, 2003, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.sound.midi;

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


	/**
	* A hardware or software device that plays back a MIDI
	* <code>{@link Sequence sequence}</code> is known as a <em>sequencer</em>.
	* A MIDI sequence contains lists of time-stamped MIDI data, such as
	* might be read from a standard MIDI file. Most
	* sequencers also provide functions for creating and editing sequences.
	* <p>
	* The <code>Sequencer</code> interface includes methods for the following
	* basic MIDI sequencer operations:
	* <ul>
	* <li>obtaining a sequence from MIDI file data</li>
	* <li>starting and stopping playback</li>
	* <li>moving to an arbitrary position in the sequence</li>
	* <li>changing the tempo (speed) of playback</li>
	* <li>synchronizing playback to an internal clock or to received MIDI
	* messages</li>
	* <li>controlling the timing of another device</li>
	* </ul>
	* In addition, the following operations are supported, either directly, or
	* indirectly through objects that the <code>Sequencer</code> has access to:
	* <ul>
	* <li>editing the data by adding or deleting individual MIDI events or entire
	* tracks</li>
	* <li>muting or soloing individual tracks in the sequence</li>
	* <li>notifying listener objects about any meta-events or
	* control-change events encountered while playing back the sequence.</li>
	* </ul>
	*
	* @see Sequencer.SyncMode
	* @see #addMetaEventListener
	* @see ControllerEventListener
	* @see Receiver
	* @see Transmitter
	* @see MidiDevice
	*
	* @author Kara Kytle
	* @author Florian Bomers
	*/
	public interface Sequencer extends MidiDevice {


	/**
	* A value indicating that looping should continue
	* indefinitely rather than complete after a specific
	* number of loops.
	*
	* @see #setLoopCount
	* @since 1.5
	*/
	public static final int LOOP_CONTINUOUSLY = -1;



	/**
	* Sets the current sequence on which the sequencer operates.
	*
	* <p>This method can be called even if the
	* <code>Sequencer</code> is closed.
	*
	* @param sequence the sequence to be loaded.
	* @throws InvalidMidiDataException if the sequence contains invalid
	* MIDI data, or is not supported.
	*/
	public void setSequence(Sequence sequence) throws InvalidMidiDataException;


	/**
	* Sets the current sequence on which the sequencer operates.
	* The stream must point to MIDI file data.
	*
	* <p>This method can be called even if the
	* <code>Sequencer</code> is closed.
	*
	* @param stream stream containing MIDI file data.
	* @throws IOException if an I/O exception occurs during reading of the stream.
	* @throws InvalidMidiDataException if invalid data is encountered
	* in the stream, or the stream is not supported.
	*/
	public void setSequence(InputStream stream) throws IOException, InvalidMidiDataException;


	/**
	* Obtains the sequence on which the Sequencer is currently operating.
	*
	* <p>This method can be called even if the
	* <code>Sequencer</code> is closed.
	*
	* @return the current sequence, or <code>null</code> if no sequence is currently set.
	*/
	public Sequence getSequence();


	/**
	* Starts playback of the MIDI data in the currently
	* loaded sequence.
	* Playback will begin from the current position.
	* If the playback position reaches the loop end point,
	* and the loop count is greater than 0, playback will
	* resume at the loop start point for the number of
	* repetitions set with <code>setLoopCount</code>.
	* After that, or if the loop count is 0, playback will
	* continue to play to the end of the sequence.
	*
	* <p>The implementation ensures that the synthesizer
	* is brought to a consistent state when jumping
	* to the loop start point by sending appropriate
	* controllers, pitch bend, and program change events.
	*
	* @throws IllegalStateException if the <code>Sequencer</code> is
	* closed.
	*
	* @see #setLoopStartPoint
	* @see #setLoopEndPoint
	* @see #setLoopCount
	* @see #stop
	*/
	public void start();


	/**
	* Stops recording, if active, and playback of the currently loaded sequence,
	* if any.
	*
	* @throws IllegalStateException if the <code>Sequencer</code> is
	* closed.
	*
	* @see #start
	* @see #isRunning
	*/
	public void stop();


	/**
	* Indicates whether the Sequencer is currently running. The default is <code>false</code>.
	* The Sequencer starts running when either <code>{@link #start}</code> or <code>{@link #startRecording}</code>
	* is called. <code>isRunning</code> then returns <code>true</code> until playback of the
	* sequence completes or <code>{@link #stop}</code> is called.
	* @return <code>true</code> if the Sequencer is running, otherwise <code>false</code>
	*/
	public boolean isRunning();


	/**
	* Starts recording and playback of MIDI data. Data is recorded to all enabled tracks,
	* on the channel(s) for which they were enabled. Recording begins at the current position
	* of the sequencer. Any events already in the track are overwritten for the duration
	* of the recording session. Events from the currently loaded sequence,
	* if any, are delivered to the sequencer's transmitter(s) along with messages
	* received during recording.
	* <p>
	* Note that tracks are not by default enabled for recording. In order to record MIDI data,
	* at least one track must be specifically enabled for recording.
	*
	* @throws IllegalStateException if the <code>Sequencer</code> is
	* closed.
	*
	* @see #startRecording
	* @see #recordEnable
	* @see #recordDisable
	*/
	public void startRecording();


	/**
	* Stops recording, if active. Playback of the current sequence continues.
	*
	* @throws IllegalStateException if the <code>Sequencer</code> is
	* closed.
	*
	* @see #startRecording
	* @see #isRecording
	*/
	public void stopRecording();


	/**
	* Indicates whether the Sequencer is currently recording. The default is <code>false</code>.
	* The Sequencer begins recording when <code>{@link #startRecording}</code> is called,
	* and then returns <code>true</code> until <code>{@link #stop}</code> or <code>{@link #stopRecording}</code>
	* is called.
	* @return <code>true</code> if the Sequencer is recording, otherwise <code>false</code>
	*/
	public boolean isRecording();


	/**
	* Prepares the specified track for recording events received on a particular channel.
	* Once enabled, a track will receive events when recording is active.
	* @param track the track to which events will be recorded
	* @param channel the channel on which events will be received. If -1 is specified
	* for the channel value, the track will receive data from all channels.
	* @throws IllegalArgumentException thrown if the track is not part of the current
	* sequence.
	*/
	public void recordEnable(Track track, int channel);


	/**
	* Disables recording to the specified track. Events will no longer be recorded
	* into this track.
	* @param track the track to disable for recording, or <code>null</code> to disable
	* recording for all tracks.
	*/
	public void recordDisable(Track track);


	/**
	* Obtains the current tempo, expressed in beats per minute. The
	* actual tempo of playback is the product of the returned value
	* and the tempo factor.
	*
	* @return the current tempo in beats per minute
	*
	* @see #getTempoFactor
	* @see #setTempoInBPM(float)
	* @see #getTempoInMPQ
	*/
	public float getTempoInBPM();


	/**
	* Sets the tempo in beats per minute. The actual tempo of playback
	* is the product of the specified value and the tempo factor.
	*
	* @param bpm desired new tempo in beats per minute
	* @see #getTempoFactor
	* @see #setTempoInMPQ(float)
	* @see #getTempoInBPM
	*/
	public void setTempoInBPM(float bpm);


	/**
	* Obtains the current tempo, expressed in microseconds per quarter
	* note. The actual tempo of playback is the product of the returned
	* value and the tempo factor.
	*
	* @return the current tempo in microseconds per quarter note
	* @see #getTempoFactor
	* @see #setTempoInMPQ(float)
	* @see #getTempoInBPM
	*/
	public float getTempoInMPQ();


	/**
	* Sets the tempo in microseconds per quarter note. The actual tempo
	* of playback is the product of the specified value and the tempo
	* factor.
	*
	* @param mpq desired new tempo in microseconds per quarter note.
	* @see #getTempoFactor
	* @see #setTempoInBPM(float)
	* @see #getTempoInMPQ
	*/
	public void setTempoInMPQ(float mpq);


	/**
	* Scales the sequencer's actual playback tempo by the factor provided.
	* The default is 1.0. A value of 1.0 represents the natural rate (the
	* tempo specified in the sequence), 2.0 means twice as fast, etc.
	* The tempo factor does not affect the values returned by
	* <code>{@link #getTempoInMPQ}</code> and <code>{@link #getTempoInBPM}</code>.
	* Those values indicate the tempo prior to scaling.
	* <p>
	* Note that the tempo factor cannot be adjusted when external
	* synchronization is used. In that situation,
	* <code>setTempoFactor</code> always sets the tempo factor to 1.0.
	*
	* @param factor the requested tempo scalar
	* @see #getTempoFactor
	*/
	public void setTempoFactor(float factor);


	/**
	* Returns the current tempo factor for the sequencer. The default is
	* 1.0.
	*
	* @return tempo factor.
	* @see #setTempoFactor(float)
	*/
	public float getTempoFactor();


	/**
	* Obtains the length of the current sequence, expressed in MIDI ticks,
	* or 0 if no sequence is set.
	* @return length of the sequence in ticks
	*/
	public long getTickLength();


	/**
	* Obtains the current position in the sequence, expressed in MIDI
	* ticks. (The duration of a tick in seconds is determined both by
	* the tempo and by the timing resolution stored in the
	* <code>{@link Sequence}</code>.)
	*
	* @return current tick
	* @see #setTickPosition
	*/
	public long getTickPosition();


	/**
	* Sets the current sequencer position in MIDI ticks
	* @param tick the desired tick position
	* @see #getTickPosition
	*/
	public void setTickPosition(long tick);


	/**
	* Obtains the length of the current sequence, expressed in microseconds,
	* or 0 if no sequence is set.
	* @return length of the sequence in microseconds.
	*/
	public long getMicrosecondLength();


	/**
	* Obtains the current position in the sequence, expressed in
	* microseconds.
	* @return the current position in microseconds
	* @see #setMicrosecondPosition
	*/
	public long getMicrosecondPosition();


	/**
	* Sets the current position in the sequence, expressed in microseconds
	* @param microseconds desired position in microseconds
	* @see #getMicrosecondPosition
	*/
	public void setMicrosecondPosition(long microseconds);


	/**
	* Sets the source of timing information used by this sequencer.
	* The sequencer synchronizes to the master, which is the internal clock,
	* MIDI clock, or MIDI time code, depending on the value of
	* <code>sync</code>. The <code>sync</code> argument must be one
	* of the supported modes, as returned by
	* <code>{@link #getMasterSyncModes}</code>.
	*
	* @param sync the desired master synchronization mode
	*
	* @see SyncMode#INTERNAL_CLOCK
	* @see SyncMode#MIDI_SYNC
	* @see SyncMode#MIDI_TIME_CODE
	* @see #getMasterSyncMode
	*/
	public void setMasterSyncMode(SyncMode sync);


	/**
	* Obtains the current master synchronization mode for this sequencer.
	*
	* @return the current master synchronization mode
	*
	* @see #setMasterSyncMode(Sequencer.SyncMode)
	* @see #getMasterSyncModes
	*/
	public SyncMode getMasterSyncMode();


	/**
	* Obtains the set of master synchronization modes supported by this
	* sequencer.
	*
	* @return the available master synchronization modes
	*
	* @see SyncMode#INTERNAL_CLOCK
	* @see SyncMode#MIDI_SYNC
	* @see SyncMode#MIDI_TIME_CODE
	* @see #getMasterSyncMode
	* @see #setMasterSyncMode(Sequencer.SyncMode)
	*/
	public SyncMode[] getMasterSyncModes();


	/**
	* Sets the slave synchronization mode for the sequencer.
	* This indicates the type of timing information sent by the sequencer
	* to its receiver. The <code>sync</code> argument must be one
	* of the supported modes, as returned by
	* <code>{@link #getSlaveSyncModes}</code>.
	*
	* @param sync the desired slave synchronization mode
	*
	* @see SyncMode#MIDI_SYNC
	* @see SyncMode#MIDI_TIME_CODE
	* @see SyncMode#NO_SYNC
	* @see #getSlaveSyncModes
	*/
	public void setSlaveSyncMode(SyncMode sync);


	/**
	* Obtains the current slave synchronization mode for this sequencer.
	*
	* @return the current slave synchronization mode
	*
	* @see #setSlaveSyncMode(Sequencer.SyncMode)
	* @see #getSlaveSyncModes
	*/
	public SyncMode getSlaveSyncMode();


	/**
	* Obtains the set of slave synchronization modes supported by the sequencer.
	*
	* @return the available slave synchronization modes
	*
	* @see SyncMode#MIDI_SYNC
	* @see SyncMode#MIDI_TIME_CODE
	* @see SyncMode#NO_SYNC
	*/
	public SyncMode[] getSlaveSyncModes();


	/**
	* Sets the mute state for a track. This method may fail for a number
	* of reasons. For example, the track number specified may not be valid
	* for the current sequence, or the sequencer may not support this functionality.
	* An application which needs to verify whether this operation succeeded should
	* follow this call with a call to <code>{@link #getTrackMute}</code>.
	*
	* @param track the track number. Tracks in the current sequence are numbered
	* from 0 to the number of tracks in the sequence minus 1.
	* @param mute the new mute state for the track. <code>true</code> implies the
	* track should be muted, <code>false</code> implies the track should be unmuted.
	* @see #getSequence
	*/
	public void setTrackMute(int track, boolean mute);


	/**
	* Obtains the current mute state for a track. The default mute
	* state for all tracks which have not been muted is false. In any
	* case where the specified track has not been muted, this method should
	* return false. This applies if the sequencer does not support muting
	* of tracks, and if the specified track index is not valid.
	*
	* @param track the track number. Tracks in the current sequence are numbered
	* from 0 to the number of tracks in the sequence minus 1.
	* @return <code>true</code> if muted, <code>false</code> if not.
	*/
	public boolean getTrackMute(int track);

	/**
	* Sets the solo state for a track. If <code>solo</code> is <code>true</code>
	* only this track and other solo'd tracks will sound. If <code>solo</code>
	* is <code>false</code> then only other solo'd tracks will sound, unless no
	* tracks are solo'd in which case all un-muted tracks will sound.
	* <p>
	* This method may fail for a number
	* of reasons. For example, the track number specified may not be valid
	* for the current sequence, or the sequencer may not support this functionality.
	* An application which needs to verify whether this operation succeeded should
	* follow this call with a call to <code>{@link #getTrackSolo}</code>.
	*
	* @param track the track number. Tracks in the current sequence are numbered
	* from 0 to the number of tracks in the sequence minus 1.
	* @param solo the new solo state for the track. <code>true</code> implies the
	* track should be solo'd, <code>false</code> implies the track should not be solo'd.
	* @see #getSequence
	*/
	public void setTrackSolo(int track, boolean solo);


	/**
	* Obtains the current solo state for a track. The default mute
	* state for all tracks which have not been solo'd is false. In any
	* case where the specified track has not been solo'd, this method should
	* return false. This applies if the sequencer does not support soloing
	* of tracks, and if the specified track index is not valid.
	*
	* @param track the track number. Tracks in the current sequence are numbered
	* from 0 to the number of tracks in the sequence minus 1.
	* @return <code>true</code> if solo'd, <code>false</code> if not.
	*/
	public boolean getTrackSolo(int track);


	/**
	* Registers a meta-event listener to receive
	* notification whenever a meta-event is encountered in the sequence
	* and processed by the sequencer. This method can fail if, for
	* instance,this class of sequencer does not support meta-event
	* notification.
	*
	* @param listener listener to add
	* @return <code>true</code> if the listener was successfully added,
	* otherwise <code>false</code>
	*
	* @see #removeMetaEventListener
	* @see MetaEventListener
	* @see MetaMessage
	*/
	public boolean addMetaEventListener(MetaEventListener listener);


	/**
	* Removes the specified meta-event listener from this sequencer's
	* list of registered listeners, if in fact the listener is registered.
	*
	* @param listener the meta-event listener to remove
	* @see #addMetaEventListener
	*/
	public void removeMetaEventListener(MetaEventListener listener);


	/**
	* Registers a controller event listener to receive notification
	* whenever the sequencer processes a control-change event of the
	* requested type or types. The types are specified by the
	* <code>controllers</code> argument, which should contain an array of
	* MIDI controller numbers. (Each number should be between 0 and 127,
	* inclusive. See the MIDI 1.0 Specification for the numbers that
	* correspond to various types of controllers.)
	* <p>
	* The returned array contains the MIDI controller
	* numbers for which the listener will now receive events.
	* Some sequencers might not support controller event notification, in
	* which case the array has a length of 0. Other sequencers might
	* support notification for some controllers but not all.
	* This method may be invoked repeatedly.
	* Each time, the returned array indicates all the controllers
	* that the listener will be notified about, not only the controllers
	* requested in that particular invocation.
	*
	* @param listener the controller event listener to add to the list of
	* registered listeners
	* @param controllers the MIDI controller numbers for which change
	* notification is requested
	* @return the numbers of all the MIDI controllers whose changes will
	* now be reported to the specified listener
	*
	* @see #removeControllerEventListener
	* @see ControllerEventListener
	*/
	public int[] addControllerEventListener(ControllerEventListener listener, int[] controllers);


	/**
	* Removes a controller event listener's interest in one or more
	* types of controller event. The <code>controllers</code> argument
	* is an array of MIDI numbers corresponding to the controllers for
	* which the listener should no longer receive change notifications.
	* To completely remove this listener from the list of registered
	* listeners, pass in <code>null</code> for <code>controllers</code>.
	* The returned array contains the MIDI controller
	* numbers for which the listener will now receive events. The
	* array has a length of 0 if the listener will not receive
	* change notifications for any controllers.
	*
	* @param listener old listener
	* @param controllers the MIDI controller numbers for which change
	* notification should be cancelled, or <code>null</code> to cancel
	* for all controllers
	* @return the numbers of all the MIDI controllers whose changes will
	* now be reported to the specified listener
	*
	* @see #addControllerEventListener
	*/
	public int[] removeControllerEventListener(ControllerEventListener listener, int[] controllers);


	/**
	* Sets the first MIDI tick that will be
	* played in the loop. If the loop count is
	* greater than 0, playback will jump to this
	* point when reaching the loop end point.
	*
	* <p>A value of 0 for the starting point means the
	* beginning of the loaded sequence. The starting
	* point must be lower than or equal to the ending
	* point, and it must fall within the size of the
	* loaded sequence.
	*
	* <p>A sequencer's loop start point defaults to
	* start of the sequence.
	*
	* @param tick the loop's starting position,
	* in MIDI ticks (zero-based)
	* @throws IllegalArgumentException if the requested
	* loop start point cannot be set, usually because
	* it falls outside the sequence's
	* duration or because the start point is
	* after the end point
	*
	* @see #setLoopEndPoint
	* @see #setLoopCount
	* @see #getLoopStartPoint
	* @see #start
	* @since 1.5
	*/
	public void setLoopStartPoint(long tick);


	/**
	* Obtains the start position of the loop,
	* in MIDI ticks.
	*
	* @return the start position of the loop,
	in MIDI ticks (zero-based)
	* @see #setLoopStartPoint
	* @since 1.5
	*/
	public long getLoopStartPoint();


	/**
	* Sets the last MIDI tick that will be played in
	* the loop. If the loop count is 0, the loop end
	* point has no effect and playback continues to
	* play when reaching the loop end point.
	*
	* <p>A value of -1 for the ending point
	* indicates the last tick of the sequence.
	* Otherwise, the ending point must be greater
	* than or equal to the starting point, and it must
	* fall within the size of the loaded sequence.
	*
	* <p>A sequencer's loop end point defaults to -1,
	* meaning the end of the sequence.
	*
	* @param tick the loop's ending position,
	* in MIDI ticks (zero-based), or
	* -1 to indicate the final tick
	* @throws IllegalArgumentException if the requested
	* loop point cannot be set, usually because
	* it falls outside the sequence's
	* duration or because the ending point is
	* before the starting point
	*
	* @see #setLoopStartPoint
	* @see #setLoopCount
	* @see #getLoopEndPoint
	* @see #start
	* @since 1.5
	*/
	public void setLoopEndPoint(long tick);


	/**
	* Obtains the end position of the loop,
	* in MIDI ticks.
	*
	* @return the end position of the loop, in MIDI
	* ticks (zero-based), or -1 to indicate
	* the end of the sequence
	* @see #setLoopEndPoint
	* @since 1.5
	*/
	public long getLoopEndPoint();


	/**
	* Sets the number of repetitions of the loop for
	* playback.
	* When the playback position reaches the loop end point,
	* it will loop back to the loop start point
	* <code>count</code> times, after which playback will
	* continue to play to the end of the sequence.
	* <p>
	* If the current position when this method is invoked
	* is greater than the loop end point, playback
	* continues to the end of the sequence without looping,
	* unless the loop end point is changed subsequently.
	* <p>
	* A <code>count</code> value of 0 disables looping:
	* playback will continue at the loop end point, and it
	* will not loop back to the loop start point.
	* This is a sequencer's default.
	*
	* <p>If playback is stopped during looping, the
	* current loop status is cleared; subsequent start
	* requests are not affected by an interrupted loop
	* operation.
	*
	* @param count the number of times playback should
	* loop back from the loop's end position
	* to the loop's start position, or
	* <code>{@link #LOOP_CONTINUOUSLY}</code>
	* to indicate that looping should
	* continue until interrupted
	*
	* @throws IllegalArgumentException if <code>count</code> is
	* negative and not equal to {@link #LOOP_CONTINUOUSLY}
	*
	* @see #setLoopStartPoint
	* @see #setLoopEndPoint
	* @see #getLoopCount
	* @see #start
	* @since 1.5
	*/
	public void setLoopCount(int count);


	/**
	* Obtains the number of repetitions for
	* playback.
	*
	* @return the number of loops after which
	* playback plays to the end of the
	* sequence
	* @see #setLoopCount
	* @see #start
	* @since 1.5
	*/
	public int getLoopCount();

	/**
	* A <code>SyncMode</code> object represents one of the ways in which
	* a MIDI sequencer's notion of time can be synchronized with a master
	* or slave device.
	* If the sequencer is being synchronized to a master, the
	* sequencer revises its current time in response to messages from
	* the master. If the sequencer has a slave, the sequencer
	* similarly sends messages to control the slave's timing.
	* <p>
	* There are three predefined modes that specify possible masters
	* for a sequencer: <code>INTERNAL_CLOCK</code>,
	* <code>MIDI_SYNC</code>, and <code>MIDI_TIME_CODE</code>. The
	* latter two work if the sequencer receives MIDI messages from
	* another device. In these two modes, the sequencer's time gets reset
	* based on system real-time timing clock messages or MIDI time code
	* (MTC) messages, respectively. These two modes can also be used
	* as slave modes, in which case the sequencer sends the corresponding
	* types of MIDI messages to its receiver (whether or not the sequencer
	* is also receiving them from a master). A fourth mode,
	* <code>NO_SYNC</code>, is used to indicate that the sequencer should
	* not control its receiver's timing.
	*
	* @see Sequencer#setMasterSyncMode(Sequencer.SyncMode)
	* @see Sequencer#setSlaveSyncMode(Sequencer.SyncMode)
	*/
	public static class SyncMode {

	/**
	* Synchronization mode name.
	*/
	private String name;

	/**
	* Constructs a synchronization mode.
	* @param name name of the synchronization mode
	*/
	protected SyncMode(String name) {

	this.name = name;
	}


	/**
	* Determines whether two objects are equal.
	* Returns <code>true</code> if the objects are identical
	* @param obj the reference object with which to compare
	* @return <code>true</code> if this object is the same as the
	* <code>obj</code> argument, <code>false</code> otherwise
	*/
	public final boolean equals(Object obj) {

	return super.equals(obj);
	}


	/**
	* Finalizes the hashcode method.
	*/
	public final int hashCode() {

	return super.hashCode();
	}


	/**
	* Provides this synchronization mode's name as the string
	* representation of the mode.
	* @return the name of this synchronization mode
	*/
	public final String toString() {

	return name;
	}


	/**
	* A master synchronization mode that makes the sequencer get
	* its timing information from its internal clock. This is not
	* a legal slave sync mode.
	*/
	public static final SyncMode INTERNAL_CLOCK = new SyncMode("Internal Clock");


	/**
	* A master or slave synchronization mode that specifies the
	* use of MIDI clock
	* messages. If this mode is used as the master sync mode,
	* the sequencer gets its timing information from system real-time
	* MIDI clock messages. This mode only applies as the master sync
	* mode for sequencers that are also MIDI receivers. If this is the
	* slave sync mode, the sequencer sends system real-time MIDI clock
	* messages to its receiver. MIDI clock messages are sent at a rate
	* of 24 per quarter note.
	*/
	public static final SyncMode MIDI_SYNC = new SyncMode("MIDI Sync");


	/**
	* A master or slave synchronization mode that specifies the
	* use of MIDI Time Code.
	* If this mode is used as the master sync mode,
	* the sequencer gets its timing information from MIDI Time Code
	* messages. This mode only applies as the master sync
	* mode to sequencers that are also MIDI receivers. If this
	* mode is used as the
	* slave sync mode, the sequencer sends MIDI Time Code
	* messages to its receiver. (See the MIDI 1.0 Detailed
	* Specification for a description of MIDI Time Code.)
	*/
	public static final SyncMode MIDI_TIME_CODE = new SyncMode("MIDI Time Code");


	/**
	* A slave synchronization mode indicating that no timing information
	* should be sent to the receiver. This is not a legal master sync
	* mode.
	*/
	public static final SyncMode NO_SYNC = new SyncMode("No Timing");

	} // class SyncMode
	}

Back to index...