/**
 * Project   : AMDA-NG
 * Name      : DownloadUI.js
 * @class 	 amdaUI.DownloadUI
 * @extends  Ext.container.Container 
 * @brief    Download Module UI definition (View)
 * @author 	 Myriam
 * @version $Id: DownloadUI.js 2622 2014-11-07 14:50:09Z elena $  
 */

Ext.define('amdaUI.DownloadUI', {

    extend: 'Ext.container.Container',
    alias: 'widget.panelDownload',

    requires: [
        'amdaUI.TimeSelectorUI',
        'amdaUI.ParamArgumentsPlug',
        'amdaUI.SendToSampButtonUI',

	'amdaModel.Download',

        'amdaModel.DownloadParam',
        'amdaModel.RequestParamObject'

    ],

    constructor: function (config) {
        this.init(config);
        this.callParent(arguments);
        // load object into view		 
        if (this.object)
            this.loadObject();
        //
        var paramArgsPlug = this.getPlugin('download-param-arguments-plugin');
        if (paramArgsPlug)
            paramArgsPlug.onApply = this.onApplyParameterArgs;
    },

    saveRequest: function()
    {
        var me = this;

        if (!this.updateObject()) {
            return;
        }

        var downloadModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
        if (!downloadModule) {
            return;
        }

        if ((this.object.get('id') != '') && (downloadModule.linkedNode.get('text') == this.object.get('name'))) {
            this.saveProcess(false);
            return;
        }

        downloadModule.linkedNode.isValidName(this.fieldName.getValue(), function (res) {
            if (!res)
            {
                me.fieldName.validFlag = 'Error during object validation';
                myDesktopApp.errorMsg(me.fieldName.validFlag);
                me.fieldName.validate();
                return;
            }

            if (!res.valid)
            {
                if (res.error)
                {
                    if (res.error.search('subtree') != -1) {
                        Ext.MessageBox.show({title:'Warning',
                            msg: res.error+'<br/>Do you want to overwrite it?',
                            width: 300,
                            buttons: Ext.MessageBox.OKCANCEL,

                            fn : function(btn) {
                                if (btn == 'cancel') return;
                                this.fieldName.clearInvalid();
                                this.saveProcess(true);
                            },

                            icon: Ext.MessageBox.WARNING,
                            scope : me
                        });
                        me.fieldName.validFlag = true;
                    }
                    else
                        me.fieldName.validFlag = res.error;
                }
                else
                {
                    me.fieldName.validFlag = 'Invalid object name';
                    myDesktopApp.errorMsg(me.fieldName.validFlag);
                }
                me.fieldName.validate();
                return;
            }

            me.fieldName.validFlag = true;
            me.fieldName.validate();
            me.saveProcess(false);
        });
    },

    saveProcess: function(toRename) {

        var downloadModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
        if (this.object.isModified('name')) {
            if (this.object.get('id'))
            {
                var contextNode = downloadModule.linkedNode.parentNode;
                downloadModule.createLinkedNode();
                downloadModule.linkedNode.set('contextNode',contextNode);
                downloadModule.createObject(this.object.getJsonValues());
                var downloadObj = downloadModule.linkedNode.get('object');
                this.object = downloadObj;
                if (toRename) downloadModule.linkedNode.toRename = true;

            }

            downloadModule.linkedNode.create();
        }
        else {
            downloadModule.linkedNode.set('contextNode',downloadModule.contextNode);
            downloadModule.linkedNode.update();

        }
    },

    addTT: function (newTTName, newTTid)
    {
        var tabPanel = this.formPanel.down();
        var downloadSrc = tabPanel.items.indexOf(tabPanel.getActiveTab());

        if (downloadSrc === 0) {
            this.timeSelector.addTT(newTTName, newTTid);
        } else {
            // search for an existing record in store with this unique name
            var existingIndex = this.TTGrid.store.findExact('name', newTTName);
            // if no corresponding TT found
            if (existingIndex == -1) {
                // adding the time table to the TTGrid of TT download 
                var r = Ext.create('amdaModel.TTobject', {id: newTTid, name: newTTName});
                this.TTGrid.store.insert(this.TTGrid.store.getCount(), r);
            }
        }
    },

    addTTs: function (TTarray) {
        // set TTTab	    
        this.timeSelector.setTTTab(TTarray);
    },

    // Add TT in download TT module
    addTTdownload: function (newTTName, newTTid) {
        var tabPanel = this.formPanel.down();
        tabPanel.setActiveTab(1);
        this.addTT(newTTName, newTTid);

    },

    /**
     * Set Start-Stop from parameter info (Local & MyData)
     */
    setTimeFromData: function (obj) {
        if (!obj.start || !obj.stop)
            return;
        var dateStart = new Date(obj.start.replace(/[T|Z]/g, ' ').replace(/\-/g, '\/'));
        var dateStop = new Date(obj.stop.replace(/[T|Z]/g, ' ').replace(/\-/g, '\/'));

        this.down('form').getForm().setValues({startDate: dateStart, stopDate: dateStop});
        this.timeSelector.intervalSel.updateDuration();
    },

    addParameter: function(paramNode, updateTime)
    {

        if (this.doNotifyDrop(paramNode)) {
            return this.doParamDrop(paramNode);
        }
        return false;

    },

    addParam: function (paramId, isLeaf, needArgs, components, predefined_args)

    {
        // adding the parameter to the  paramGrid	

        var paramObj = amdaModel.RequestParamObject.getEmptyObj();
        paramObj.paramid = paramId;

        if (components) {
            if (components['index1']) {
                paramObj['dim1-index'] = components['index1'];
                ++paramObj['type'];
            }

            if (components['index2']) {
                paramObj['dim2-index'] = components['index2'];
                ++paramObj['type'];
            }
        }

	if (predefined_args) {
		paramObj.template_args = predefined_args;
	}

        var r = Ext.create('amdaModel.DownloadParam', paramObj);
        var pos = this.paramGrid.store.getCount();
        this.paramGrid.store.insert(pos, r);
        this.paramGrid.getView().refresh();

        if (needArgs)
            this.editParameterArgs(r);
    },

    // parameter name -> alias
    updateConstruct: function (oldval, newval) {
        var index = this.paramGrid.store.findExact('name', oldval);
        if (index != -1) {
            this.paramGrid.getStore().getAt(index).set('name', newval);
            this.paramGrid.getStore().getAt(index).set('text', newval);
        }
    },

    setObject: function (obj) {
        this.object = obj;
        this.loadObject();
    },

    /**
     * update this.object from form
     */
    updateObject: function ()
    {
        // get the basic form
        var tabPanel = this.formPanel.down();
        var downloadSrc = tabPanel.items.indexOf(tabPanel.getActiveTab());
        var basicForm = this.formPanel.getForm();
        var updateStatus = true;
        var values = basicForm.getValues();

        // data download
        if (downloadSrc === 0)
        {
            var timeformat = values.timeformat;
            var timeSource = this.timeSelector.getActiveTimeSource();

            var filestructure = values.filestructure;

            var sampling = values.sampling ? values.sampling : 600;

            var refparamSampling = values.refparamSampling == 'on';

            var fileprefix = values.fileprefix ? values.fileprefix : '';
            var fileformat = values.fileformat;
            var compression = values.compression;

            var fieldsWithoutName = basicForm.getFields().items;
            Ext.Array.each(fieldsWithoutName, function (item, index, allItems) {

                if ((item.name != 'name') && !item.isValid()) {

                    if ((timeSource === amdaModel.AmdaTimeObject.inputTimeSrc[0]) &&
                            ((item.name == 'startDate') || (item.name == 'stopDate') || (item.name == 'duration'))) {
                        updateStatus = true;
                    } else {
                        // set update isn't allowed
                        updateStatus = false;
                        return false;
                    }
                }
            }, this);

            if (timeSource === amdaModel.AmdaTimeObject.inputTimeSrc[0] // timeSource  'TimeTable'
                    && this.timeSelector.TTGrid.getStore().count() == 0) {
                myDesktopApp.warningMsg('You\'ve chosen Time Selection `by TimeTable` but no timeTable was added!'
                        + '<br>You must add one or choose Time Selection `by Interval`');
                updateStatus = false;
            }

            if (updateStatus && (this.object.params().count() == 0))
            {
                myDesktopApp.warningMsg('You must define at least one parameter to download');
                updateStatus = false;
            }

            if (updateStatus)
            {
                /// real object update
                // update TimeTable object with the content of form
                basicForm.updateRecord(this.object);

                this.object.set('timesrc', timeSource);
                // set valid intervals into TimeTable object
                if (timeSource === amdaModel.AmdaTimeObject.inputTimeSrc[0])
                    this.object.set('timeTables', this.timeSelector.TTGrid.getStore().data.items);

                this.object.set('filestructure', filestructure);

                this.object.set('refparamSampling', refparamSampling);
                this.object.set('sampling', sampling);
                this.object.set('fileprefix', fileprefix);
                this.object.set('timeformat', timeformat);
                this.object.set('fileformat', fileformat);
                this.object.set('compression', compression);
            }
        }
        //TT download
        else
        {

            var timeformat = values.timeformatTT ? values.timeformatTT :amdaModel.DownloadConfig.defaultValues.timeformatTT;

            var compression = values.compressionTT;
            var fileformat = values.fileformatTT;

            if (this.TTGrid.getStore().count() == 0) {
                myDesktopApp.warningMsg('You must define at least one TimeTable or Catalog to download');
                updateStatus = false;
            }
            else if (compression === 'none'

                    && this.TTGrid.getStore().count() > 1) {
                myDesktopApp.warningMsg('You are going to download several time tables -  select the Compression please');
                updateStatus = false;
            }
            this.object.set('timeTables', this.TTGrid.getStore().data.items);
            this.object.set('timeformatTT', timeformat);
            this.object.set('fileformatTT', fileformat);
            this.object.set('compressionTT', compression);
        }

        this.object.set('downloadSrc', downloadSrc);
        // return the update status
        return updateStatus;
    },

    /**
     * load this.object into form
     */
    loadObject: function () {

        // load object into form	
        this.formPanel.getForm().loadRecord(this.object);
        // set object's TTs into the timeselector
        this.addTTs(this.object.get('timeTables'));

        // set parameters
        this.paramGrid.reconfigure(this.object.params());
        //this.paramGrid.getStore().loadData(this.object.params().data.items);
	// select "Parameters" tab
	var tabPanel = this.formPanel.down();
        tabPanel.setActiveTab(0);

    },

    /**
     * download method called by 'Download' button to launch the download process
     */
    doDownload: function (sendToSamp, clientId) {
        var downloadModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
        if (downloadModule)

            downloadModule.linkedNode.execute({'sendToSamp': (sendToSamp == true), 'clientId': clientId});

    },

    actionItem: function (grid, cell, cellIndex, record, row, recordIndex, e) {

        var isTimeTable = record instanceof amdaModel.TTobject;

        if (cellIndex == 3 || (cellIndex == 2 && isTimeTable))
            grid.getStore().remove(record);
        else if (cellIndex == 2) {
            this.paramGrid.getView().select(row);
            this.editParameterArgs(record);
        }
    },

    editParameterArgs: function (record) {
        var paramArgsPlug = this.getPlugin('download-param-arguments-plugin');
        if (paramArgsPlug)
            paramArgsPlug.show('download-param-arguments-plugin', record);
    },

    onApplyParameterArgs: function (parentUI, paramObject) {
        parentUI.paramGrid.getView().refresh();
    },

    onFileStructureChange: function (combo, newValue, oldValue) {
        if (!this.formPanel)
            return;

        var refParamCheck = this.formPanel.getForm().findField('refparamSampling');

        var samplingField = this.formPanel.getForm().findField('sampling');

        if (samplingField && newValue !== oldValue) {
            refParamCheck.setDisabled(newValue == 2);
            samplingField.setDisabled((newValue == 2) || refParamCheck.getValue());
        }
    },

    onTTFileFormatChange: function (combo, newValue, oldValue) {
         if (!this.formPanel)
            return;

        var refTimeFormatField = this.formPanel.getForm().findField('timeformatTT');

        if (refTimeFormatField && newValue !== oldValue) {
                       if (newValue === 'space' ){
                           refTimeFormatField.setValue('YYYY-MM-DDThh:mm:ss');
                           refTimeFormatField.setDisabled(true);
                       }else{
                           refTimeFormatField.setDisabled(false);
                       }
        }
    },

    onRefParamSamplingChange: function (check, newValue, oldValue) {
        if (!this.formPanel)
            return;

        var samplingField = this.formPanel.getForm().findField('sampling');
        var structureCombo = this.formPanel.getForm().findField('filestructure');

        if (samplingField && newValue !== oldValue)
            samplingField.setDisabled((structureCombo.getValue() == 2) || check.getValue());
    },

    onSendVOTableToSamp: function (clientId, sendOpt) {
        var me = sendOpt.scope;
        if (me.updateObject()) {
            me.doDownload(true, clientId);
        }
    },

    doNotifyDrop: function(record)

    {

        if (record.get('nodeType') == 'localParam' && record.get('notyet'))
        {
            return false;
        }
        if (((record.get('nodeType') == 'localParam') ||
             (record.get('nodeType') == 'remoteParam') ||
             (record.get('nodeType') == 'remoteSimuParam') ||
             (record.get('nodeType') == 'derivedParam') ||
             (record.get('nodeType') == 'myDataParam') ||
             (record.get('nodeType') == 'alias')) &&
             (record.isLeaf() || record.get('isParameter')) &&
             !record.get('disable'))
        {
            return true;
        }

        return false;
    },

    doParamDrop: function(record)
    {
        var idToSent;
        var components = null;
        var predefinedArgs = record.get('predefinedArgs');
        switch (record.get('nodeType'))
        {
            case 'localParam' :
            case 'remoteParam':
            case 'remoteSimuParam':
                idToSent = record.get('id');
                if (record.get('alias') != "")
                    idToSent = "#" + record.get('alias');
                var component_info = record.get('component_info');
                if (component_info && component_info.parentId)
                {
                    if (component_info.index1 || component_info.index2)
                    {
                        idToSent = component_info.parentId;
                        components = [];
                        if (component_info.index1)
                            components['index1'] = component_info.index1;
                        if (component_info.index2)
                            components['index2'] = component_info.index2;
                        predefinedArgs = record.parentNode.get('predefinedArgs');
                    }
                    if (record.get('needsArgs'))
                    {
                        idToSent = component_info.parentId;
                        if (component_info.index1)
                        {
                            components = [];
                            components['index1'] = component_info.index1;
                        }
                    }
                }
                break;
            case 'alias' :
                idToSent = "#" + record.get('text');
                break;
            case 'derivedParam' :
                if (record.modelName == 'amdaModel.DerivedParamComponentNode')
                {
                    paramId = record.get('text');
                    var parentId = paramId.substr(0, paramId.length - 3);
                    idToSent = "ws_" + parentId;
                    var regExp = /\(([\d]+)\)/;
                    var component_index = regExp.exec(paramId);
                    if (component_index)
                    {
                        components = [];
                        components['index1'] = component_index[1];
                    }
                } 
                else {
                    idToSent = "ws_" + record.get('text');
                }
                break;
            case 'myDataParam' :
                if (record.modelName == 'amdaModel.MyDataParamComponentNode')
                {
                    paramId = record.get('text');
                    var parentId = paramId.substr(0, paramId.length - 3);
                    idToSent = "wsd_" + parentId;
                    var regExp = /\(([\d]+)\)/;
                    var component_index = regExp.exec(paramId);
                    if (component_index)
                    {
                        components = [];
                        components['index1'] = component_index[1];
                    }
                }
                else {
                    idToSent = "wsd_" + record.get('text');
                }
                break;
            default :
                return false;
        }

        var downModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
        if (downModule) {
            if (predefinedArgs) {
                downModule.parseTemplatedParam(idToSent, function(param_info) {
                    downModule.addParam(param_info.paramid, record.get('leaf'), record.get('needsArgs'), components, param_info.template_args);
                });
            }
            else {
                downModule.addParam(idToSent, record.get('leaf'), record.get('needsArgs'), components);
                return true;
            }
        }
        return true;

    },

    /**
     * Check if changes were made before closing window 
     * @return false
     */
    fclose: function () {

        return this.object.isDirty();

    },

    init: function (config) {
        var me = this;

        this.timeSelector = new amdaUI.TimeSelectorUI({id: 'downloadTimeSelector', flex: 1});

        this.fieldName = new Ext.form.field.Text({
            labelAlign: 'left',
            labelWidth: 90,
            fieldLabel: 'Request Name',
            name : 'name',
            allowBlank : false,
            stripCharsRe: /(^\s+|\s+$)/g,
            validateOnChange: false,
            validateOnBlur: false,
            validFlag: false,
            validator : function()
            {
                return this.validFlag;
            }
        });

        var downloadCont = this;

        this.paramGrid = Ext.create('Ext.grid.Panel', {
            flex: 2,
            store: Ext.create('Ext.data.Store', {model: 'amdaModel.DownloadParam'}),
            columns: [
                {xtype: 'rownumberer', width: 20},
                {
                    header: "Parameter Name",
                    dataIndex: 'name',
                    flex: 1,
                    sortable: false,
                    menuDisabled: true,
                    renderer: function (val, meta, rec) {
                        return rec.getParamFullName();
                    }
                },
                {
                    menuDisabled: true, width: 30, renderer: function () {
                        return'<div class="icon-parameters" style="width: 15px; height: 15px;"></div>';
                    }
                },
                {
                    menuDisabled: true, width: 30, renderer: function () {
                        return'<div class="icon-remover" style="width: 15px; height: 15px;"></div>';
                    }
                }
            ],
            //TODO - BRE - Wait the fix for drag&drop issue
            listeners:
                    {
                        render: function (o, op)
                        {
                            var me = this;
                            var el = me.body.dom;

                            me.dropTarget = Ext.create('Ext.dd.DropTarget', el, {

                                ddGroup: 'explorerTree',
                                notifyEnter: function (ddSource, e, data) { },
                                notifyOver: function (ddSource, e, data)
                                {

                                    if (!downloadCont.doNotifyDrop(data.records[0])) {

                                        this.valid = false;
                                        return this.dropNotAllowed;
                                    }

                                    this.valid = true;
                                    return this.dropAllowed;

                                },
                                notifyDrop: function (ddSource, e, data)
                                {
                                    if (!this.valid)
                                        return false;

                                    return downloadCont.doParamDrop(data.records[0]);

                                }
                            });
                        }
                    }
        });

        this.paramGrid.on('cellclick', this.actionItem, this);

        this.TTGrid = Ext.create('Ext.grid.Panel', {
            flex: 2,
            store: Ext.create('Ext.data.Store', {model: 'amdaModel.TTobject'}),
            columns: [
                {xtype: 'rownumberer', width: 20},
                {header: "TimeTable/Catalog Name", dataIndex: 'name', flex: 1, sortable: false, menuDisabled: true},
                {
                    menuDisabled: true, width: 30, renderer: function () {
                        return '<div class="icon-remover" style="width: 15px; height: 15px;"></div>';
                    }
                }
            ],
            listeners:
                    {
                        render: function (o, op)
                        {
                            var me = this;
                            var el = me.body.dom;
                            var dropTarget = Ext.create('Ext.dd.DropTarget', el, {
                                ddGroup: 'explorerTree',
                                notifyEnter: function (ddSource, e, data)
                                {

                                },
                                notifyOver: function (ddSource, e, data)
                                {
                                    var nodeType = data.records[0].get('nodeType');

                                    if ((nodeType == 'timeTable' || nodeType == 'sharedtimeTable') ||

                                            (nodeType == 'catalog' || nodeType == 'sharedcatalog') &&

                                            (data.records[0].get('leaf')))
                                    {
                                        this.valid = true;
                                        return this.dropAllowed;
                                    }
                                    this.valid = false;
                                    return this.dropNotAllowed;
                                },
                                notifyDrop: function (ddSource, e, data)
                                {
                                    if (!this.valid)
                                        return false;
                                    var downModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
                                    if (downModule)
                                        downModule.getUiContent().addTTdownload(data.records[0].get('text'), data.records[0].get('id'));
                                    return true;
                                }
                            });
                        }
                    }
        });

        this.TTGrid.on('cellclick', this.actionItem, this);

        var storeTimeFormat = new Ext.data.ArrayStore({

            fields: ['id', 'name', 'qtip'],

            data: amdaModel.DownloadConfig.timeformatData

        });

        this.paramPanel = new Ext.container.Container({

            title: 'Parameters',
            layout: {
                type: 'hbox',
                align: 'stretch',
                defaultMargins: {top: 10, left: 10, bottom: 5, right: 10}
            },
            items: [
                {
                    xtype: 'container',
                    flex: 2,
                    layout: {
                        type: 'vbox',
                        align: 'stretch'
                    },
                    items: [

                        this.fieldName,

                        {
                            xtype: 'splitter',
                            flex: 0.05
                        },
                        this.paramGrid
                    ]
                },
                {
                    xtype: 'container',
                    flex: 2,
                    defaults: {
                        xtype: 'combo',
                        labelWidth: 90,
                        queryMode: 'local',
                        editable: false
                    },
                    layout: {
                        type: 'vbox',
                        align: 'stretch'
                    },
                    items: [
                        {
                            fieldLabel: 'Time Format',
                            name: 'timeformat',
                            valueField: 'id',
                            displayField: 'name',
                            queryMode: 'local',

                            store: storeTimeFormat,

                            listConfig: {
                                tpl: [
                                    '<tpl for=".">',
                                    '<li class="x-boundlist-item" data-qtip="{qtip}">{name}</li>',
                                    '</tpl>'
                                ]

                            }

                        },
                        {
                            fieldLabel: 'File Structure',
                            name: 'filestructure',

                            store: amdaModel.DownloadConfig.filestructureData,

                            listeners: {
                                change: {fn: this.onFileStructureChange},
                                scope: this
                            }
                        },
                        {
                            xtype: 'checkbox', boxLabel: 'Header in a separate file',
                            boxLabelAlign: 'before',
                            name: 'separateInfoFile', checked: false

                        },
                        {
                            xtype: 'checkbox', boxLabel: 'Use first param. as reference for sampling',
                            boxLabelAlign: 'before',

                            name: 'refparamSampling', checked: false, disabled: true,

                            listeners: {
                                change: {fn: this.onRefParamSamplingChange},
                                scope: this
                            }
                        },
                        {
                            xtype: 'numberfield', name: 'sampling',
                            fieldLabel: 'Sampling Time', value: 600,
                            hideTrigger: true, editable: true,
                            disabled: true
                        },
                        {
                            xtype: 'checkbox', boxLabel: 'Scientific floating-point formatting',
                            boxLabelAlign: 'before',
                            name: 'scientificformat', checked: false
                        },
                        {
                            xtype: 'textfield', name: 'fileprefix',
                            fieldLabel: 'File Prefix',
                            disabled: false, editable: true
                        },
                        {
                            fieldLabel: 'File Format',
                            name: 'fileformat',

                            store: amdaModel.DownloadConfig.fileformatData

                        },
                        {
                            fieldLabel: 'Compression',
                            name: 'compression',

                            store: amdaModel.DownloadConfig.filecompressData

                        },

                        this.timeSelector
                    ]
                }

            ]});

        this.ttPanel =
                {
                    xtype: 'container',
                    title: 'Time Tables / Catalogs',
                    layout: {
                        type: 'hbox',
                        align: 'stretch',
                        defaultMargins: {top: 10, left: 10, bottom: 5, right: 10}
                    },
                    items: [
                        this.TTGrid,
                        {
                            xtype: 'container',
                            flex: 2,
                            defaults: {
                                xtype: 'combo',
                                labelWidth: 90,
                                queryMode: 'local',
                                editable: false
                            },
                            layout: {
                                type: 'vbox',
                                align: 'stretch'
                            },
                            items: [{
                                    fieldLabel: 'Time Format',
                                    name: 'timeformatTT',

                                    valueField: 'id',
                                    store: storeTimeFormat,
                                    displayField: 'name',
                                    queryMode: 'local',
                                    listConfig: {
                                        tpl: [
                                            '<tpl for=".">',
                                            '<li class="x-boundlist-item" data-qtip="{qtip}">{name}</li>',
                                            '</tpl>'
                                        ]

                                    }

                                },
                                {
                                    fieldLabel: 'File Format ',
                                    name: 'fileformatTT',

                                    store: amdaModel.DownloadConfig.fileformatTTData,
                                    listeners: {
                                        change: {fn: this.onTTFileFormatChange},
                                            scope: this
                                   }

                                },
                                {
                                    fieldLabel: 'Compression ',
                                    name: 'compressionTT',

                                    store: amdaModel.DownloadConfig.filecompressTTData

                                },
				{
                                    xtype: 'panel',
                                    html: ['<div>',

                                           '<p><b>=> Format specifications:</b></p>',

                                           '<ul>',

                                           '<li><b>Plain text:</b> ASCII tabular file. A comment line starts with "#"</li>',

                                           '<li><b>VOTable:</b> <a target="_blank" href="https://www.ivoa.net/documents/VOTable/20130315/PR-VOTable-1.3-20130315.html">Version 1.3</a></li>',

                                           '<li><b>HPEvent:</b> <a target="_blank" href="https://spase-group.org/docs/conventions/HDMC-Event-List-Specification-v1.0.4.pdf">Version 1.0</a></li>',

                                           '</ul>',
                                           '</div>'].join("\n")

                                }
                            ]}
                    ]
                };

        this.formPanel = new Ext.form.Panel({
            layout: 'fit',
            region: 'center',
            bodyStyle: {background: '#dfe8f6'},
            buttonAlign: 'left',
            trackResetOnLoad: true, //reset to the last loaded record
            defaults: {
                border: false
            },
            items: [{
                    xtype: 'tabpanel',
                    activeTab: 0,
                    bodyStyle: {background: '#dfe8f6'},
                    items: [
                        this.paramPanel,
                        this.ttPanel

                    ],
                    listeners: {
                        tabchange: function(tabPanel, newCard, oldCard, eOpts) {
                            var saveBtn = this.down('#save-download');
                            saveBtn.setDisabled(newCard != this.paramPanel);
                        },
                        scope: this
                    }
                    },
                   ],

            fbar: [
                {
                    text: 'Download',
                    scope: this,
                    handler: function (button) {
                        // if the return is true (object had been updated)
                        if (this.updateObject()) {
                            // launch the download process 			        
                            this.doDownload();
                        }
                    }
                },
                {
                    text: 'Reset',
                    scope: this,
                    handler: function () {

                        var downModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
                        downModule.createLinkedNode();
                        var obj = null;
                        downModule.createObject(obj);
                        this.setObject(downModule.linkedNode.get('object'));

                    }
                },

                {
                    text: 'Save',

                    id: 'save-download',

                    scope: this,
                    handler: function () {
                        this.saveRequest();
                    }
                },

                '->',
                {
                    xtype: 'sendToSampButton',
                    type: 'votable',
                    onSendToSamp: this.onSendVOTableToSamp,
                    sendOpt: {scope: this}
                }]
        });

        var myConf = {
            layout: 'border',
            items: [
                this.formPanel,
                {
                    xtype: 'panel',
                    region: 'south',
                    title: 'Information',
                    collapsible: true,
                    collapseMode: 'header',
                    height: 100,
                    autoHide: false,
                    bodyStyle: 'padding:5px',
                    iconCls: 'icon-information',
                    loader: {
                        autoLoad: true,
                        url: helpDir + 'downloadHOWTO'
                    }
                }
            ],
            plugins: [{ptype: 'paramArgumentsPlugin', pluginId: 'download-param-arguments-plugin'}]
        };

        Ext.apply(this, Ext.apply(arguments, myConf));
    }

});