Ext.Ms/**
 * Project      : AMDA-NG4
 * Name         : ExplorerUI.js
 * Description  : Explorer Module UI definition (View)
 * @class   amdaUI.ExplorerUI 
 * @extends Ext.tab.Panel 
 * @brief   Explorer View
 * @author  CDA
 * @version $Id: ExplorerUI.js 2544 2014-10-03 10:21:56Z elena $ 
 */


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;
    }
});


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_ROOT : 'root',
        ITEM_KIND_LEAF : 'leaf',
        ITEM_KIND_DIRE : 'dire',
        ITEM_KIND_PARA : 'para',
    },

    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);
            },
       //     activeTab: 0,
            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')
                                    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([{ property : '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: 'DES' }, 
                    {  sorterFn: function(o1, o2){                     
                        if (o1.get('nodeType') !== 'localParam')
                            return;  
                        
                        return o1.get('text').toUpperCase()  < o2.get('text').toUpperCase() ? -1 : 1;
                    } }],
             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' :	   
                            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){
			// block other events
			e.stopEvent();
			
			// unlock selection
//			view.ownerCt.getSelectionModel().setLocked(false);
		       // already selected by default by right click
// 			view.ownerCt.getSelectionModel().select(rec,true);
			
			// 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)
				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 'localParam' :
					case 'remoteParam':
					case 'remoteSimuParam':    
						record.createAlias(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();
			}
		},
//  Already done in ExtJS 4.2.4 selection model
// 		itemmousedown: function(tree,rec,item,index,event,options){
// 			if(event.button===2){
// 				// if the right clicked item is already selected
// 				if (tree.getSelectionModel().isSelected(rec)) {
// 					// lock selection to prevent the selection modification by the right click
// 					 tree.getSelectionModel().setLocked(true);
// 				}
// 			}
// 		},
		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('info'));
            	    		});
            	    		break;
            	    }
                },
                toolIsVisible : function(record) {
                	
                	switch (record.get('nodeType'))
                	{
                		case 'localParam' :
                                case 'remoteParam' :
                                case 'remoteSimuParam' :
                			
                			return record.get('help') != '';
                	}
                	return false;
                },
                field: { 
                	validFlag: false,
    	            validator : function(value) {
    	            	// get explorerModule
                    	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) {
                            if (!editedNode.get('id') && value === amdaModel.AmdaNode.NEW_DIR_NAME){
                                return false;
                            } else {
                            	return this.validFlag;
                            }
                        } else {
                            return 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) {
                            		if (!res)
								  	{
                            			field.validFlag = 'Error during object validation';
                            			field.validate();
									  	return;
								  	}
                        		
                            		if (!res.valid)
                            		{
                            			if (res.error)
									  	{
                            				field.validFlag = res.error;
                            				field.validate();
											return;
									  	}
                            			else
                            			{
                            				field.validFlag = 'Invalid object name';
                            				field.validate();
                            				return;
                            			}
								  	}
								  
                            		field.validFlag = true;
                            		field.validate();
								});
                            }
    	            	}
    	            },
		    scope: this
                }
            }],
            //add our custom editor plugin
            plugins:  [new MyTreeEditor({
            	pluginId: 'treeEditor',
            	listeners: {
            		'canceledit' : function(editor, context) {
            			if (editor && editor.startValue===amdaModel.AmdaNode.NEW_DIR_NAME) {
            	            context.record.remove(true);	  
            			}
            		}
            		
            	}})],
            
            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']);
    }

});    
        
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){
                                // 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.get('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
        };
    }
} );