view src/uk/ac/qmul/eecs/depic/daw/gui/AutomationGraphActions.java @ 0:3074a84ef81e

first import

/*  
 Cross-Modal DAW Prototype - Prototype of a simple Cross-Modal Digital Audio Workstation.

 Copyright (C) 2015  Queen Mary University of London (http://depic.eecs.qmul.ac.uk/)
	
 This program 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 3 of the License, or
 (at your option) any later version.

 This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*/
package uk.ac.qmul.eecs.depic.daw.gui;

import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.geom.Point2D;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.prefs.Preferences;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JComponent;
import javax.swing.JOptionPane;
import javax.swing.KeyStroke;

import uk.ac.qmul.eecs.depic.daw.Automation;
import uk.ac.qmul.eecs.depic.daw.AutomationValue;
import uk.ac.qmul.eecs.depic.daw.Daw;
import uk.ac.qmul.eecs.depic.daw.Sonification;
import uk.ac.qmul.eecs.depic.daw.SoundType;
import uk.ac.qmul.eecs.depic.daw.SoundWave;
import uk.ac.qmul.eecs.depic.daw.beads.sonification.BeadsSonification;
import uk.ac.qmul.eecs.depic.patterns.Range;
import uk.ac.qmul.eecs.depic.patterns.Sequence;

/**
 * 
 * Actions for the manipulation of the automation graph. 
 * 
 *
 */
class AutomationGraphActions implements Iterable<Action> {
	private static AutomationGraphActions singleton; 
	private SequencePoint heldPoint;
	
	public final AddAutomationValueAction addAutomationValueAction;
	public final RemoveAutomationValueAction removeAutomationValueAction;
	public final MoveAutomationValueAction moveAutomationValueUpAction;
	public final MoveAutomationValueAction moveAutomationValueLeftAction;
	public final MoveAutomationValueAction moveAutomationValueDownAction;
	public final MoveAutomationValueAction moveAutomationValueRightAction;
	public final ResetAutomationValuesAction resetAutomationAction;
	public final ListenWholeAutomationAction listenWholeAutomationAction;
	public final StopListenWholeAutomationAction stopListenWholeAutomationAction;
	public final SwitchListenAutomationAction switchListenAutomationAction;
	public final SwitchListenPeakLevelAction switchListenPeakLevelAction;
	public final ListenWholePeakLevelAction listenWholePeakLevelAction;
	
	private Sonification sonification;

	static AutomationGraphActions getInstance(){
		if(singleton == null)
			singleton = new AutomationGraphActions();
		return singleton;
	}
	
	private AutomationGraphActions (){ 
		addAutomationValueAction = new AddAutomationValueAction();
		removeAutomationValueAction = new RemoveAutomationValueAction();
		moveAutomationValueUpAction = new MoveAutomationValueAction(KeyStroke.getKeyStroke("ctrl UP"),0.0f,0.05f);
		moveAutomationValueDownAction = new MoveAutomationValueAction(KeyStroke.getKeyStroke("ctrl DOWN"),0.0f,-0.05f);
		moveAutomationValueLeftAction = new MoveAutomationValueAction(KeyStroke.getKeyStroke("ctrl LEFT"),-50.0f,0.0f);
		moveAutomationValueRightAction = new MoveAutomationValueAction(KeyStroke.getKeyStroke("ctrl RIGHT"),50.0f,0.0f);
		resetAutomationAction = new ResetAutomationValuesAction();
		listenWholeAutomationAction = new ListenWholeAutomationAction();
		stopListenWholeAutomationAction = new StopListenWholeAutomationAction();
		switchListenAutomationAction = new SwitchListenAutomationAction();
		switchListenPeakLevelAction = new SwitchListenPeakLevelAction();
		listenWholePeakLevelAction = new ListenWholePeakLevelAction();
		
		sonification = Daw.getSoundEngineFactory().getSharedSonification();
	}
	
	/**
	 * Create a new Actions than plays the automation value sound when it is at zero point, 
	 * that is in the middle of the automation range  
	 * 
	 * @param val
	 * @return
	 */
	private static Action createZeroValAction(final Sequence.Value val){
		return new AbstractAction() {
			private static final long serialVersionUID = 1L;
			private boolean doneOnce = false;
			@Override
			public void actionPerformed(ActionEvent evt){
				/* only play feedback once. This action remains until a new action 
				 * for the same keystroke is installed. A new action is installed 
				 * when the user presses ctrl + up/down/left/right arrow (see MoveAutomation 
				 * Feedback as to be given only once by each zeroAction, otherwise 
				 * the sonification will be played each time the user releases a ctrl + 
				 * arrow action, regardless of whether they actually moved an automation or nor */
				if(doneOnce){
					return;
				}else{
					doneOnce = true;
				}
				Daw.getSoundEngineFactory().getSharedSonification().getSequenceMapping(SoundType.AUTOMATION).renderValue(
					new Sequence.Value() {
						@Override
						public int index() {
							return val.index();
						}
						
						@Override
						public float getValue() {
							Range<Float> range = val.getSequence().getRange();
							return range.getStart() + range.lenght()/2;
						}
						
						@Override
						public float getTimePosition() {
							return val.getTimePosition();
						}
						
						@Override
						public Sequence getSequence() {
							return val.getSequence();
						}
					});
			}
		};
	}

	@Override
	public Iterator<Action> iterator(){
		return new Iterator<Action>(){
			private int index = 0;
			private Action [] actions = new Action [] {
					addAutomationValueAction,
					removeAutomationValueAction,
					moveAutomationValueUpAction,
					moveAutomationValueLeftAction,
					moveAutomationValueDownAction,
					moveAutomationValueRightAction,
					resetAutomationAction,
					listenWholeAutomationAction,
					stopListenWholeAutomationAction,
					switchListenAutomationAction,
					switchListenPeakLevelAction,
					listenWholePeakLevelAction
			};
			
			@Override
			public boolean hasNext() {
				return index < actions.length;
			}

			@Override
			public Action next() {
				if(index == actions.length)
					throw new NoSuchElementException();
				return actions[index++];
			}

			@Override
			public void remove() {
				throw new UnsupportedOperationException("remove not supported");
			}
			
		};
	}
	
	static abstract class AutomationGraphAction extends AbstractAction {
		private static final long serialVersionUID = 1L;
		
		AutomationGraphAction(KeyStroke keyStroke){
			putValue(Action.ACCELERATOR_KEY,keyStroke);
		}
		
		@Override 
		public void actionPerformed(ActionEvent evt){
			handleActionPerformed((AudioTrack)evt.getSource());
		}
		
		public abstract void handleActionPerformed(AudioTrack track);
			
	}
	
	class AddAutomationValueAction extends AutomationGraphAction {
		private static final long serialVersionUID = 1L;
		
		public AddAutomationValueAction() {
			super(KeyStroke.getKeyStroke("ctrl INSERT"));
		}

		@Override
		public void handleActionPerformed(AudioTrack track) {
			if(track == null || !track.getSoundWave().hasSequence()) {
				return;
			}
			
			SoundWave wave = track.getSoundWave();
			int cursorPos = wave.getCurrentChunkPosition();
			
			Point2D.Float p = AudioTrack.getAutomationCoord(track, cursorPos, track.getHeight()/2);
			
			/* if user is trying to create an automation outside the bounds of the automation, notify the error */
			if(p == null){
				sonification.play(SoundType.ERROR);
				return;
			}
			
			/* if a new point is created when moving another point the held point will still be the old one        * 
			 * by setting it to null the hel point will become the new one as soon as the user will try to move it */
			heldPoint = null;
			sonification.getSequenceMapping(SoundType.AUTOMATION).renderValue(
					wave.getParametersControl().getCurrentAutomation().add(p.x, p.y));
		}
	} // class AddAutomationAction
	
	class MoveAutomationValueAction extends AutomationGraphAction {
		private static final long serialVersionUID = 1L;
		private float deltaX;
		private float deltaY;
		
		public MoveAutomationValueAction(KeyStroke keyStroke, float deltaX, float deltaY){
			super(keyStroke);
			this.deltaX = deltaX;
			this.deltaY = deltaY;
			heldPoint = null;
		}
		
		@Override
		public void handleActionPerformed(final AudioTrack track) {
			if(track == null || !track.getSoundWave().hasSequence()){
				heldPoint = null;
				return;
			}
			
			int cursorPos = track.getSoundWave().getCurrentChunkPosition();
			
			/* if ctrl is held (heldPoint != null) it means the user is still moving around a  * 
			 * point that they grabbed previously. So the check that the point be under the    *
			 * cursor must not be done, and the point can be moved and played anyway           */
			if(heldPoint != null){
				changeAutomation((AutomationValue)heldPoint.getSequenceValue(),track);
				return;
			}
			
			/* find the automaton value under the cursor position if any */
			for(SequencePoint itr : track.getAutomationGraph().getSequencePoints()){
				if( itr.isXCentredAt(cursorPos) ){
					/* p is now the heldPoint, until the user releaser the ctrl key this point will be referenced * 
					 * in next move action even if it's not under the the cursor is not under the cursor anymore  */
					heldPoint = itr;
					/* set up an action that will stop scrubbing free the held point when the user releases the ctrl key */
					track.getInputMap(JComponent.WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_CONTROL, 0 , true), "heldPoint");
					track.getActionMap().put("heldPoint", new AbstractAction(){
						private static final long serialVersionUID = 1L;
						@Override
						public void actionPerformed(ActionEvent evt) {
								heldPoint = null;
								/* stop scrubbing */
								track.getSoundWave().scan(SoundWave.STOP_SCANNING);
								/* de-register itself from the track registered actions */
								track.getInputMap(JComponent.WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_CONTROL, 0 , true), "none");
								track.getActionMap().remove("heldPoint");
						}
					});
					
					changeAutomation((AutomationValue)itr.getSequenceValue(),track);
					break;
				}
			}
		}
		
		protected void changeAutomation(AutomationValue val, AudioTrack track){
			val.setLocation(val.getTimePosition()+deltaX, val.getValue()+deltaY);
			
			/* install the action that plays the zero value when the key is released */
			KeyStroke thisActionKeyStroke = (KeyStroke)getValue(Action.ACCELERATOR_KEY);
			KeyStroke zeroValKeyStroke = KeyStroke.getKeyStroke(thisActionKeyStroke.getKeyCode(),thisActionKeyStroke.getModifiers(),true);
			
			if(Preferences.userNodeForPackage(BeadsSonification.class).getBoolean("render_val.ref", false)){
				track.getInputMap(JComponent.WHEN_FOCUSED).put(zeroValKeyStroke, "zeroVal");
				track.getActionMap().put("zeroVal", createZeroValAction(val));
			}
			
			/* besides moving the automation, scrub the cursor along */
			int scanTo = (int)(val.getTimePosition() / track.getSoundWave().getMillisecPerChunk());
			track.getSoundWave().scan(scanTo);
			sonification.getSequenceMapping(SoundType.AUTOMATION).renderValue(heldPoint.getSequenceValue());
		}
	} // class MoveAutomationValueAction

	class RemoveAutomationValueAction extends AutomationGraphAction {
		private static final long serialVersionUID = 1L;

		public RemoveAutomationValueAction() {
			super(KeyStroke.getKeyStroke("ctrl DELETE"));
		}

		@Override
		public void handleActionPerformed(AudioTrack track) {
			if(track == null || !track.getSoundWave().hasSequence()){
				return;
			}
			
			int cursorPos = track.getSoundWave().getCurrentChunkPosition();
			
			/* find the automaton value */
			SequencePoint p = null;
			for(SequencePoint itr : track.getAutomationGraph().getSequencePoints()){
				float dist = Math.abs(cursorPos - (int)itr.getCenterX() );
				
				if( dist  <  SequencePoint.SIZE ){
					if(p == null || dist < Math.abs((int)p.getCenterX() - (int)itr.getCenterX())){
						p = itr;
						/* don't break as it keeps looking for other points, which might be closer to the cursor */
					}
				}
			}
			
			/* if found, then remove it and play it */
			if(p != null){
				((Automation)p.getSequenceValue().getSequence()).remove((AutomationValue)p.getSequenceValue());
				sonification.getSequenceMapping(SoundType.AUTOMATION).renderValue(p.getSequenceValue());
			}
		}		
		
	} // class RemoveAutomationAction
	
	class ResetAutomationValuesAction extends AutomationGraphAction {
		private static final long serialVersionUID = 1L;

		public ResetAutomationValuesAction() {
			super(KeyStroke.getKeyStroke("ctrl R "));
		}

		@Override
		public void handleActionPerformed(AudioTrack track){
			if(track == null || !track.getSoundWave().hasSequence()){ 
				return;
			}
			
			int confirmation = JOptionPane.showConfirmDialog(track, 
					"Are you sure you want to reset the automation ?", // FIXME bundle 
					"Confirmation Dialog",
					JOptionPane.YES_NO_OPTION
					);
			
			if(confirmation == JOptionPane.YES_OPTION){
				track.getSoundWave().getParametersControl().getCurrentAutomation().reset();
			}			
		}
	} // class ClearAutomationValuesAction 
	
	class ListenWholeAutomationAction extends AutomationGraphAction {
		private static final long serialVersionUID = 1L;

		public ListenWholeAutomationAction() {
			super(KeyStroke.getKeyStroke("ctrl shift L"));
		}

		@Override
		public void handleActionPerformed(AudioTrack track){
			if(track == null || (!track.getSoundWave().hasSequence()) ){ 
				sonification.play(SoundType.ERROR);
				return;
			}
			
			track.getSoundWave().getTransportControl().rew();
			sonification.getSequenceMapping(SoundType.AUTOMATION).renderCurve(
					track.getSoundWave().getParametersControl().getCurrentAutomation(),0.0f);			
			track.getSoundWave().getTransportControl().play();
		}
	} // class SonifyAutomationAction
	
	class StopListenWholeAutomationAction extends AutomationGraphAction {
		private static final long serialVersionUID = 1L;
		
		public StopListenWholeAutomationAction(){
			super(KeyStroke.getKeyStroke("ctrl K"));
		}
		
		@Override
		public void handleActionPerformed(AudioTrack track){
			sonification.getSequenceMapping(SoundType.AUTOMATION).renderCurve(
					null,-100.0f);
			sonification.getSequenceMapping(SoundType.PEAK_LEVEL).renderCurve(
					null,-100.0f);
			track.soundWave.getTransportControl().stop(); 
		}
	}
	
	class SwitchListenAutomationAction extends AutomationGraphAction {
		private static final long serialVersionUID = 1L;
		private boolean isOn;
		
		public SwitchListenAutomationAction(){
			super(KeyStroke.getKeyStroke("ctrl L"));
			isOn = false;
		}
		
		@Override
		public void handleActionPerformed(AudioTrack track){
			if(track.getSoundWave().hasSequence()){
				isOn = !isOn;
				
				track.showAutomationSound(isOn);
				sonification.play(SoundType.OK);
			}else{
				sonification.play(SoundType.ERROR);
			}
		}
		
		public boolean isSwitchOn(){
			return isOn;
		}
	} // class SwitchListenAutomation
	
	class SwitchListenPeakLevelAction extends AutomationGraphAction {
		private static final long serialVersionUID = 1L;
		private boolean isOn;
		
		SwitchListenPeakLevelAction(){
			super(KeyStroke.getKeyStroke("ctrl P"));
			isOn = false;
		}
		
		@Override
		public void handleActionPerformed(AudioTrack track){
			if( track == null || (!track.getSoundWave().getDbWave().hasSequence())){
				Daw.getSoundEngineFactory().getSharedSonification().play(SoundType.ERROR);
				return;
			}
			isOn = !isOn;
					
			track.showPeakLevelSound(isOn);
			Daw.getSoundEngineFactory().getSharedSonification().play(SoundType.OK);
		}
		
		public boolean isSwitchOn(){
			return isOn;
		}
	} // SwitchListenPeakLevelAction
	
	class ListenWholePeakLevelAction extends AutomationGraphAction {
		private static final long serialVersionUID = 1L;
		
		ListenWholePeakLevelAction(){
			super(KeyStroke.getKeyStroke("ctrl shift P"));
		}
		
		@Override
		public void handleActionPerformed(AudioTrack track){
			if(track == null || (!track.getSoundWave().getDbWave().hasSequence()) ){ 
				sonification.play(SoundType.ERROR);
				return;
			}
			
			track.getSoundWave().getTransportControl().rew();
			sonification.getSequenceMapping(SoundType.PEAK_LEVEL).renderCurve(
					track.getSoundWave().getDbWave().getSequence(),0.0f);			
			track.getSoundWave().getTransportControl().play();
		}
	}
	
}