tsequencer.java

linux下建立JAVA虚拟机的源码KAFFE

		synchronized (m_aControllerListeners)
		{
			if (anControllers == null)
			{
				/*
				 *	Add to all controllers. NOTE: this
				 *	is an implementation-specific
				 *	semantic!
				 */
				for (int i = 0; i < 128; i++)
				{
					addControllerListener(i, listener);
				}
			}
			else
			{
				for (int i = 0; i < anControllers.length; i++)
				{
					addControllerListener(anControllers[i], listener);
				}
			}
		}
		return getListenedControllers(listener);
	}



	private void addControllerListener(int i,
					   ControllerEventListener listener)
	{
		if (m_aControllerListeners[i] == null)
		{
			m_aControllerListeners[i] = new ArraySet();
		}
		m_aControllerListeners[i].add(listener);
	}



	public int[] removeControllerEventListener(ControllerEventListener listener, int[] anControllers)
	{
		synchronized (m_aControllerListeners)
		{
			if (anControllers == null)
			{
				/*
				 *	Remove from all controllers. Unlike
				 *	above, this is specified semantics.
				 */
				for (int i = 0; i < 128; i++)
				{
					removeControllerListener(i, listener);
				}
			}
			else
			{
				for (int i = 0; i < anControllers.length; i++)
				{
					removeControllerListener(anControllers[i], listener);
				}
			}
		}
		return getListenedControllers(listener);
	}



	private void removeControllerListener(int i,
					      ControllerEventListener listener)
	{
		if (m_aControllerListeners[i] != null)
		{
			m_aControllerListeners[i].add(listener);
		}
	}



	private int[] getListenedControllers(ControllerEventListener listener)
	{
		int[]	anControllers = new int[128];
		int	nIndex = 0;	// points to the next position to use.
		for (int nController = 0; nController < 128; nController++)
		{
			if (m_aControllerListeners[nController] != null &&
			    m_aControllerListeners[nController].contains(listener))
			{
				anControllers[nIndex] = nController;
				nIndex++;
			}
		}
		int[]	anResultControllers = new int[nIndex];
		System.arraycopy(anControllers, 0, anResultControllers, 0, nIndex);
		return anResultControllers;
	}



	protected void sendControllerEvent(ShortMessage message)
	{
		// TDebug.out("TSequencer.sendControllerEvent(): called");
		int	nController = message.getData1();
		if (m_aControllerListeners[nController] != null)
		{
			Iterator	iterator = m_aControllerListeners[nController].iterator();
			while (iterator.hasNext())
			{
				ControllerEventListener	controllerEventListener = (ControllerEventListener) iterator.next();
				ShortMessage	copiedMessage = (ShortMessage) message.clone();
				controllerEventListener.controlChange(copiedMessage);
			}
		}
	}



	protected void notifyListeners(MidiMessage message)
	{
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.sendToListeners(): begin"); }
		if (message instanceof MetaMessage)
		{
			// IDEA: use extra thread for event delivery
			sendMetaMessage((MetaMessage) message);
		}
		else if (message instanceof ShortMessage && ((ShortMessage) message).getCommand() == ShortMessage.CONTROL_CHANGE)
		{
			sendControllerEvent((ShortMessage) message);
		}
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.sendToListeners(): end"); }
	}



	public SyncMode getMasterSyncMode()
	{
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.getMasterSyncMode(): begin"); }
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.getMasterSyncMode(): end"); }
		return m_masterSyncMode;
	}



	public void setMasterSyncMode(SyncMode syncMode)
	{
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.setMasterSyncMode(): begin"); }
		if (m_masterSyncModes.contains(syncMode))
		{
			if (! getMasterSyncMode().equals(syncMode))
			{
				m_masterSyncMode = syncMode;
				setMasterSyncModeImpl(syncMode);
			}
		}
		else
		{
			throw new IllegalArgumentException("sync mode not allowed: " + syncMode);
		}
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.setMasterSyncMode(): end"); }
	}


	/*
	  This method is guaranteed only to be called if the sync mode really changes.
	 */
	protected void setMasterSyncModeImpl(SyncMode syncMode)
	{
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.setMasterSyncModeImpl(): begin"); }
		// DO NOTHING
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.setMasterSyncModeImpl(): end"); }
	}



	public SyncMode[] getMasterSyncModes()
	{
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.getMasterSyncModes(): begin"); }
		SyncMode[]	syncModes = (SyncMode[]) m_masterSyncModes.toArray(EMPTY_SYNCMODE_ARRAY);
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.getMasterSyncModes(): end"); }
		return syncModes;
	}



	public SyncMode getSlaveSyncMode()
	{
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.getSlaveSyncMode(): begin"); }
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.getSlaveSyncMode(): end"); }
		return m_slaveSyncMode;
	}



	public void setSlaveSyncMode(SyncMode syncMode)
	{
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.setSlaveSyncMode(): begin"); }
		if (m_slaveSyncModes.contains(syncMode))
		{
			if (! getSlaveSyncMode().equals(syncMode))
			{
				m_slaveSyncMode = syncMode;
				setSlaveSyncModeImpl(syncMode);
			}
		}
		else
		{
			throw new IllegalArgumentException("sync mode not allowed: " + syncMode);
		}
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.setSlaveSyncMode(): end"); }
	}



	/*
	  This method is guaranteed only to be called if the sync mode really changes.
	 */
	protected void setSlaveSyncModeImpl(SyncMode syncMode)
	{
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.setSlaveSyncModeImpl(): begin"); }
		// DO NOTHING
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.setSlaveSyncModeImpl(): end"); }
	}



	public SyncMode[] getSlaveSyncModes()
	{
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.getSlaveSyncModes(): begin"); }
		SyncMode[]	syncModes = (SyncMode[]) m_slaveSyncModes.toArray(EMPTY_SYNCMODE_ARRAY);
		if (TDebug.TraceSequencer) { TDebug.out("TSequencer.getSlaveSyncModes(): end"); }
		return syncModes;
	}



	public boolean getTrackSolo(int nTrack)
	{
		boolean	bSoloed = false;
		if (getSequence() != null)
		{
			if (nTrack < getSequence().getTracks().length)
			{
				bSoloed = m_soloBitSet.get(nTrack);
			}
		}
		return bSoloed;
	}



	public void setTrackSolo(int nTrack, boolean bSolo)
	{
		if (getSequence() != null)
		{
			if (nTrack < getSequence().getTracks().length)
			{
				boolean	bOldState = m_soloBitSet.get(nTrack);
				if (bSolo != bOldState)
				{
					if (bSolo)
					{
						m_soloBitSet.set(nTrack);
					}
					else
					{
						m_soloBitSet.clear(nTrack);
					}
					updateEnabled();
					setTrackSoloImpl(nTrack, bSolo);
				}
			}
		}
	}



	protected void setTrackSoloImpl(int nTrack, boolean bSolo)
	{
	}



	public boolean getTrackMute(int nTrack)
	{
		boolean	bMuted = false;
		if (getSequence() != null)
		{
			if (nTrack < getSequence().getTracks().length)
			{
				bMuted = m_muteBitSet.get(nTrack);
			}
		}
		return bMuted;
	}



	public void setTrackMute(int nTrack, boolean bMute)
	{
		if (getSequence() != null)
		{
			if (nTrack < getSequence().getTracks().length)
			{
				boolean	bOldState = m_muteBitSet.get(nTrack);
				if (bMute != bOldState)
				{
					if (bMute)
					{
						m_muteBitSet.set(nTrack);
					}
					else
					{
						m_muteBitSet.clear(nTrack);
					}
					updateEnabled();
					setTrackMuteImpl(nTrack, bMute);
				}
			}
		}
	}


	protected void setTrackMuteImpl(int nTrack, boolean bMute)
	{
	}



	private void updateEnabled()
	{
		BitSet	oldEnabledBitSet = (BitSet) m_enabledBitSet.clone();
		boolean	bSoloExists = m_soloBitSet.length() > 0;
		if (bSoloExists)
		{
			m_enabledBitSet = (BitSet) m_soloBitSet.clone();
		}
		else
		{
			for (int i = 0; i < m_muteBitSet.size(); i++)
			{
				if (m_muteBitSet.get(i))
				{
					m_enabledBitSet.clear(i);
				}
				else
				{
					m_enabledBitSet.set(i);
				}
			}
		}
		oldEnabledBitSet.xor(m_enabledBitSet);
		/*	oldEnabledBitSet now has a bit set if the status for
			this bit changed.
		*/
		for (int i = 0; i < oldEnabledBitSet.size(); i++)
		{
			if (oldEnabledBitSet.get(i))
			{
				setTrackEnabledImpl(i, m_enabledBitSet.get(i));
			}
		}
	}



	/**	Shows that a track state has changed.
		This method is called for each track where the enabled
		state (calculated from mute and solo) has changed.
		The boolean value passed represents the new state.

		@param nTrack The track number for which the enabled status
		has changed.

		@param bEnabled The new enabled state for this track.
	 */
	protected void setTrackEnabledImpl(int nTrack, boolean bEnabled)
	{
	}



	protected boolean isTrackEnabled(int nTrack)
	{
		return m_enabledBitSet.get(nTrack);
	}



	/** Sets the preloading intervall.
		This is the time span between preloading events to an internal
		queue and playing them. This intervall should be kept constant
		by the implementation. However, this cannot be guaranteed.
	*/
	public void setLatency(int nMilliseconds)
	{
	}



	/** Get the preloading intervall.

	@return the preloading intervall in milliseconds, or -1 if the sequencer
	doesn't repond to changes in the <code>Sequence</code> at all.
	*/
	public int getLatency()
	{
		return -1;
	}
}



/*** TSequencer.java ***/