/**
 * Project      : AMDA-NG4
 * Name         : ExplorerUI.js
 * @class   amdaUI.ExplorerUI 
 * @extends Ext.tab.Panel
 * @class   amdaUI.TreeToolColumn
 * @extends Ext.tree.Column
 * @class   MyTreeEditor
 * @extends Ext.grid.plugin.CellEditing
 * @brief   Explorer View
 * @author  CDA
 */

Ext.define('amdaUI.TreeToolColumn', {
	extend: 'Ext.tree.Column',
	alias: 'widget.treetoolcolumn',

	/**
	* Add more tools here.  These will be on the prototype for all TreeToolColumns
	*/
	tools: {
		'info': 'js/resources/images/16x16/info_mini.png'
	},

	initComponent: function()
	{
		var me = this;
		me.addEvents('toolclick');
		me.callParent();
		me.on('toolclick', me.toolHandler, me);
	},

	renderer: function(value, metaData, record, rowIdx, colIdx, store, view)
	{
		var toolCol = view.getHeaderAtIndex(colIdx);

		if (!toolCol.toolIsVisible(record)) return value;

		var toolId  = 'tool-' + rowIdx + '-' + colIdx,
			toolImg = toolCol.tools[toolCol.tool],
			imgHtml = Ext.DomHelper.markup({
					id      : toolId,
					tag     : 'img',
					tooltype: toolCol.tool,
					src     : toolImg,
					style   : 'cursor:hand;'
			});

		return value + ' ' + imgHtml;
	},

	processEvent: function(type, view, cell, recordIndex, cellIndex, e)
	{
		if(type === "click" && e.target.tagName === "IMG")
		{
			var tooltype = e.target.getAttribute("tooltype");
			if(tooltype)
					return this.fireEvent("toolclick", view, cell, recordIndex, cellIndex, e);
		}
		return this.fireEvent.apply(this, arguments);
	},

	/**
	* Override this when you add columns to the tree... see example below
	*/
//    toolHandler: function() {
//        alert("override this");
//    },

	toolIsVisible : function(record) {
		return false;
	}
});


// ExplorerUI
Ext.define('amdaUI.ExplorerUI', {
	extend: 'Ext.tab.Panel',
	alias : 'widget.panelExplorer',

	statics:
	{
		RESRC_TAB : {
			TREE_ID:'resourcesTree',
			TREE_TYPE:'resources'
		},
		OPE_TAB : {
			TREE_ID:'operationsTree',
			TREE_TYPE:'operations'
		},
		JOB_TAB : {
			TREE_ID:'jobsTree',
			TREE_TYPE:'jobs'
		},

		CAT_SUFFIX: '-treeBase',
		ROOT_SUFFIX: '-treeRootNode',
		SUB_ROOT_SUFFIX : 'RootNode',
		
		ITEM_KIND_BASE : 'base',
		ITEM_KIND_ROOT : 'root',
		ITEM_KIND_LEAF : 'leaf',
		ITEM_KIND_DIRE : 'dire',
		ITEM_KIND_PARA : 'para',
		ITEM_KIND_PTAB : 'ptab', //plot tab
		ITEM_KIND_MISS : 'miss'
	},

	initComponent : function (config) 
	{
		var explorerModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.explorer.id);

		var myConf = {
			split	: true,
			width	: '100%',
			height      : '100%',
			autoScroll  : true,
			border      : true,
			header	: false,
			defaults	: {
				// applied to each contained panel
				containerScroll	: true
			},
			stateful: true,
			//stateId: 'tp1',
			stateEvents: ['tabchange'],
			getState: function() {
				return {
					activeTab: this.items.findIndex('id',this.getActiveTab().id)
				};
			},
			applyState: function(s) {
					this.setActiveTab(s.activeTab);
			},
			items: [
					this.initTree(amdaUI.ExplorerUI.RESRC_TAB.TREE_TYPE),
					this.initTree(amdaUI.ExplorerUI.OPE_TAB.TREE_TYPE),
					this.initTree(amdaUI.ExplorerUI.JOB_TAB.TREE_TYPE)
			],
			tbar : [
				{
					xtype : 'combo',
					fieldLabel: 'Filter',
					labelWidth: 25,
					width: 140,
					store: explorerModule.filtersStore,
					queryMode: 'local',
					displayField: 'name',
					valueField: 'id',
					listeners : {
						scope : this,
						select: function(combo, records) {
							AmdaAction.setCrtFilterId({id : records[0].get('id')},
									function (result, e)
									{
										var t = e.getTransaction();
										if (e.status)
										{
											if (result)
											{
												var explorerModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.explorer.id);
												if (explorerModule)
														explorerModule.setCrtFilter();
											}
											else
												Ext.Msg.show( {
														title : 'Filter',
														msg : 'Cannot apply filter',
														modal : true,
														icon : Ext.Msg.ERROR,
														buttons : Ext.Msg.OK
												});
										}
										else
										{
											// FAILURE
											Ext.Msg.show({title:'Error System', msg: e.message, icon: Ext.MessageBox.ERROR, buttons: Ext.Msg.OK});
										}
								},this);
							}
					}
				},
				{
					text: '',
					iconCls : 'icon-parameters',
					tooltip: { text: 'Edit Filter', align: 'bl-tl' },
					handler: function(t){
						myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.filters.id, true, function (module) {
							module.createWindow();
						});
					}
				},
				{
					text: '',
					iconCls : 'icon-remover',
					tooltip: { text: 'Reset Filter', align: 'bl-tl' },
					handler: function(t){
						var explorerModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.explorer.id);
						explorerModule.resetFilter();
					}
				}, '-',
				{
					xtype: 'displayfield',
					fieldLabel: 'SortBy',
					width: 40
				},
				{
					text: 'Name',
					scope : this,
					tooltip: { text: 'Sort out AMDA DataBase Data by Mission Name', align: 'bl-tl' },
					pressed: true,
					enableToggle : true,
					toggleGroup: 'sorting',
					handler: function(){
						var tree = Ext.getCmp(amdaUI.ExplorerUI.RESRC_TAB.TREE_ID);
						tree.getStore().sort([
								{  sorterFn: function(o1, o2){
										if (o1.get('nodeType') !== 'localParam' || o1.get('isParameter'))
											return;

										return o1.get('text').toUpperCase()  < o2.get('text').toUpperCase() ? -1 : 1;
									} 
								}]);
						this.updateFilter();
					}
				},
				{
					text: 'Target',
					scope : this,
					tooltip: {text: 'Sort out AMDA DataBase Data by Mission Main Target', align: 'bl-tl'},
					enableToggle : true,
					toggleGroup: 'sorting',
					handler: function(){
							var tree = Ext.getCmp(amdaUI.ExplorerUI.RESRC_TAB.TREE_ID);
							tree.getStore().sort('rank');
							this.updateFilter();
					}
				}]
		};
		Ext.apply (this , Ext.apply (arguments, myConf));
		this.callParent(arguments);
	},

	initTree : function(treeType)
	{
		switch (treeType) 
		{
			case amdaUI.ExplorerUI.RESRC_TAB.TREE_TYPE:
					treeId = amdaUI.ExplorerUI.RESRC_TAB.TREE_ID;
					break;
			case amdaUI.ExplorerUI.OPE_TAB.TREE_TYPE:
					treeId = amdaUI.ExplorerUI.OPE_TAB.TREE_ID;
					break;
			case amdaUI.ExplorerUI.JOB_TAB.TREE_TYPE:
					treeId = amdaUI.ExplorerUI.JOB_TAB.TREE_ID;
					break;
			default:
					treeId = amdaUI.ExplorerUI.RESRC_TAB.TREE_ID;
					break;
		}

		var store = Ext.create('Ext.data.TreeStore', {
			root: {
					expanded: true,
					nodeType : treeType
				},
			model: 'amdaModel.AmdaNode',
			sorters:[{ direction: 'ASC' ,
						sorterFn: function(o1, o2){
							
								if ((o1.get('nodeType') == 'localParam' && !o1.get('isParameter')) || o1.get('nodeType') == 'myData') {
									return o1.get('text').toUpperCase()  < o2.get('text').toUpperCase() ? -1 : 1;
								}
								
								return;
							} 
						}],
			listeners: {
				beforeload: function(store, operation){
					store.proxy.extraParams = {
							nodeType: operation.node.get('nodeType')
					};
				}
			}
		});

		var menu = new Ext.menu.Menu();

		var tree = Ext.create('Ext.tree.Panel', {
			id : treeId,
			title: treeType,
			store: store,
			rootVisible: false,
			animate: false,
			hideHeaders : true,
			selModel: Ext.create('Ext.selection.TreeModel', {
		//   	ignoreRightMouseSelection: true,
				mode: 'MULTI'
			}),
			viewConfig:
			{
				plugins:
				{
					ptype: 'treeviewdragdrop',
					enableDrag:true,
					enableDrop:true,
					//TODO - BRE - Wait a fix for drag&drop issue
					ddGroup:'explorerTree',
					pluginId : 'ddplugin',
					
					isValidDropPoint : function (node, position, dragZone, e, data)
					{
						if (!node || !data.item) {
									return false;
						}
						var view = this.view,
						targetNode = view.getRecord(node),
						draggedRecords = data.records,
						dataLength = draggedRecords.length,
						ln = draggedRecords.length,
						i, record;

						// No drop position, or dragged records: invalid drop point
						if (!(targetNode && position && dataLength)) {
								return false;
						}
						// If the targetNode is within the folder we are dragging
						for (i = 0; i < ln; i++) {
								record = draggedRecords[i];
								if (record.isNode && record.contains(targetNode)) {
									return false;
								}
						}
						// Respect the allowDrop field on Tree nodes
						if (position === 'append' && targetNode.get('allowDrop') === false) {
								return false;
						}
						else if (position != 'append' && targetNode.parentNode.get('allowDrop') === false) {
								return false;
						}
						// If the target record is in the dragged dataset, then invalid drop
						if (Ext.Array.contains(draggedRecords, targetNode)) {
								return false;
						}
						//
						if (dataLength > 1)
									return false;
						
						var draggedRecord = draggedRecords[0];
						//
						switch (targetNode.data.nodeType)
						{
							case 'localParam' :
							case 'remoteParam' :
							case 'remoteSimuParam' :
							case 'myData' :
							case 'plottab' :
								return false;
							default :
								if (draggedRecord.data.id == targetNode.data.nodeType+'-treeRootNode')
									return false;
								if ((position == 'before') && (targetNode.data.id == targetNode.data.nodeType+'-treeRootNode'))
									return false;
								return (draggedRecord.data.nodeType == targetNode.data.nodeType);
						}
						return false;
					},
					onViewRender : function(view)
					{
						var me = this;

						view.on('itemupdate', function(record,index,node,opts)
						{
							var forceHide = false;
							var crtRec = record.parentNode;
							while (crtRec && !forceHide)
							{
								if (crtRec.get('filtered'))
										forceHide = crtRec.get('filtered');
								crtRec = crtRec.parentNode;
							}
							tree.setNodesVisibility(record,forceHide);
							tree.applyDisableToNode(record);
						});

						view.on('itemadd', function(records,index,node,opts)
						{
							Ext.each(records,function (rec)
							{
								tree.applyFilterToNode(rec);
								tree.applyDisableToNode(rec);
							});
						});

						view.on('afteritemexpand', function(record,index,node,opts)
						{
							var forceHide = false;
							var crtRec = record.parentNode;
							while (crtRec && !forceHide)
							{
								if (crtRec.get('filtered'))
											forceHide = crtRec.get('filtered');
								crtRec = crtRec.parentNode;

							}
							tree.setNodesVisibility(record,forceHide);
							tree.applyDisableToNode(record);
						});

						if (me.enableDrag)
						{
							me.dragZone = Ext.create('Ext.tree.ViewDragZone', {
								view: view,
								ddGroup: me.dragGroup || me.ddGroup,
								dragText: me.dragText,
								repairHighlightColor: me.nodeHighlightColor,
								repairHighlight: me.nodeHighlightOnRepair
							});
						}

						if (me.enableDrop)
						{
							me.dropZone = Ext.create('Ext.tree.ViewDropZone', {
								view: view,
								ddGroup: me.dropGroup || me.ddGroup,
								allowContainerDrops: me.allowContainerDrops,
								appendOnly: me.appendOnly,
								allowParentInserts: me.allowParentInserts,
								expandDelay: me.expandDelay,
								dropHighlightColor: me.nodeHighlightColor,
								dropHighlight: me.nodeHighlightOnDrop,
								isValidDropPoint : me.isValidDropPoint
							});
						}
					}
				},
				listeners :
				{
					beforedrop : function(node, data, overModel, dropPosition)
					{
						var parentId;
						switch(dropPosition)
						{
							case 'append' :
									if (overModel.isLeaf())
										parentId = overModel.parentNode.get('id');
									else
										parentId = overModel.get('id');

										if(!overModel.isExpanded() && overModel.isExpandable()) {
													myDesktopApp.warningMsg('Please open the folder before node adding');
													return false;
										}
									break;
							case 'before' :
							case 'after' :
									parentId = overModel.parentNode.get('id');
									break;
						}

						Ext.each(data.records, function(rec)
						{
							rec.renameDD(parentId,function(result)
							{
								if (result)
								{
									if (!result.id)
									{
										Ext.Msg.show({
													title : 'Drop is impossible',
													msg : result.error,
													buttons : Ext.Msg.OK,
													icon : Ext.MessageBox.WARNING
										});

										return false;
									}
								}
								else
								{
									Ext.Msg.show({
														title : 'Drop is impossible',
														msg : 'Cannot connect to the server',
														buttons : Ext.Msg.OK,
														icon : Ext.MessageBox.WARNING
												});

									return false;
								}

								return true;
							});
						});
					}
				}
			},
			listeners: 
			{
				itemmouseenter: function(view, record, item){
					if(record.get('isParameter')){
						var el = Ext.get(item),
						td = el.down('td > div');
						td.setStyle('cursor', 'crosshair');
					}
					else
					{
						var el = Ext.get(item),
						td = el.down('td > div');
						td.setStyle('cursor', 'pointer');
					}
				},

				itemcontextmenu: function(view, rec, item, index, e){
					// Add record to selection model
					view.ownerCt.getSelectionModel().select(rec);

					// block other events
					e.stopEvent();

					// clear menu items
					menu.removeAll();
					var menuItems;

					// if it's a single selection
					if (view.ownerCt.getSelectionModel().selected.length === 1) {
						// get items menu corresponding to right clicked record
						menuItems = rec.getContextMenuItems(this);

					} else if (view.ownerCt.getSelectionModel().selected.length > 1) {
						// get items menu corresponding to right clicked record
						menuItems = rec.getContextMenuMultiItems(this);
					}
								// if there's at least one item menu
					if (menuItems && menuItems.length){
						// add the items
						menu.add(menuItems);
						// add listener on right clicked record
						var onRecordClick = function (menu, item, e, eOpts)
							{
								if (this.myGetOwnerTree().getSelectionModel().isSelected(this)) {
									//Dispatch click event to the record
									this.onMenuItemClick(menu,item,e);
								}
								//Remove old click listener
								menu.removeListener('click',onRecordClick,this);
							};

						menu.addListener('click',onRecordClick,rec);
						// then show menu
						menu.showAt(e.getXY());
					}
				},

				itemdblclick: function(view, record, item, index, event){
					event.stopEvent();
					// first check if it is for SAVE-START-STOP plugin...
					if (Ext.PluginManager.getCount() > 0 &&
						record.get('nodeType') == amdaModel.TimeTableNode.nodeType && record.isLeaf()) {
						var zmgr = myDesktopApp.desktop.getDesktopZIndexManager();
						var winActive = zmgr.getActive();
						var winId =  winActive.getId();
						if (winId == 'explorer-win') {
							zmgr.eachTopDown(function(win) {
								var id = win.getId();
								if (id !==  'explorer-win') {
									winId = id;
									return false;
								}
							});
						}
					}

					if (record.get('nodeType') == 'remoteParam' && !record.isLeaf()
										&& !record.get('isParameter')) {
						myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.interop.id, true, function (module) {
							module.createWindow(record.getBaseId());
						});
					}

					if (record.isLeaf() || record.data.isParameter || (record.data.tabs && (record.data.tabs.length > 0)))                                                                                                                                     
						switch (record.get('nodeType'))
						{
							case 'myData' :
							case 'myDataParam' :
							case 'derivedParam' :
							case 'timeTable' :
							case 'sharedtimeTable' :
							case 'sharedcatalog' :
							case 'catalog' :
							case 'request' :
							case 'condition' :
								record.editLeaf();
								break;
							case 'plottab' :
								record.editPlotTab();
								break;
							case 'localParam' :
							case 'remoteParam':
							case 'remoteSimuParam':
								record.createPlot(record);
								break;
							case 'bkgWorks' :
								if (!record.get('object')) {
									AmdaAction.getObject(record.get('id'), record.get('nodeType'), record.getObjectCallback, record);
								}
								else {
									if (record.get('status') == 'done') {
										var isInteractive = false;
										var isNewTab = true;
										record.editNode(isNewTab, isInteractive);
									}
									else {
										myDesktopApp.infoMsg('Job Status: ' + record.get('status'));
									}
								}
								break;
						}
					},
					
					beforeselect: function(view,node,index,options){
						// if there's at least one node already selected
						if(view.selected.length
							//AND (the node which is beeing selected has a different nodeType than the first selected node OR the first selected node isn't a leaf
							&& ( node.get('nodeType')!== view.selected.items[0].get('nodeType') ||  !view.selected.items[0].isLeaf())
							// OR the node which is beeing selected has no nodeType OR it isn't a leaf OR
							|| !node.get('nodeType') || !node.isLeaf()
						){
							// clear old selection
							view.deselectAll();
						}
					},

					afterrender: function(comp){
						var view = comp.getView();
						view.tip = Ext.create('Ext.tip.ToolTip', {
							// The overall target element.
							target: view.el,
							// Each grid row causes its own seperate show and hide.
							delegate: view.itemSelector,
							dismissDelay : 0,
							//    showDelay: 100,
							//  anchor: 'left',
							// Moving within the row should not hide the tip.
							trackMouse: true,
							autoRender: true,
							listeners: {
								// Change content dynamically depending on which element triggered the show.
								beforeshow: function updateTipBody(tip) {
									if (view.getRecord(tip.triggerElement)) {
										var info = view.getRecord(tip.triggerElement).get('info');
										if (!info || info == '') {
											tip.addCls('hide');
										}
										else {
											tip.removeCls('hide');
											tip.update(info);
										}
									}
								}
							}
						});
					},
					// if remote base is empty - open interoperability module
					itemexpand: function(node) {
						if ( node.get('nodeType') == amdaModel.RemoteParamNode.nodeType
						&& node.getDepth() == 3 && !node.hasChildNodes()) {
							node.addData();
						}
					},
					scope: this
				},

				hideHeaders: true,
            // must define a column with a field to enable editor
				columns: [{
						xtype    : 'treetoolcolumn',
						text     : 'Name',
						flex     : 1,
						dataIndex: 'text',
						tool: 'info', // this references the "tools" object on the prototype
						toolHandler: function(view, cell, recordIndex, cellIndex, e) {
							var tooltype = e.target.getAttribute("tooltype");
							var record = view.store.getAt(recordIndex);
							switch (tooltype)
							{
							case 'info' :
								myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.info.id, true, function (module) {
									module.createWindow(record.get('help'), record.get('text'));
								});
								break;
							}
						},
						toolIsVisible : function(record) {

							switch (record.get('nodeType'))
							{
								case 'localParam' :
								case 'remoteParam' :
								case 'remoteSimuParam' :

								return record.get('help') != '';
							}
							return false;
						},
						field: {
							validFlag: true,
							listeners: {
								change : function( field, newValue, oldValue, eOpts )
								{
									var explModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.explorer.id);
									var explUI = explModule.getUiContent();
									var activeTreePanel = explUI.getActiveTab();

										var editedNode = activeTreePanel.getSelectionModel().selected.items[0];
										if (editedNode) {
											editedNode.isValidName(newValue, function (res) {
                        var validFlag = true;
                        if(newValue === amdaModel.AmdaNode.NEW_DIR_NAME) {
                          validFlag = 'Field is not modified'
                        } else if (!res) {
                          validFlag = 'Error during object validation';
												} else if (!res.valid) {
													if (res.error) {
                            validFlag = res.error;
													} else {
                            validFlag = 'Invalid object name';
													}
												}
                        if (validFlag !== true) {
                        	field.markInvalid(validFlag);
												}
                        field.validFlag = validFlag;
											});
										}
								}
							},
							scope: this
						}
					}],
					// Add our custom editor plugin
					plugins: [
						new MyTreeEditor({
							pluginId: 'treeEditor',
							listeners: {
								beforeedit: function (editor, e) {
									e.column.field.fireEvent('change', e.column.field, e.value, '');
								},
								validateedit: function (editor, e) {
									if (e.column.field.validFlag !== true) {
										if (e.record.deleteOnFailure) {
											e.record.remove(true);
										} else {
											return false;
										}
									}
									return true;
								}
							},
							scope: this
						})
					],

					setNodesVisibility : function(node,forceHide)
					{
						var isFiltered = node.get('filtered');

						for (var i = 0; i < node.childNodes.length; i++)
							this.setNodesVisibility(node.childNodes[i],forceHide || isFiltered);

						this.setNodeVisibility(node,!(forceHide || isFiltered));
					},

					setNodeVisibility : function(node,isVisible)
					{
						var record = store.getNodeById(node.internalId);
						var viewNode = Ext.fly(tree.getView().getNode(record));
						if (viewNode)
						{
							viewNode.setVisibilityMode(Ext.Element.DISPLAY);
							if (isVisible)
							{
								viewNode.show();
								this.applyDisableToNode(record);
							}
							else
								viewNode.hide();
						}
					},

					applyFilterToNode : function(node)
					{
						if (!node)
							return;

						var filter = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.explorer.id).filter;

						switch (node.get('nodeType'))
						{
							case 'localParam' :
								if (!filter || !filter['param'])
								{
									//no filter applied
									node.set('filtered',false);
									return;
								}
								var pos = node.get('depth') - 3; //depth from local param root node
								if (pos < 0 || pos > 2)
								{
									node.set('filtered',false);
									return;
								}
								var isFiltered = true;
								for (var i = 0; i < filter['param'].length; i++)
								{
									s = filter['param'][i].split(';');
									if (node.get('id') == s[pos])
									{
										isFiltered = false;
										break;
									}
								}
								node.set('filtered',isFiltered);
								break;
								
							case 'remoteSimuParam' :
								if (!filter || !filter['simu'] )
								{
									//no filter applied
									node.set('filtered',false);
									return;
								}
								var pos = node.get('depth') - 3; //depth from remote param root node

								if (pos < 0 || pos > 5)
								{
									node.set('filtered',false);
									return;
								}
								var isFiltered = true;

								for (var i = 0; i < filter['simu'].length; i++)
								{
									s = filter['simu'][i].split(';');

									if (node.get('id') == s[pos])
									{
										isFiltered = false;
										break;
									}
								}
								node.set('filtered',isFiltered);
								break;
							/*case 'alias' :
								if (!this.localParamFilter.result || this.localParamFilter.id == "" ||
									!node.isLeaf())
								{
									//no filter applied
									node.set('filtered',false);
									return;
								}
								var crtParam = node.get('id');
								crtParam = crtParam.replace('alias_','');
								crtParam = crtParam.replace(/_/g,':');
								var isFiltered = true;
								for (var i = 0; i < this.localParamFilter.result.length; i++)
								{
									s = this.localParamFilter.result[i].split(';');
									console.log(s[2]);
								if (crtParam == s[2])
								{
									isFiltered = false;
									break;
								}
								}
								node.set('filtered',isFiltered);
								break;*/
							default :
								return;
						}
					},

					applyFilterToNodes : function(node)
					{
						node.eachChild(function (child){
							tree.applyFilterToNodes(child);
						});
						tree.applyFilterToNode(node);
					},

					applyDisableToNode : function(node)
					{
						var crtNode = node;
						var disable = false;

						do
						{
							if (crtNode.get('disable'))
							{
								disable = true;
								break;
							}
							crtNode = crtNode.parentNode;
						} while (crtNode);


						var viewNode = Ext.fly(tree.getView().getNode(node));
						if (disable)
						{
							node.set('disable',true);
							viewNode.setStyle('opacity',0.5);
						}
					}
				});

				tree.addEvents('edition');

				return tree;
			},

			updateFilter : function()
			{
				var filter = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.explorer.id).filter;

				var keys = [];
				for (var f in filter) {
						if (hasOwnProperty.call(filter, f))
							keys.push(f);
				}

				var tree = this.query('#'+amdaUI.ExplorerUI.RESRC_TAB.TREE_ID)[0];
				tree.getView().refresh();

				for (var i = 0; i < keys.length; i++)
				{
					if (keys[i] == "_empty_")
						continue;

					switch (keys[i])
					{
						case 'param' :
								//apply filter to local datasets
								var localNode = tree.getRootNode().findChild('id','myLocalData-treeRootNode',true);
								tree.applyFilterToNodes(localNode);
								tree.setNodesVisibility(localNode,false);
								tree.applyDisableToNode(localNode);

								//apply filter to aliases
// 								var aliasNode = tree.getRootNode().findChild('id','alias-treeRootNode',true);
// 								tree.applyFilterToNodes(aliasNode);
// 								tree.setNodesVisibility(aliasNode,false);
// 								tree.applyDisableToNode(aliasNode);
								break;

						case 'simu' :
								//apply filter to simulation datasets (in remote data)
								var remoteNode = tree.getRootNode().findChild('id','myRemoteSimuData-treeRootNode',true);
								tree.applyFilterToNodes(remoteNode);
								tree.setNodesVisibility(remoteNode,false);
								tree.applyDisableToNode(remoteNode);
								break;
					}
				}

				this.dockedItems.getAt(1).items.items[0].select(filter['name']);
			}
});

// MyTreeEditor
Ext.define( 'MyTreeEditor', {
	extend: 'Ext.grid.plugin.CellEditing',
	alias: 'editing.treeeditor',

	// initialization method of plugin
	init: function(cmp) {
		var me = this;
		me.hostCmp = cmp;
		// on parent event
		me.hostCmp.on({
			// on edition event
			edition : {
					delay: 50,
					fn : function(view, record, item, index, e){
						// view.getHeaderAtIndex(0).field.validFlag = 'Not modified';
						// call the start edition method
						me.startEdit(record, view.getHeaderAtIndex(0));
					},
					scope: me
			}
		});
		me.callParent(arguments);
	},

	/**
	* Cancel any active editing.
	*/
	cancelEdit: function() {
		var me = this,
		activeEd = me.getActiveEditor(),
		viewEl = me.grid.getView().getEl(me.getActiveColumn());

		me.setActiveEditor(null);
		me.setActiveColumn(null);
		me.setActiveRecord(null);
		if (activeEd) {
			activeEd.cancelEdit();
			viewEl.focus();
			this.fireEvent('canceledit', activeEd, me.context);
		}
	},

	/**
	* overwrite the initEditTriggers to disable edition on click/dblclick
	* and to add custom
	*/
	initEditTriggers: function() 
	{
		var me = this,
		view = me.view;

		me.on({
			edit: function(editor,event){
					// if there is a modification
					if (event.originalValue !== event.value) {
						// delegate rename action on model
						event.record.rename(event.value,function(result){
							// if a result has been returned : success
							if(result) {
									// delegate commit action to delete modification flag
									event.record.commit();
									var rec = event.record.data;
									// in case of directory
									if (!rec.leaf && (rec.nodeType != 'plottab')){
										// set folder's ID returned by server
										rec.id = result.id;
									}
							} else { // in case of transaction error
									// reset originalValue
									event.record.value = event.originalValue;
									event.record.set('text', event.originalValue);
									event.record.commit();
							}
						});
					}
			}
		});

		// enable Enter key and Esc Key
		view.on('render', function() {
			me.keyNav = Ext.create('Ext.util.KeyNav', view.el, {
					enter: me.onEnterKey,
					esc: me.onEscKey,
					scope: me
			});
		}, me, { single: true });
	},
	//overwrite the getEditing context because we do not need the rowId
	getEditingContext: function(record, columnHeader) {
		var me = this,
		grid = me.grid,
		store = grid.store,
		colIdx,
		view = grid.getView(),
		value;

		// getting colIdx and real columnHeader
		if (Ext.isNumber(columnHeader)) {
			colIdx = columnHeader;
			columnHeader = grid.headerCt.getHeaderAtIndex(colIdx);
		} else {
			colIdx = columnHeader.getIndex();
		}
		// getting current value
		value = record.get(columnHeader.dataIndex);

		// return editing context
		return {
			grid: grid,
			record: record,
			field: columnHeader.dataIndex,
			value: value,
			column: columnHeader,
			colIdx: colIdx,
			view: columnHeader.getOwnerHeaderCt().view
		};
	}
});