public void actionPerformed(ActionEvent e) {
			boolean insert=e.getSource().equals("Insert");
			if ("V".equals(inputMode)) {
				if (insert) {
					insertInInputStr(exprGetHelper.getInput());
				} else {setInputStr(exprGetHelper.getInput());}
			} else if ("TvyI".indexOf(inputMode)>-1) {
				if (!insert) {
					String exprString=exprGetHelper.getInput();
					if (inputStr.indexOf(" ")>-1) {
						int start=inputStr.lastIndexOf(" ", cursorPos-1);
						//if (start==-1) {start=0;}
						int end=inputStr.indexOf(" ", cursorPos);
						if (end==-1) {end=inputStr.length();}
						inputStr = inputStr.substring(0,start+1)
									+exprString+
									inputStr.substring(end); 
					} else {
						setInputStr(exprString);
					}
				} else {
					insertInInputStr(exprGetHelper.getInput());
				}
			} else if ("i".equals(inputMode)) {
				setInputStr(exprSetHelper.getInput());
			} else {
				if (insert) {
					insertInInputStr(exprGetHelper.getInput());
				} else {setInputStr(exprGetHelper.getInput());}
			}
		} 
	}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//MouseWheel ActionListener
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	private class InputHelpWheel implements MouseWheelListener{
	
		public void mouseWheelMoved(MouseWheelEvent e) {
			Object boundedObj = getTimeLineDrawObject(false);
			TimeLineDraw timeLineDraw = (boundedObj instanceof TimeLineDraw)?((TimeLineDraw)boundedObj):null;
			if (inputBarDraw.inside(mouseX,mouseY)) {
				Object o=inputBarDraw.checkForObjectOnScreen(mouseX,mouseY);
				if (!inputMode.equals("") && o!=null && o.equals("inputField")) {
					NumberScrollingUtil.NumberCursorData ncd  = numberScrollingUtil.getNumberNearCursor( inputStr, cursorPos ); 
					if ( ncd!=null ) {						
						inputStr = numberScrollingUtil.getNextNumber( e, ncd,inputStr, cursorPos );
					} else {
						if (e.getWheelRotation() > 0) 	{ keyCode = DOWN; keyPressed();	}
						if (e.getWheelRotation() <= 0) 	{ keyCode = UP; keyPressed();	}
					}
				}
			}else if (popupWindowDraw.isVisible() && popupWindowDraw.inside(mouseX,mouseY)) {
				popupWindowDraw.setScroll(e.getWheelRotation() > 0);
//			} else if (slidersDraw.inside(mouseX,mouseY)) {
//				slidersDraw.updateSliderWheel(mouseX,mouseY,ctrl,shift,e.getWheelRotation() );
//				if ("v".equals(inputMode)) {
//					Event copyEv=getLastEvent().getCopy(null);
//					slidersDraw.setBackValues(copyEv.getValue());
//					inputStr=copyEv.getValueStr();
//					cursorPos=inputStr.length();
//					if (alt) {	   oscUtil.simpleOscMessage(copyEv);   }
//				} else if ("w".equals(inputMode)) {
//					inputStr=""+slidersDraw.getSliderValue(0);
//					if (alt) {	   timeLineObject.pitch=slidersDraw.getSliderValue(0);  }
//				}
			}	else if (timeLineDraw!=null) {
				Object o = timeLineDraw.checkForObjectOnScreen(mouseX,mouseY);
				if (o instanceof String) {
					String stringObject=(String) o;
					int lgth=timeLineObject.displayEnd-timeLineObject.displayStart;
					int move=(int) Math.round((lgth)*0.1);
					int end=Math.round((lgth)*2);
					Vector selection =null;
					TimeLineObject lastTimeLineObject = timeLineObject;
					boolean lastScrollPosToView=lastTimeLineObject.scrollPosToView;
					if (ctrl) {
						selection=timeLineSelection;
					} else {selection=new Vector();selection.add(timeLineObject);}
					for (int i=0;i<selection.size();i++) {
						timeLineObject = (TimeLineObject) selection.get(i);
						if (stringObject.toLowerCase().equals("scroll") && (e.getWheelRotation() > 0)) {scrollLeft(move);} // works for scroll bar or scroll button
						else if (stringObject.toLowerCase().equals("scroll") && (e.getWheelRotation() <= 0)) {scrollRight(move);}
						else if (stringObject.equals("Zoom") && (e.getWheelRotation() < 0)) {zoomIn();}
						else if (stringObject.equals("Zoom") && (e.getWheelRotation() >= 0)) {zoomOut();}	
						else if (stringObject.equals("Height") && (e.getWheelRotation() < 0)) {adjustHeight(-5);}
						else if (stringObject.equals("Height") && (e.getWheelRotation() >= 0)) {adjustHeight(5);}	
						else if (stringObject.equals("ScrollPosToView") ) {timeLineObject.scrollPosToView=!lastScrollPosToView;}	
					}
					timeLineObject = lastTimeLineObject;
				}
			} 
		}
	}
	
//	public String getNextNumber(MouseWheelEvent e, NumberCursorData ncd,String inputStr2) {
//		int dirFactor=1;
//		if (e.getWheelRotation() > 0) 	{ dirFactor=-1;}
//		String newValue="";
//		int oldLength = ncd.stringVal.length();
//		if (ncd.value instanceof Float) {
//			int indexOfDot = ncd.stringVal.indexOf(".");
//			float digitsMultiplier = indexOfDot<ncd.posInNumber?
//													(indexOfDot - ncd.posInNumber+1) :
//														 indexOfDot -( ncd.posInNumber );//oldLength-
//			float newValueFloat = ncd.value.floatValue() + (dirFactor * (float) Math.pow(10f, digitsMultiplier-1));
//			//newValueFloat = (new BigDecimal(newValueFloat)).setScale(oldLength-indexOfDot).floatValue();
//			newValue=""+newValueFloat;
//			int oldLenComp = ncd.value.floatValue()>0?oldLength:oldLength-1;
//			while (newValue.length()< oldLenComp) {
//				newValue+="0";
//			}
//			if (newValue.length()>oldLength) {		cursorPos++;	}
//		} else {
//			int digitsMultiplier = oldLength - ncd.posInNumber;
//			int newValueInt = ncd.value.intValue() + (dirFactor * (int) Math.pow(10f, digitsMultiplier-1));
//			newValue=""+newValueInt;
//			if (newValue.length()>oldLength) {		cursorPos++;	}
//		}	
//		return inputStr2.substring( 0, ncd.start ) + newValue +((ncd.end<inputStr2.length())? inputStr2.substring( ncd.end, inputStr2.length() ):"");
//	}
/////////////////////////////////// ///////////////////////////////// ///////////////////////////////// ///////////////////////////////// 
//// get the number next to the cursor for use with mouse wheel
/////////////////////////////////////////////////////////////////// ///////////////////////////////// ///////////////////////////////// 
//	private class NumberCursorData{
//		public int posInNumber = 0;
//		public Number value = null ;	
//		public String stringVal = null ;	
//		public int start = 0;
//		public int end = 0;
//	}
//	
//	private NumberCursorData getNumberNearCursor(String inputStr) {
//		char beforeChar = cursorPos>0?inputStr.charAt(cursorPos-1):(char)-1;
//		char afterChar = cursorPos<inputStr.length()?inputStr.charAt(cursorPos):(char)-1;
//		if (Character.isDigit(beforeChar)||Character.isDigit(afterChar)) {
//			NumberCursorData ncd = new NumberCursorData();
//			// move left from cursor to get stat of number 
//			int start = cursorPos;
//			for (;start>-1 ;start--) {
//				if ("1234567890.-".indexOf(inputStr.charAt(start))==-1) {start ++;	break;	}
//			}
//			if (start==-1) {start=0;}
//			//	move right of cursor to get the end of the number.
//			int end = cursorPos;
//			for (; end<inputStr.length() ;end++) {
//				if ("1234567890.-".indexOf(inputStr.charAt(end))==-1) { break; }
//			}
//			if (start>=end) {return null;} 
//			String numStr = inputStr.substring(start, end);
//			
//			try  {
//				if (numStr.indexOf(".")>-1) {
//					ncd.value = new Float(numStr);
//				} else {
//					ncd.value = new Integer( numStr);
//				}
//			} catch (NumberFormatException n) {
//				return null;
//			}
//			ncd.posInNumber = cursorPos-start;
//			ncd.stringVal  = numStr;
//			ncd.start = start;
//			ncd.end = end;
//			return ncd;
//		}
//		return null;
//	}
	// adjust the height of the timeline.
	private void adjustHeight(int increment) {
		if ((timeLineObject.setHeight>60) && increment<=0) {
			timeLineObject.setHeight+=increment;
		} else if ((timeLineObject.setHeight<200)&& increment>0) {
			timeLineObject.setHeight+=increment;
		}
	}
	// zoom in (with wheel)
	private void zoomIn() {
		int lgth=timeLineObject.displayEnd-timeLineObject.displayStart;
		timeLineObject.displayEnd=timeLineObject.displayStart+Math.round((lgth)/2);
	}
	//	zoom out (with wheel)
	private void zoomOut() {
		int lgth=timeLineObject.displayEnd-timeLineObject.displayStart;
		timeLineObject.displayStart-=(lgth/2);
		timeLineObject.displayEnd+=(lgth/2);
		if (timeLineObject.displayStart<0) {
			timeLineObject.displayStart = 0;
		} 
		if (timeLineObject.displayEnd >= timeLineObject.timeLineLength) {
			timeLineObject.displayEnd = timeLineObject.timeLineLength;
		}
	}
	// scroll Left
	private void scrollLeft( int move) {
		int lgth=timeLineObject.displayEnd-timeLineObject.displayStart;
		if( timeLineObject.displayStart-move<=0 ){
			timeLineObject.displayStart=0;
			timeLineObject.displayEnd=lgth;
		} else {
			timeLineObject.displayStart-=move;
			timeLineObject.displayEnd-=move; 
		}
	}
	// scroll Right
	private void scrollRight(int move) {
		int lgth=timeLineObject.displayEnd-timeLineObject.displayStart;
		if((timeLineObject.displayEnd+move)>=timeLineObject.timeLineLength){ 
			timeLineObject.displayStart=timeLineObject.timeLineLength-lgth;
			timeLineObject.displayEnd=timeLineObject.timeLineLength;
		}
		else {
			timeLineObject.displayStart+=move;
			timeLineObject.displayEnd+=move;
		}
	} 
//	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	  window resize: event listeners
//	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	public class WindowResizeHandler extends ComponentAdapter {
		public void componentResized(ComponentEvent e) {
			//set width here - get height from tlBounds.
			screenWidth = thisFrame.getWidth();
			screenHeight = tlBound.getTotalHeight() + BORDER_HEIGHT;
			tlBound.setWidth( screenWidth -BORDER_WIDTH);//
			thisFrame.setSize( screenWidth, screenHeight );
		}
		
		@Override
		public void componentMoved(ComponentEvent e) {
			//testing window move problems w. compiz.
			//super.componentMoved(e);
			Point location=((Component)e.getSource()).getLocation();
			//System.out.println(location.toString()+":"+thisFrame.getX()+":"+thisFrame.getY()+":"+thisFrame.getParent());
			thisFrame.setLocation( location );
		}
	}
	
	public class BoundsChangeHandler implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			updateTimeLineDisplays();
		}
	}
	
	public void updateTimeLineDisplays() {
		timeLineDisplays.clear();
		tlBound.clearBoundedObjects();
		tlBound.addBoundedObject(topBarDraw);
		tlBound.addBoundedObject(inputBarDraw);
		tlBound.addBoundedObject(buttonsDraw);
		int ystart = 60;// start height
		int theTop=0;
		for (int i=0;i<timeLineSelection.size();i++) {
			TimeLineObject tlo = (TimeLineObject) timeLineSelection.get(i);
			TimeLineDraw tld  =  new TimeLineDraw(screenWidth, tlo.dispHeight, 0, ystart+theTop, tlo);
			timeLineDisplays.add(tld);
			tlBound.addBoundedObject(tld);
			theTop+=tlo.dispHeight;
		}
		thisFrame.setSize(screenWidth, tlBound.getTotalHeight()+BORDER_HEIGHT);
	}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	interface functions: moves selected events
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	loads interface file
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	
	public void loadInterface(String fileName) {
		this.interfaceFile = fileName;
		interfaceBuilder.reset();
		interfaceReader.openFile(this.interfaceFile, interfaceBuilder);
		interfaceBuilder.setVisible(true);
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	moveEvents: moves selected events
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	void moveEvents(Vector events, int interval) {
		for (int i=0;i<events.size();i++) {
			Event event=(Event)events.get(i);
			event.eventTime+=interval;
			if (!alt) {event.eventTime=(event.eventTime/timeLineObject.quantize)*timeLineObject.quantize;}//quantise.
		}
	}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	MIDI Stuff: initialisation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	public void noteOn(Note note){
		midiUtil.noteOn( note);
	}
	
	public  void closeMidi() {
		midiUtil.closeMidi();
	}
	
	public void noteOff(Note note){
		midiUtil.noteOff( note);
	}
	
	public void controllerIn(Controller controller){
		midiUtil.controllerIn(controller);
	}
	public void programChange ( ProgramChange programChange){// doesnt seem to work
		showMessage("progch:"+programChange.getNumber()+":"+programChange.getMidiPort()+":"+programChange.getMidiChannel());
	}
	
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	OSC Stuff: initialisation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  void initOsc() {
  	oscUtil.initOsc();
  }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	OSC Stuff: unpackMessage(OscIn oscIn): unpcak osc msg recievd and make event if recording.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  public void oscEvent(OscIn oscIn) {
	  unpackMessage( oscIn,0);
  }
  void unpackMessage(OscIn oscIn,int server) {  
	oscUtil.unpackMessage( oscIn, server);
  }
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	OSC Stuff: simpleOscMessage(Event e, int index) - sends osc message (event e ) on specified OSC Port(array index) - used by midi stuff.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  public void simpleOscMessage(Event e, int index) {
//	//oscUtil.simpleOscMessage( e,  index);
//	  oscUtil.simpleOscMessage( e);
//  }
	
	


//////////////////RecompLstnr ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	/**
	 * this allows the dynCompiler to access this dynamicObjects map and reload any classes theat are needed.
	 * @author robm
	 *
	 */
	private class RecompLstnr implements RecompilationListener {
		public void recompiledEvent(DynCompilerObjectBean o) {
			
		}
		public void reLoadedEvent(){
			//dynamicObjects.put("std",new Standard());
			// rm 11/11/07 dont think i neeed this ... removingo
			// addStandardObjects();
		}
		public HashMap getDynamicObjects() {
			return dynamicObjects;
		}
	}
	
	public void addStandardObjects() {
		Iterator i = stdObjectClasses.keySet().iterator();
		while (i.hasNext()) {
			String key=(String) i.next();
			Class c= (Class) stdObjectClasses.get(key);
			try {
				dynamicObjects.put(key, c.newInstance());
			} catch (InstantiationException e) {
				showMessage("could not create:"+key+"("+c.getName()+") - "+e.getMessage(), LogWindow.TYPE_ERROR);
			} catch (IllegalAccessException e) {
				showMessage("could not create:"+key+"("+c.getName()+") - "+e.getMessage(), LogWindow.TYPE_ERROR);
			}
		}
	}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	logging stuff.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	public void addLogEntry(String str) {
		logVector.add(str);
		if (logVector.size()>10) {	writeLog();	}
	}
	FileWriter fw=null;
	public void initLog() {
		//RM_FP:
		try {
			fw=new FileWriter(new File(configDirectoryPath+"log.log"),false);
		} catch (Exception e) {
			System.out.println("open:"+e.getMessage()	);
		}
	}
	
	public void writeLog() {
		try {
			for (Iterator logVectorIter = logVector.iterator(); logVectorIter.hasNext();) {
				String s = (String) logVectorIter.next();
				fw.write(s+"\n");
				fw.flush();
			}
		} catch (Exception e) {
			System.out.println(":"+e.getMessage()	);
		}
		logVector.clear();
	}
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	  various click handlers
//  the button has an activate part and a name part ( | a |  name   |
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	  timeline  click handler
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	public void timeLineButClickHndlr(TimeLineObject selTimeLine) {
		if (selTimeLine!=null) {
			propHelper.setObject(selTimeLine, "timeline");
			int[] point = buttonsDraw.getBoundObjectInsideCoord(selTimeLine,mouseX,mouseY);
			if (point[0] > 35){ 
				cueTimeLineObject = selTimeLine;
			} else if (!"".equals(inputMode)  && (mouseButton==RIGHT) && (point[0]>12)){// if in inputmode and right click on name.
				if ( "e".indexOf(inputMode)>-1) {
					inputStr=selTimeLine.id;
					cursorPos=inputStr.length();
				} else  {
					// insert timeline expr.
					String expr="$t:"+selTimeLine.id+":";
					insertInInputStr(expr);
				}
			} 
			else if (point[0] > 12){ // if click on name.
				// create event to trigger right +ctrl clicked timeline
				 if (ctrl && mouseButton==RIGHT) {
					 if (selTimeLine!=timeLineObject && timeLineObject!=null ) {
						Event e = new Event();
						e.target=selTimeLine;
						e.targetPlayMode=shift?"l":"p";
						e.setValue("0") ;
						e.eventTime=0;
						e.oscIndex=timeLineObject.oscIndex;
						e.oscP5=oscServers[e.oscIndex];
						timeLineObject.timeLine.add(e);
						timeLineObject.rebuildTimeLine();
					 }
					return;
				}
				//set the visible timeline.
				if (shift && timeLineSet !=null) {
					if (timeLineSet.getSet().contains(selTimeLine)) {
						timeLineSet.getSet().remove(selTimeLine);
					} else {
						timeLineSet.getSet().add(selTimeLine);
					}
				} else {
					timeLineSet=null;
				}
				
				if (!ctrl) {
					if (timeLineSelection.contains(selTimeLine) &&timeLineSelection.size()>0 && timeLineObject==selTimeLine) {
						timeLineSelection.remove(selTimeLine);
					} else if (!timeLineSelection.contains(selTimeLine)) {timeLineSelection.add(selTimeLine);}
				} else {
					timeLineSelection.clear();
					timeLineSelection.add(selTimeLine);
				}
				this.timeLineIndex=timeLines.indexOf(selTimeLine);
				timeLineObject=selTimeLine;
				updateTimeLineDisplays();
			} else { // if click on activation part.
				//play/loop the cilcked timeline   this event is used just to send data
/* logic here is :-
 *
 * if (timeline playing) {stop timeline}
 * if (timeline is cued) {decue it}
 * if (ctrl || none playing ) {
 * 			dont que - play now
 *  		if (!shift) { stop others}
 * }
 * if (other timeline in group playing) {cue timeline &decue others cued  }
 */
				String playMode="p";
				if (mouseButton==RIGHT) {	playMode="l";	}
				if (!"".equals(selTimeLine.playMode)) {playMode="";} 

				Vector group = getTimeLineGroup(selTimeLine.id, true);
				Vector grpPlaying = checkOthersPlaying(selTimeLine.id);
				
				if (!"".equals(selTimeLine.playMode)) {
					selTimeLine.playMode="";return;
				}
				if (cue.checkQued(selTimeLine) ) {
					cue.deCueEveryWhere(selTimeLine);return;
				}
				if (ctrl || (grpPlaying.size()==0)) {
					if (!shift) {
						for (int j=0; j<group.size(); j++) {
							Cueable to = (Cueable)group.get(j);//TimeLineObject
							if (to!=selTimeLine && to instanceof TimeLineObject) {
								TimeLineObject t = (TimeLineObject) to;
								t.playMode = "";
							}
						}
					}
					playTimeline(selTimeLine, playMode);
					return;
				}
				if ( (grpPlaying.size()>0)) {//grpPlaying.contains(selTimeLine)
					// decue others
					for (Iterator i = group.iterator();i.hasNext()  ; ) {
						Cueable groupObject=(Cueable) i.next();
						cue.deCueEveryWhere(groupObject);
					}
					// encue timeline	
					for (Iterator i = grpPlaying.iterator();i.hasNext()  ; ) {
						TimeLineObject trig=(TimeLineObject) i.next();
						cue.addToCue(trig, selTimeLine, playMode, true, true);
					}
				}
			} 
		}
	}
	
	public boolean checkSameGroup(String to1, String  to2) {
		String test1=to1.split("-")[0];
		String test2=to2.split("-")[0];
		return test1.equals(test2);
	}
	public Vector getTimeLineGroup(String id, boolean getSets) {
		String base=id;
		if (base.indexOf("-")>-1) {base = base.substring(0,base.indexOf("-")+1);}
		else {return new Vector();}
		Vector returnVec = new Vector();
		for (int i=0;i<timeLines.size();i++) {
			TimeLineObject to=(TimeLineObject)timeLines.get(i);
			if (to.id.indexOf(base)==0 ){
				returnVec.add(to);
			}
		}
		if (getSets) {
			for (int i=0;i<timeLineSets.size();i++) {
				TimeLineSet ts=(TimeLineSet)timeLineSets.get(i);
				if (ts.getId().indexOf(base)==0 ){
					returnVec.add(ts);
				}
			}
		}
		return returnVec;
	}
	private String getNextName(String id) {
		if ( id.indexOf("-")>-1) {	id=id.substring(0, id.indexOf("-"));	}
		int cnt=0;
		int highIndex=0;
		for (int i=0;i<timeLines.size();i++) {
			TimeLineObject t=(TimeLineObject)timeLines.get(i);
			if (t.id.indexOf(id+"-")==0) {
				try {highIndex=Math.max(highIndex, Integer.parseInt(t.id.substring(t.id.indexOf("-")+1)));}catch(NumberFormatException n ){}
				cnt++;
			}
		}
		for (int i=0;i<timeLineSets.size();i++) {
			TimeLineSet t=(TimeLineSet)timeLineSets.get(i);
			if (t.getId().indexOf(id+"-")==0) {
				try {highIndex=Math.max(highIndex, Integer.parseInt(t.getId().substring(t.getId().indexOf("-")+1)));}catch(NumberFormatException n ){}
				cnt++;
			}
		}
		String newTimeLineId=id+"-"+(++highIndex);
		return newTimeLineId;
	}
	public Vector checkOthersPlaying(String id) {
		Vector returnVec = getTimeLineGroup(id, false);
		for (int i=0;i<returnVec.size();i++) {
			TimeLineObject to=(TimeLineObject)returnVec.get(i);
			if ("".equals(to.playMode)){
				returnVec.remove(to);
				i--;
			}
		}
		return returnVec;
	}

//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	  timeline set click handler
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	private void timeLineSetButClickHandler(TimeLineSet set) {
		propHelper.setObject(set, "timelineSet");
		int[] point = buttonsDraw.getBoundObjectInsideCoord(set, mouseX, mouseY);
		if (point[0]>12){
			if ((mouseButton==RIGHT) && (!"".equals(inputMode))) {
				setInputStr(set.getId());
			}else {
				if (timeLineSet==null) {
					timeLineSelection.clear();
					timeLineSelection.addAll(set.getSet());
					timeLineSet = set;
					updateTimeLineDisplays();
				} else {
					timeLineSet=null;
				}
			}
		} else if (point[0]<=12) {
/* logic here is :-
 *
 * if (set is cued) {decue it}
 * if (ctrl || none playing ) {
 * 			dont que - play now
 *  		if (!shift) { stop others}
 * }
 * if (other timeline in group playing) {cue timeline & decue others cued  }
 */
			//play/loop the cilcked timeline   this event is used just to send data
			String playMode="p";
			if (mouseButton==RIGHT) {	playMode="l";	}
			
			Vector group = getTimeLineGroup(set.getId(), true);
			Vector grpPlaying = checkOthersPlaying(set.getId());
			
			if (cue.checkQued(set) ) {
				cue.deCueEveryWhere(set);return;
			}
			if (ctrl || (grpPlaying.size()==0)) {
				if (!shift) {
					for (int j=0; j<group.size(); j++) {
						Cueable to = (Cueable)group.get(j);//TimeLineObject
						if ( to instanceof TimeLineObject) {
							TimeLineObject t = (TimeLineObject) to;
							t.playMode = "";
						}
					}
				}
				playTimeLines( set.getSet(), playMode );
				return;
			}
			if ( (grpPlaying.size()>0)) {//grpPlaying.contains(selTimeLine)
				// decue others
				for (Iterator i = group.iterator();i.hasNext()  ; ) {
					Cueable groupObject=(Cueable) i.next();
					cue.deCueEveryWhere(groupObject);
				}
				// encue timeline	
				for (Iterator i = grpPlaying.iterator();i.hasNext()  ; ) {
					TimeLineObject trig=(TimeLineObject) i.next();
					cue.addToCue(trig, set, playMode, true, true);
				}
			}
		}
	}
	
	public void enCueHandler(Cueable tgt) {
		if (cueTimeLineObject!=null && tgt!=null) {
			if (cue.checkQued(cueTimeLineObject, tgt)) {
				cue.deCue(cueTimeLineObject, tgt);
			} else if (cueTimeLineObject != tgt)  {
				cue.addToCue(cueTimeLineObject, tgt, (mouseButton==LEFT?"p":"l"),false, 
										checkSameGroup(tgt.getId(),cueTimeLineObject.getId()) || shift  //  stop if shift or in the same group
								);
			}
			cueTimeLineObject = null;
		}
	}
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	  event click handler
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	public void eventClickHndlr(Event e) {
		if (e!=null) {
			propHelper.setObject(e, "event");
			if (!"".equals(inputMode)  && (mouseButton==RIGHT)) {
				String expr="$e:"+timeLineObject.id+":"+("".equals(e.id)?""+timeLineObject.timeLine.indexOf(e):e.id)+":";
				insertInInputStr(expr);
			} else if (mouseButton==CENTER) {
				playEvent(e);
			} else {
				int index=timeLineObject.timeLine.indexOf(e);
				timeLineObject.currentEvent=index;
				timeLineObject.lastSelEvent=index;
				dragObject=e;
			}
		}
	}
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	  group click handler
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	public void groupClickHandler(String groupObjStr) {
		Object boundedObj = getTimeLineDrawObject(false);
		TimeLineDraw timeLineDraw = (boundedObj instanceof TimeLineDraw)?((TimeLineDraw)boundedObj):null;
		if (timeLineDraw==null) return;
		int[] point = timeLineDraw.getBoundObjectInsideCoord(groupObjStr,mouseX,mouseY);
		String groupName=groupObjStr.substring(2);
		if ("g".equals(inputMode) && (mouseButton==RIGHT)) {
			//inputStr=groupName;cursorPos=inputStr.length();
			insertInInputStr(groupName);
		}else if (!"".equals(inputMode)  && (mouseButton==RIGHT)) {
			String expr="$g:"+timeLineObject.id+":"+groupName+":";
			insertInInputStr(expr);
		} else if  (mouseButton==LEFT){
			Vector group=(Vector)timeLineObject.groups.get(groupName);
			if ("selection".equals(groupName)) {group=timeLineObject.selection;}
			boolean activeState=false;
			boolean selectState=false;
			if ("selection".equals(groupName) && (point[0]>12)) {timeLineObject.selection.clear();return;}
			for (int i=0;i<group.size();i++) {
				Event e=(Event)group.get(i);
				if (i==0) { activeState=e.active;selectState=timeLineObject.selection.contains(e); }
				if (point[0]<12) {	e.active=!activeState;}
				else {
					if (!selectState) {
						if (!timeLineObject.selection.contains(e)) {timeLineObject.selection.add(e);}
					} else {
						timeLineObject.selection.remove(e);
					}
				}
			}
		}
	}
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	  filter resloution.
//	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	public void playFilter(OscMessage oscMsg) {
		Vector v=(Vector)filters.get(oscMsg.getMsgName());
		for (int i=0;v!=null && i<v.size();i++){
			FilterBean fb=(FilterBean)v.get(i);
			if (fb.isActive()) {
				exprUtil.setValueExpr(fb.getExpr(), new Vector(oscMsg.getArgs()));
			}
		}
	}
	
	private void toggleActivateFilter(String filterSpec) {
		String filterSplit[] = filterSpec.split(" ");
		Vector v=(Vector)filters.get(filterSplit[0]);
		if (v!=null ){
			for (int i=0;i<v.size();i++){
				FilterBean fb=(FilterBean)v.get(i);
				if (fb.getExpr().equals(filterSplit[1])){
					fb.setActive(!fb.isActive());
				}
			}
		}