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 Local 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 Local 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:[{ property:'leaf', 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,
            //TODO deprecated
            //multiSelect: 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);

                    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)
                			{
                				//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;

			      }
			  });
			}
		      }

//		    var targetModuleName = myDesktopApp.getModule('explorer-win').getPinedModule();

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