public InputState Clone(){
			InputState inputStateNew = new InputState (this.name, this.hash);

			if(this.combinations[0]!=null)
			inputStateNew.combinations [0] = this.combinations [0].Clone ();

			if(this.combinations [1]!=null)
			inputStateNew.combinations [1] = this.combinations [1].Clone ();
			return inputStateNew;
		}
				///////////////////////////             OnGUI                ////////////////////////
				/// <summary>
				/// Raises the GU event.
				/// </summary>
				void OnGUI ()
				{

				
						int numLayers;
						int numStates;
						int i = 0;
						int j = 0;		
						UnityEditor.Animations.AnimatorStateMachine stateMachine;
						UnityEditor.Animations.AnimatorState state;
						UnityEditor.Animations.AnimatorControllerLayer layer;
						UnityEditor.Animations.AnimatorController ac;


						if (_deleteStateWithHash != 0) {
								_stateInputCombinations.Remove (_deleteStateWithHash);
								_deleteStateWithHash = 0;
						}
					

		
						if (_spaceDesignator != null) {

								EditorGUILayout.LabelField ("Settings");
								EditorGUILayout.Separator ();

								////// MAX NUM COMBOS  ///// 
								maxCombosNum = EditorGUILayout.IntField ("Combos per input:", maxCombosNum, _settingsStyle);

								EditorGUILayout.Separator ();

								////// DESIGNATORS /////
								EditorGUILayout.LabelField ("Click Designators");

								///////// DOUBLE ////////////
								_doubleClickDesignator = EditorGUILayout.TextField ("Double click designator", _doubleClickDesignator, _settingsStyle);
								InputManager.Settings.doubleDesignator = _doubleClickDesignator.Length > 0 ? _doubleClickDesignator : _prevlongClickDesignator;
						
						

								if (_prevdoubleClickDesignator != null && _doubleClickDesignator.Length > 0 && _prevdoubleClickDesignator != _doubleClickDesignator) {
										replaceDesignator (_prevdoubleClickDesignator, _doubleClickDesignator);
								}
								_prevdoubleClickDesignator = _doubleClickDesignator;

								//////////////  LONG //////////
								_longClickDesignator = EditorGUILayout.TextField ("Long click designator", _longClickDesignator, _settingsStyle);

								InputManager.Settings.longDesignator = _longClickDesignator.Length > 0 ? _longClickDesignator : _prevlongClickDesignator;
						
								if (_prevlongClickDesignator != null && _longClickDesignator.Length > 0 && _prevlongClickDesignator != _longClickDesignator) {
										replaceDesignator (_prevlongClickDesignator, _longClickDesignator);
								}
								_prevlongClickDesignator = _longClickDesignator;

								///////////// SPACE /////////////
								_spaceDesignator = EditorGUILayout.TextField ("Combination separator", _spaceDesignator, _settingsStyle);
								if (_spaceDesignator.Length > 1)
										_spaceDesignator = _spaceDesignator [0].ToString ();//restrict to 1 char

								InputManager.Settings.spaceDesignator = _spaceDesignator.Length > 0 ? _spaceDesignator : _prevSpaceDesinator.ToString ();
			
								if (_spaceDesignator.Length > 0 && _prevSpaceDesinator != _spaceDesignator [0]) {
										replaceDesignator (_prevSpaceDesinator.ToString (), _spaceDesignator [0].ToString ());
								}

								_prevSpaceDesinator = _spaceDesignator [0];
						
				
								EditorGUILayout.Separator ();

								/////  SENSITIVITY  ////
								EditorGUILayout.LabelField ("Sensitivity");
								InputManager.Settings.singleClickSensitivity = _singleClickSensitivity = EditorGUILayout.FloatField ("Single click sensitivity", _singleClickSensitivity, _settingsStyle);
								InputManager.Settings.doubleClickSensitivity = _doubleClickSensitivity = EditorGUILayout.FloatField ("Double click sensitivity", _doubleClickSensitivity, _settingsStyle);
								InputManager.Settings.longClickSensitivity = _longClickSensitivity = EditorGUILayout.FloatField ("Long click sensitivity", _longClickSensitivity, _settingsStyle);
								InputManager.Settings.combinationsClickSensitivity = _combosClickSensitivity = EditorGUILayout.FloatField ("Combos click sensitivity", _combosClickSensitivity, _settingsStyle);
								EditorGUILayout.Separator ();


								//////////// PLAYERS //////////////
								EditorGUILayout.BeginHorizontal ();


								InputPlayer player = null;
								_playerNumber = EditorGUILayout.IntField ("Number of Players", _playerNumber);

								if (_playerNumber < 1)
										_playerNumber = 1;
								
							
								//create Players
								if (settings.Players == null || _playerNumber != settings.Players.Length) {
										
										
										InputPlayer[] players = new InputPlayer[_playerNumber];

										for (i=0; i<_playerNumber; i++) {
												
												

												//don't delete previous players just add new
												if (settings.Players != null && settings.Players.Length > i)
														players [i] = settings.Players [i];
												else
														players [i] = new InputPlayer ();
										}


										settings.Players = players;

										//set last player as current
										_playerIndexSelected = _playerNumber - 1;

										//reset profile to default
										_profileSelectedIndex = 0;

										
								}

								//create player display options
								if (_playerDisplayOptions == null || _playerNumber != _playerDisplayOptions.Length) {
										_playerDisplayOptions = new string [_playerNumber];
										for (i=0; i<_playerNumber; i++) {
												_playerDisplayOptions [i] = "Player" + i;
										}

								}




								_playerIndexSelected = EditorGUILayout.Popup (_playerIndexSelected, _playerDisplayOptions);
					

								if (_playerNumber > 1 && GUILayout.Button ("Clone To All")) {


										if (EditorUtility.DisplayDialog ("Clone to All!",
                                                "Are you sure to clone selected player overwriting other player's settings?", "Yes", "Cancel")) {
												InputPlayer sample = settings.Players [_playerIndexSelected];

												for (i = 0; i < _playerNumber; i++) {
														if (i != _playerIndexSelected)
																settings.Players [i] = sample.Clone ();
												}
										}
								}


								EditorGUILayout.EndHorizontal ();




								//////////// Profiles /////////////
				 
								EditorGUILayout.BeginHorizontal ();

								EditorGUILayout.LabelField ("Profiles");

								
								List<IDevice> devices = InputManager.GetDevices<IDevice> ();

								if (devices.Count > 0) {

										List<string> pList = devices.Where (item => item.profile != null).Select (item => item.profile.Name).Distinct ().ToList ();
										pList.Insert (0, "default");

										_profilesDevicesDisplayOptions = pList.ToArray ();

								} else {
										_profileSelectedIndex = 0;
										_profilesDevicesDisplayOptions = new string[] { "default" };
								}


				
				
				
				
				
				
								_profileSelectedIndex = EditorGUILayout.Popup (_profileSelectedIndex, _profilesDevicesDisplayOptions);


								//by selecting profile we are setting Device type expectation
								_deviceByProfile = devices.Where (item => item.profile != null).FirstOrDefault (item => item.profile.Name == _profilesDevicesDisplayOptions [_profileSelectedIndex]);

				
				
								player = settings.Players [_playerIndexSelected];

								Dictionary<int,InputState> stateInputsCurrent = null;

								//init stateInput Dictionary if player numbers is increased
								if (_profilesDevicesDisplayOptions.Length > _profileSelectedIndex) {
										if (!player.DeviceProfileStateInputs.ContainsKey (_profilesDevicesDisplayOptions [_profileSelectedIndex])) {
												player.DeviceProfileStateInputs [_profilesDevicesDisplayOptions [_profileSelectedIndex]] = new Dictionary<int, InputState> ();
										}


										stateInputsCurrent = player.DeviceProfileStateInputs [_profilesDevicesDisplayOptions [_profileSelectedIndex]];
								} else {
										_profileSelectedIndex = 0;
										stateInputsCurrent = player.DeviceProfileStateInputs ["default"];


								}


								if (_profileSelectedIndex > 0) {
										if (GUILayout.Button ("Clone default")
												&& EditorUtility.DisplayDialog ("Clone Default!",
                                                "Are you sure to clone Default input settings to " + _profilesDevicesDisplayOptions [_profileSelectedIndex] + " device specific settings?", "Yes", "Cancel")
                
                                            ) {

												Dictionary<int,InputState> stateInputsDefault = player.DeviceProfileStateInputs ["default"];
												foreach (var HashInputStatePair in stateInputsDefault) {
														if (!stateInputsCurrent.ContainsKey (HashInputStatePair.Key))
																stateInputsCurrent.Add (HashInputStatePair.Key, HashInputStatePair.Value.Clone ());
											
												}



										}




						
					

								}


								_stateInputCombinations = stateInputsCurrent;



								EditorGUILayout.EndHorizontal ();
								EditorGUILayout.Separator ();



								

								//////////  ANY/Complex Action Types(doubles,long...)  /FULL AXIS Checkers ///////
								EditorGUILayout.BeginHorizontal ();
								//	_isDeviceAny = GUILayout.Toggle (_isDeviceAny, "Any(Uncheck 4Testing Only");
								_isComplexActionTypesAllowed = GUILayout.Toggle (_isComplexActionTypesAllowed, "Allow DOUBLE/LONG(HOLD)");
								_isDeviceAxisPositionFull = GUILayout.Toggle (_isDeviceAxisPositionFull, "Full Axis");
								EditorGUILayout.EndHorizontal ();

								EditorGUILayout.Separator ();


								


						}
				

						/////////////// GENERATING ENUM SETTINGS  ///////////
						_enumSettingsFoldout = EditorGUILayout.Foldout (_enumSettingsFoldout, "States Enum Properties");

						if (_enumSettingsFoldout) {
								EditorGUILayout.BeginVertical ();

								//settingsXML = EditorGUILayout.ObjectField (settingsXML, typeof(TextAsset), true) as TextAsset;
								_namespace = EditorGUILayout.TextField ("Namespace:", _namespace);
								_enumName = EditorGUILayout.TextField ("Enum:", _enumName);
								_enumFileName = EditorGUILayout.TextField ("File name:", _enumFileName);
								EditorGUILayout.EndVertical ();
						}

						EditorGUILayout.Separator ();

						/////////////////   XML  ////////////////////
						EditorGUILayout.LabelField ("Input XML/BIN");
						EditorGUILayout.BeginHorizontal ();
						settingsFile = EditorGUILayout.ObjectField (settingsFile, typeof(UnityEngine.Object), true);

						//reload if xml changed
						if (_lastSettingsFile != settingsFile) {
								_settingsLoaded = false;

							
						}

						_lastSettingsFile = settingsFile;


						if (_selectedStateHash == 0 && GUILayout.Button ("Open")) {
								string path; 

								if (_isBinary)
										path = EditorUtility.OpenFilePanel ("Open XML Input Settings file", "", "bin");
								else
										path = EditorUtility.OpenFilePanel ("Open XML Input Settings file", "", "xml");

								if (path.Length > 0) {
										

										loadAsset (path);
				
										
								}


								return;
						}


						///////////////   SAVE ////////////////////
					
						if (_selectedStateHash == 0 && GUILayout.Button ("Save")) {

								EditorGUIUtility.keyboardControl = 0;
								_selectedStateHash = 0;


								if (!Directory.Exists (Application.streamingAssetsPath)) {
										Directory.CreateDirectory (Application.streamingAssetsPath);
								}

								if (settingsFile != null) {
										string path = AssetDatabase.GetAssetPath (settingsFile);

										if (Path.GetExtension (path) == ".xml") {
												saveInputSettings (Path.Combine (Application.streamingAssetsPath, settingsFile.name + ".xml"));
										} else {
												saveInputSettings (Path.Combine (Application.streamingAssetsPath, settingsFile.name + ".bin"));
										}
								} else { 
										

										if (_isBinary)
												saveInputSettings (EditorUtility.SaveFilePanel ("Save Input Settings", Application.streamingAssetsPath, "InputSettings", "bin"));
										else
												saveInputSettings (EditorUtility.SaveFilePanel ("Save Input Settings", Application.streamingAssetsPath, "InputSettings", "xml"));
										return;
								}
						}

						if (settingsFile == null)
								_isBinary = GUILayout.Toggle (_isBinary, "Binary");

						/////////// RELOAD ////////////////
						if (GUILayout.Button ("Reload")) { 
								_settingsLoaded = false;
						}
						EditorGUILayout.EndHorizontal ();


						EditorGUILayout.Separator ();

						//loadingSettings selected thru ObjectField browser or drag and drop
						if ((!_settingsLoaded && settingsFile != null)) { 
								
								
							_settingsLoaded=loadInputSettings (settingsFile);
								
						}



				
						/////////  ANIMATOR CONTROLER //////////
						_lastController = controller;
			
				
						EditorGUILayout.LabelField ("Animator Controller States");

						EditorGUILayout.BeginHorizontal ();
						controller = EditorGUILayout.ObjectField (controller, typeof(UnityEditor.Animations.AnimatorController), true) as UnityEditor.Animations.AnimatorController;

				
						EditorGUILayout.EndHorizontal ();



						EditorGUILayout.Separator ();


				


				
						/////////  Create AnimaitonController states GUI //////////
						if (controller != null) {
		
								ac = controller as UnityEditor.Animations.AnimatorController;
						

								numLayers = ac.layers.Length;

								if (_showLayer == null || _showLayer.Length != numLayers)
										_showLayer = new bool[controller.layers.Length];
					   
				
								for (i=0; i<numLayers; i++) {
										layer = ac.layers [i];

								

										_showLayer [i] = EditorGUILayout.Foldout (_showLayer [i], layer.name);

										if (_showLayer [i]) {
												stateMachine = layer.stateMachine;
					
												numStates = stateMachine.states.Length;
					
												scrollPosition = GUILayout.BeginScrollView (scrollPosition, false, false);
				
												for (j=0; j<numStates; j++) {
														state = stateMachine.states [j].state;
														createInputStateGUI (state.name, Animator.StringToHash (state.name));
														//createInputStateGUI (state.name, state.uniqueNameHash);
							
												}

												GUILayout.EndScrollView ();
										}

								}


								EditorGUILayout.Separator ();

						}

						///////////////////// NEW CUSTOM STATE STATE //////////////////////
						EditorGUILayout.LabelField ("Custom States");

				
						EditorGUILayout.BeginHorizontal ();
						EditorGUILayout.LabelField ("New state name:", _stateNameLabelStyle);
						_newCustomStateName = EditorGUILayout.TextField (_newCustomStateName, _stateNameLabelStyle);
				
						if (_newCustomStateName != _prevNewCustomStateName)
								_warrningAddStateLabel = "";

						_prevNewCustomStateName = _newCustomStateName;

						if (GUILayout.Button ("+", _addRemoveButtonStyle)) {
			
								EditorGUIUtility.keyboardControl = 0;
								_selectedStateHash = 0;

								if (_newCustomStateName != null && _newCustomStateName.Length > 0) {
										int hash = Animator.StringToHash (_newCustomStateName);
										if (!_stateInputCombinations.ContainsKey (hash)) {//not already there
												_stateInputCombinations [hash] = new InputState (_newCustomStateName, hash);// string[]{"None","None"};
												_stateInputCombinations [hash].Add (new InputCombination ("None"));
												_stateInputCombinations [hash].Add (new InputCombination ("None"));
					
					
												_newCustomStateName = "";//reset
										} else
												_warrningAddStateLabel = "Already exist!";
								} else {

										_warrningAddStateLabel = "Empty state name!";
						
								}
						}


						GUI.color = Color.red;
						EditorGUILayout.LabelField (_warrningAddStateLabel);
						EditorGUILayout.EndHorizontal ();
						GUI.color = Color.white;

				
						EditorGUILayout.BeginHorizontal ();
						scrollPosition2 = EditorGUILayout.BeginScrollView (scrollPosition2, false, false);
						//Debug.Log ("Loop..." + _stateInputCombinations.Count+" inputmngr "+InputManager.Settings.stateInputs.Count);
						if (_stateInputCombinations != null)
								foreach (var KeyValuePair in _stateInputCombinations) {
										if (!existInController (KeyValuePair.Key)) {
												createInputStateGUI (KeyValuePair.Value.name, KeyValuePair.Key);
										}


								}
						GUILayout.EndScrollView ();	
						EditorGUILayout.EndHorizontal ();
		      
						//}




				

				

						//if event is of key or mouse
						if (Event.current.isKey) {

								if (Event.current.keyCode == KeyCode.Return) {
										_selectedStateHash = 0;
										_previousStateInput = null;
										this.Repaint ();
								} else if (Event.current.keyCode == KeyCode.Escape) {
										if (_selectedStateHash != 0) {
												_stateInputCombinations [_selectedStateHash].combinations [_isPrimary] = _previousStateInput;
												_previousStateInput = null;
												_selectedStateHash = 0;
										}
								}		
						}
			
						if (_selectedStateHash != 0)
								InputManager.processGUIEvent (Event.current);//process input from keyboard & mouses
		
		

						

				

				}
				//////////////////////               CREATE STATE GUI             ///////////////////////

				/// <summary>
				/// Creates the state GUI.
				/// </summary>
				/// <param name="name">State Name.</param>
				/// <param name="hash">State Hash.</param>
				void createInputStateGUI (string name, int hash)
				{
						InputCombination[] combinations;
						string currentCombinationString;
		
						GUILayout.BeginHorizontal ();
		
		
						GUILayout.Label (name, _stateNameLabelStyle);
		
		
						if (_selectedStateHash != hash) {
			
								if (InputMapper._stateInputCombinations.ContainsKey (hash)) {
				
				
										combinations = InputMapper._stateInputCombinations [hash].combinations;
				
				
										if (combinations [0] == null)
												combinations [0] = new InputCombination ("None");

										if (GUILayout.Button (combinations [0].combinationString)) {
												_selectedStateHash = hash;
												_previousStateInput = null;
												_isPrimary = 0;
												EditorGUIUtility.keyboardControl = 0;
										}
				
										if (combinations [1] == null)
												combinations [1] = new InputCombination ("None");

										if (GUILayout.Button (combinations [1].combinationString)) {
												_selectedStateHash = hash;
												_previousStateInput = null;
												_isPrimary = 1;
												EditorGUIUtility.keyboardControl = 0;
										}


                                  
				
										//DELETE
										if (GUILayout.Button ("-", _addRemoveButtonStyle)) {
												//delete 
												_deleteStateWithHash = hash;
												//this.Repaint();
										}
								} else {
										if (GUILayout.Button ("None")) {

												InputState state = _stateInputCombinations [hash] = new InputState (name, hash);
												state.Add (new InputCombination ((int)KeyCode.None), 0);
						

										
												_selectedStateHash = hash;
												_previousStateInput = null;
												_isPrimary = 0;
												EditorGUIUtility.keyboardControl = 0;
										}
				
				
										if (GUILayout.Button ("None")) {

												InputState state = _stateInputCombinations [hash] = new InputState (name, hash);
												state.Add (new InputCombination ((int)KeyCode.None), 1);
					
										
												_selectedStateHash = hash;
												_previousStateInput = null;
												_isPrimary = 1;
												EditorGUIUtility.keyboardControl = 0;
										}
				
								}
			
			
						} else {

								if (InputMapper._stateInputCombinations.ContainsKey (hash)) {
										combinations = InputMapper._stateInputCombinations [hash].combinations;
			

										currentCombinationString = combinations [_isPrimary].combinationString;

										if (_previousStateInput == null) {
												_previousStateInput = combinations [_isPrimary].Clone ();
										}
						
						
								} else {
										currentCombinationString = "None";
								}


								GUILayout.Label (currentCombinationString);//, _inputLabelStyle);


			
								this.Repaint ();
						}
		
						//			
		
		
						GUILayout.EndHorizontal ();
		
		
		
						EditorGUILayout.Separator ();
				}