//Ext-Js config
Ext.BLANK_IMAGE_URL = getAppRoot() + '/Scripts/ext/resources/images/default/s.gif';

Ext.QuickTips.init();

var originalBlur = Ext.form.TextField.prototype.onBlur;
var originalTextboxRender = Ext.form.TextField.prototype.onRender;
var originalTextboxKeyDown = Ext.form.TextField.prototype.onKeyDown;
var originalDateFieldRender = Ext.form.DateField.prototype.onRender;
var originalComboBoxRender = Ext.form.ComboBox.prototype.onRender;
var originalComboBoxSetDisabled = Ext.form.ComboBox.prototype.setDisabled;
var originalComboBoxSetVisible = Ext.form.ComboBox.prototype.setVisible;
var originalLoadRecord = Ext.form.BasicForm.prototype.loadRecord;
var originalReset = Ext.form.BasicForm.prototype.reset;
var originalTreeClick = Ext.tree.TreePanel.prototype.onClick;
var originalSetRenderer = Ext.grid.ColumnModel.prototype.setRenderer;
var originalCheckboxRender = Ext.form.Checkbox.prototype.onRender;
var originalFieldsetRender = Ext.form.FieldSet.prototype.onRender;
var originalGridRenderer = Ext.grid.GridPanel.prototype.onRender;
var originalFormRenderer = Ext.form.FormPanel.prototype.onRender;

Ext.override(Ext.PagingToolbar, {
    refresh: function()
    {
        delete this.store.lastParams;
        this.doLoad(this.cursor);
    }
});

Ext.override(Ext.data.Store, {
    loadStore: function(store)
    {
        if (!store)
        {
            return;
        }
        
        this.removeAll();

        for (ic = 0; ic < store.getCount(); ic++)
        {
            this.add(store.getAt(ic));
        }

    }
});

Ext.override(Ext.Toolbar, {
    lock: function()
    {
        for (it = 0; it < this.items.length; it++)
        {
            var item = this.items.itemAt(it);
            if (item.getXType() == "button")
            {
                item.setDisabled(true);
            }
        }
        this.locked = true;
    },

    upadateButtons: function(record)
    {
        for (iu = 0; iu < this.items.length; iu++)
        {
            var item = this.items.itemAt(iu);
            if (item.getXType() == "button")
            {
                if (item.alwaysEnable)
                {
                    item.setDisabled(false);
                    this.locked = false;
                }
                else
                {
                    item.setDisabled(record == null);
                    if (record)
                    {
                        this.locked = false;
                    }
                }
            }
        }
    }
});

Ext.override(Ext.grid.GridPanel, {
    lock: function()
    {
        var selModel = this.getSelectionModel();

        if (selModel)
        {
            selModel.lock();
            this.showPadlock(true);
        }

        this.locked = true;

        this.lockToolBar();
    },

    unlock: function()
    {
        var selModel = this.getSelectionModel();

        if (selModel)
        {
            selModel.unlock();
            this.showPadlock(false);
        }

        this.locked = false;

        this.updateToolBar();
    },

    lockToolBar: function()
    {
        var tbar = this.getTopToolbar();
        if (tbar)
        {
            tbar.lock();
        }
    },

    updateToolBar: function()
    {
        var tbar = this.getTopToolbar();
        if (tbar)
        {
            if (!this.locked)
            {
                tbar.upadateButtons(this.getSelectedRecord());
            }
        }
    },

    showPadlock: function(value)
    {
        var padlock = Ext.getCmp(this.id + '-gridPadlock');

        if (padlock)
        {
            padlock.setVisible(value);
        }
    },

    autoSizeColumns: function(headerOnly)
    {
        autoSizeColumns(this, headerOnly);
    },

    onRender: function()
    {
        if (this.locked)
        {
            this.lock();
        }

        originalGridRenderer.apply(this, arguments);
    }
});

Ext.override(Ext.form.TextField, {
    onBlur: function()
    {
        if (this.letterCase != undefined)
        {
            switch (this.letterCase)
            {
                case "upper":
                    this.setValue(this.getValue().toUpperCase());
                    break;

                case "lower":
                    this.setValue(this.getValue().toLowerCase());
                    break;

                case "proper":
                    this.setValue(Client.ToProperCase(this.getValue()));
                    break

                default:
                    break;
            }
        }

        // call default TextField blur
        originalBlur.apply(this, arguments);
    },

    onRender: function()
    {
        this.enableKeyEvents = true;
        
        if (this.readOnly)
        {
            this.style = "border: none; background: none;";
        }

        originalTextboxRender.apply(this, arguments);
    },

    onKeyDown: function(e)
    {
        if (e.keyCode == 13)
        {
            if (this.onEnterKey)
            {
                this.onEnterKey.call(this, this);
            }
        }

        originalTextboxKeyDown.apply(this, arguments);
    }
});

Ext.override(Ext.form.DateField, {
    onRender: function()
    {
        if (this.readOnly)
        {
            this.hideTrigger = true;
            this.style = "border: none; background: none;";
        }

        originalDateFieldRender.apply(this, arguments);
    }
});

Ext.override(Ext.form.Checkbox, {
    onRender: function()
    {
        originalCheckboxRender.apply(this, arguments);

        if (this.readOnly)
        {
            this.getEl().dom.onclick = function()
            {
                return false;
            }
        }
    }
});

Ext.override(Ext.form.FormPanel, {
    onRender: function()
    {
        if (this.locked)
        {
            this.getForm().lock();
        }

        originalFormRenderer.apply(this, arguments);
    }
});

Ext.override(Ext.grid.ColumnModel, {
    isCellEditable: function(col, row)
    {
        return !this.getColumnAt(col).readonly;
    },

    setRenderer: function(col, fn)
    {
        var colId;

        try
        {
            colId = parseInt(col);
        }
        catch (e)
        {
        }

        if (isNaN(colId))
        {
            colId = this.findColumnIndex(col);
        }

        col = colId;

        originalSetRenderer.apply(this, arguments);
    },

    setIconRenderer: function(col, fn)
    {
        var renderer = function(v, p, record, rowIndex)
        {
            className = fn(record);

            return '<div class="' + className + '" style="width: 20px; background-position: left; height: 16px;"></div>';
        };

        this.setRenderer(col, renderer);
    },

    getColumn: function(index)
    {
        var colId = this.getColumnId(col);
        var col = this.getColumnById(colId);

        return col;
    }
});

Ext.override(Ext.form.BasicForm, {
    clear: function()
    {
        for (ib = 0; ib < this.items.length; ib++)
        {
            var item = this.items.itemAt(ib);

            if (item.getXType() == 'combobox')
            {
                item.clearValue();
            }
            else
            {
                item.setValue(null);
            }

            if (!this.ignoreChanges)
            {
                if (item.onClear)
                {
                    item.onClear.call(this);
                }
            }
        }
    },

    lock: function()
    {
        for (il = 0; il < this.items.length; il++)
        {
            var item = this.items.itemAt(il);
            item.setDisabled(true);
        }

        this.locked = true;
    },

    unlock: function()
    {
        for (ibu = 0; ibu < this.items.length; ibu++)
        {
            var item = this.items.itemAt(ibu);
            item.setDisabled(false);
        }

        if (this.boundFieldSets)
        {
            for (fs = 0; fs < this.boundFieldSets.length; fs++)
            {
                var fieldset = this.boundFieldSets[fs];
                fieldset.unlock();
            }
        }

        this.locked = false;
    },

    loadImageFields: function(record)
    {
        for (ii = 0; ii < this.items.length; ii++)
        {
            var field = this.items.itemAt(ii);
            if (field.xtype == "xImage")
            {
                var value = record.get(field.name);
                if (value)
                {
                    if (field.el.dom.children.length == 0)
                    {
                        var img = document.createElement("img");
                        field.el.dom.appendChild(img);
                    }
                    var src = getAppRoot() + "/" + value;
                    field.el.dom.children[0].src = src;
                }
                else
                {
                    if (field.el.dom.children.length == 1)
                    {
                        field.el.dom.children[0].src = null;
                    }
                }
            }
        }
    },

    loadRecord: function(record)
    {
        this.record = record;
        this.ignoreChanges = true;
        this.unlock();
        this.clear();

        originalLoadRecord.apply(this, arguments);

        this.loadImageFields(record);

        var basicForm = this;
        var listenToChanges = function()
        {
            basicForm.ignoreChanges = false;
        }

        listenToChanges.defer(200);

        if (this.boundFieldSets)
        {
            for (fs = 0; fs < this.boundFieldSets.length; fs++)
            {
                var fieldset = this.boundFieldSets[fs];
                fieldset.lock();
            }
        }
    },

    reset: function()
    {
        this.ignoreChanges = true;
        originalReset.apply(this, arguments);
        this.ignoreChanges = false;

        if (this.boundFieldSets)
        {
            for (fs = 0; fs < this.boundFieldSets.length; fs++)
            {
                var fieldset = this.boundFieldSets[fs];
                fieldset.reset();
            }
        }
    },

    loadItem: function(item)
    {
        this.ignoreChanges = true;
        this.unlock();
        this.clear();

        for (ii = 0; ii < this.items.length; ii++)
        {
            var field = this.items.itemAt(ii);
            if (field.name != undefined)
            {
                if (item[field.name] != undefined)
                {
                    field.setValue(item[field.name]);
                }
                else
                {
                }
            }
        }

        var basicForm = this;
        var listenToChanges = function()
        {
            basicForm.ignoreChanges = false;
        }

        listenToChanges.defer(200);
    },

    getInvalidFields: function()
    {
        invalidFields = [];
        for (vf = 0; vf < this.items.length; vf++)
        {
            var field = this.items.itemAt(vf);
            if (!field.isValid())
            {
                field.validate();
                invalidFields[invalidFields.length] = field.fieldLabel ? field.fieldLabel : field.name;
            }
        }

        return invalidFields;
    }
});

Ext.override(Ext.tree.TreePanel, {
    doublelClickInterval: 50,
    onClick: function(node)
    {
        if (this.onDblClick)
        {
            var d = new Date();

            if (this.lastClick)
            {
                if (d.getDay() = this.lastClick.getDay())
                {
                    if (d.getHours() = this.lastClick.getHours())
                    {
                        if (this.lastClick.getMilliseconds() >= (d.getMilliseconds() - this.doublelClickInterval))
                        {
                            this.onDblClick.call(this, arguments);
                        }
                    }
                }
            }
        }

        //call default Tree click
        originalTreeClick.apply(this, arguments);
    }
});

Ext.override(Ext.form.ComboBox, {
    setStore: function(store)
    {
        if (!store)
        {
            return;
        }

        var comboStore = this.getStore();

        comboStore.removeAll();

        for (ic = 0; ic < store.getCount(); ic++)
        {
            comboStore.add(store.getAt(ic));
        }

        // Update value
        this.setValue(this.getValue());
    },

    selectByValue: function(value)
    {
        var store = this.getStore();

        for (recIndex = 0; recIndex < store.getCount(); recIndex++)
        {
            var rec = store.getAt(recIndex);
            if (rec.get(this.valueField) == value)
            {            
                this.setValue(value);

                break;
            }
        }
    },

    onRender: function()
    {
        if (this.readOnly)
        {
            this.hideTrigger = true;
            this.style = "border: none; background: none;";
        }

        if (this.onEnterKey)
        {
            this.enableKeyEvents = true;
        }

        originalComboBoxRender.apply(this, arguments);
    },

    setDisabled: function(value)
    {
        originalComboBoxSetDisabled.apply(this, arguments);

        this.validate();
    },

    setVisible: function(value)
    {
        originalComboBoxSetVisible.apply(this, arguments);

        this.validate();
    }

});

Ext.override(Ext.form.FieldSet, {
    clear: function()
    {
        for (iff = 0; iff < this.items.length; iff++)
        {
            var item = this.items.itemAt(iff);

            if (item.getXType() == 'grid')
            {
                continue;
            }
            else if (item.getXType() == 'combobox')
            {
                item.clearValue();
            }
            else
            {
                item.setValue(null);
            }

            if (!this.ignoreChanges)
            {
                if (item.onClear)
                {
                    item.onClear.call(this);
                }
            }
        }
    },

    reset: function()
    {
        for (iff = 0; iff < this.items.length; iff++)
        {
            var item = this.items.itemAt(iff);

            if (item.getXType() == 'grid')
            {
                if (item.getStore())
                {
                    item.getStore().removeAll();
                }
            }
            else if (item.getXType() == 'combobox')
            {
                item.clearValue();
            }
            else
            {
                item.setValue(null);
            }

            if (!this.ignoreChanges)
            {
                if (item.onClear)
                {
                    item.onClear.call(this);
                }
            }
        }

        this.lock();

        if (this.boundGrid)
        {
            this.boundGrid.lock();
        }
    },

    lock: function()
    {
        for (ill = 0; ill < this.items.length; ill++)
        {
            var item = this.items.itemAt(ill);
            if (item.getXType() == 'grid')
            {
                if (this.boundGrid)
                {
                    if (item == this.boundGrid)
                    {
                        continue;
                    }
                    else
                    {
                        item.lock();
                    }
                }
                else
                {
                    item.lock();
                }
            }
            else
            {
                item.setDisabled(true);
            }
        }

        this.locked = true;
    },

    unlock: function()
    {
        for (iuu = 0; iuu < this.items.length; iuu++)
        {
            var item = this.items.itemAt(iuu);
            if (item.getXType() == 'grid')
            {
                item.unlock();
            }
            else
            {
                item.setDisabled(false);
            }
        }

        this.locked = false;
    },

    loadItem: function(item)
    {
        this.ignoreChanges = true;
        this.unlock();
        this.clear();

        for (io = 0; io < this.items.length; io++)
        {
            var field = this.items.itemAt(i);
            if (field.name != undefined)
            {
                if (item[field.name] != undefined)
                {
                    field.setValue(item[field.name]);
                }
            }
        }

        var fieldSet = this;
        var listenToChanges = function()
        {
            fieldSet.ignoreChanges = false;
        }

        listenToChanges.defer(200);
    },

    loadRecord: function(record)
    {
        this.record = record;
        this.ignoreChanges = true;
        this.unlock();
        this.clear();

        for (ir = 0; ir < this.items.length; ir++)
        {
            var field = this.items.itemAt(ir);
            if (field.name != undefined)
            {
                var datafield;
                if (field.boundValueField)
                {
                    datafield = field.boundValueField;
                }
                else
                {
                    datafield = field.name;
                }

                if (record.data[datafield] != undefined)
                {
                    field.setValue(record.data[datafield]);
                }
            }
        }

        var fieldSet = this;
        var listenToChanges = function()
        {
            fieldSet.ignoreChanges = false;
        }

        listenToChanges.defer(200);
    },

    setBoundGrid: function(grid)
    {
        this.boundGrid = grid;

        for (ig = 0; ig < this.items.length; ig++)
        {
            var item = this.items.itemAt(ig);
            item.grid = grid;
            item.fieldSet = this;

            if (item.getXType() == 'grid')
            {
                continue;
            }

            if (item.getXType() == "combo")
            {
                item.addListener("select", function(combo, record, index)
                {
                    if (record)
                    {
                        var gridRecord = combo.grid.getSelectedRecord();

                        if (!gridRecord)
                        {
                            return;
                        }

                        gridRecord.set(combo.boundValueField, record.get(combo.valueField));
                        gridRecord.set(combo.boundDisplayField, record.get(combo.displayField));

                    }
                });

                item.addListener("change", function(combo, newValue, oldValue)
                {
                    var gridRecord = combo.grid.getSelectedRecord();

                    if (!gridRecord)
                    {
                        return;
                    }

                    gridRecord.set(combo.boundValueField, newValue);
                    gridRecord.set(combo.boundDisplayField, combo.lastSelectionText);
                });
            }
            else if (item.getXType() == "textfield")
            {
                item.onEnterKey = function(textfield)
                {
                    var gridRecord = textfield.grid.getSelectedRecord();

                    if (!gridRecord)
                    {
                        return;
                    }

                    gridRecord.set(textfield.name, textfield.getValue());
                }

                item.addListener("change", function(textfield, newValue, oldValue)
                {
                    var gridRecord = textfield.grid.getSelectedRecord();

                    if (!gridRecord)
                    {
                        return;
                    }

                    gridRecord.set(textfield.name, newValue);
                })
            }
            else
            {
                item.addListener("change", function(control)
                {
                    var gridRecord = control.grid.getSelectedRecord();

                    if (!gridRecord)
                    {
                        return;
                    }

                    gridRecord.set(control.name, control.getValue());
                })
            }
        }
    },

    onRender: function()
    {
        if (this.boundForm)
        {
            var form = Ext.getCmp(this.boundForm);
            var basicForm = form.getForm();

            if (!basicForm.boundFieldSets)
            {
                basicForm.boundFieldSets = [];
            }

            basicForm.boundFieldSets[basicForm.boundFieldSets.length] = this;
        }

        if (this.items)
        {
            for (ir = 0; ir < this.items.length; ir++)
            {
                var field = this.items.itemAt(ir);
                if (field.name != undefined)
                {
                    field.fieldset = this;
                }
            }
        }

        originalFieldsetRender.apply(this, arguments);
    },

    onUpdate: function()
    {
        if (this.boundForm)
        {
            var form = Ext.getCmp(this.boundForm);
            form.showToolbar(true);
        }
    }
});

function autoSizeColumns(grid, headerOnly)
{     
    var store = grid.getStore();
    var colModel = grid.getColumnModel();
    var view = grid.getView();
    var width = 0;
    var totalWidth = 0;

    if (!store || !colModel)
    {
        return;
    }

    var colCount = colModel.getColumnCount();
    var rowCount = store.getCount();
    var lastColIndex = 0;

    for (colIndex = 0; colIndex < colCount; colIndex++)
    {        
        if (colModel.isFixed(colIndex) || colModel.isHidden(colIndex))
        {
            continue;
        }
        else
        {
            lastColIndex = colIndex;

            var el = view.getHeaderCell(colIndex).firstChild;
            el.style.width = '0px';
            width = el.scrollWidth;
            el.style.width = 'auto';

            if (headerOnly)
            {
                if (colModel.getColumnWidth(colIndex) < width)
                {
                    colModel.setColumnWidth(colIndex, width + 18);
                }
                continue;
            }

            for (rowIndex = 0; rowIndex < rowCount; rowIndex++)
            {
                el = view.getCell(rowIndex, colIndex).firstChild;
                el.style.width = '0px';
                width = Math.max(width, el.scrollWidth);
                el.style.width = 'auto';
            }
        }

        if (colModel.getColumnWidth(colIndex) < width)
        {
            colModel.setColumnWidth(colIndex, width + 8);
        }

        totalWidth += width;
    }

    // Autoexpand last column
    var colId = colModel.getColumnId(lastColIndex);
    grid.autoExpandColumn = colId;    
    
    view.refresh();
}

function renderBool(val)
{
    var checkedImg = getAppRoot() + '/Scripts/ext/resources/images/default/menu/checked.gif';
    var uncheckedImg = getAppRoot() + '/Scripts/ext/resources/images/default/menu/unchecked.gif';
    var cb = ''
            + '<div style="text-align:center;height:13px;overflow:visible">'
            + '<img style="vertical-align:-3px" src="'
            + (val ? checkedImg : uncheckedImg)
            + '"'
            + ' />'
            + '</div>'
        ;
    return cb;
}

Ext.ns("Ext.ux.util");
Ext.ux.util.MoveProperties = function(src, dest, properties)
{
    for (var i = 0, len = properties.length; i < len; i++)
    {
        var property = properties[i];
        if (typeof (src[property]) != 'undefined')
        {
            dest[property] = src[property];
            delete src[property];
        }
    }
    return;
};


Ext.ux.Image = function(config)
{
    var c = config || {};
    Ext.applyIf(c, {
        autoEl: { tag: 'img' }
    });

    // Transfer src, width, height to autoEl
    Ext.ux.util.MoveProperties(c, c.autoEl, ["src", "width", "height"]);

    Ext.ux.Image.superclass.constructor.call(this, c);
}

Ext.extend(Ext.ux.Image, Ext.form.Field, {
    onRender: function()
    {
        Ext.form.Label.prototype.onRender.apply(this, arguments);
    }
});

Ext.reg('xImage', Ext.ux.Image);