Ext.namespace("Kalitte", "Kalitte.Dashboards.API");

var nVer = navigator.appVersion;
var nAgt = navigator.userAgent;
var browserName = '';
var fullVersion = 0;
var lazyDestroyTimeout = 15000;
var majorVersion = 0;
var isAttached = false;
var InAjaxCall = false;
var WidgetAutoRefreshList = new Array();
var editorUrl = '/France/WidgetEditor.aspx';
var widgetMaximizeUrl = '/France/WidgetMaximize.aspx';
var autoMaskTarget = null;
var autoMaskMessage = null;

var msg_Refreshing = 'Refreshing ...';
var msg_Applying = 'Applying ...';
var msg_LoadingEditor = 'Loading editor ...';
var msg_EditTitle = 'Click to edit title';
var msg_CloseWidgetQuestion = 'Close ?';
var msg_Loading = '#{msg_Loading}';
var cmd_Maximize = 'Maximize';
var msg_Maximizing = 'Maximizing ...';
var msg_Restoring = 'Restoring ...';
var msg_ChangeWidgetTitleHeader = 'Change Title';
var msg_ChangeWidgetTitleLabel = 'New Title:';
var msg_Confirm = '#{msg_Confirm}';
var msg_WidgetEditorTitle = '';


var PageRequestManager = null;
var isDashboardAjaxCall = false;
var tabClosed = false;



function waDestroy(ref) {
    destroyWidgetContext(ref);
}


function destroyWidgetContext(widget) {
    if (widget.ddClientContext) {
        widget.ddClientContext.destroy();
        delete widget.ddClientContext;
    }
}

function getWidgetContext(widgetId) {
    var widget = Ext.getCmp(widgetId);
    var context = widget.ddClientContext;
    return context;
}

function initializeWidgetContext(widgetId, modulePath, domNodeId, params) {
    var widget = Ext.getCmp(widgetId);
    destroyWidgetContext(widget);
    var moduleParams = params || {};



    require([modulePath], function (moduleClass) {
        try {
            var domNode = document.getElementById(domNodeId);

            function createContext(domNode) {
                var contextObj = new WidgetContext(widget);
                moduleParams.context = contextObj;
                var moduleObject = new moduleClass(domNode, moduleParams);
                contextObj.userModule = moduleObject;
                widget.ddClientContext = contextObj;
            }


            createContext(domNode);

        } catch (e) {
            alert(e.message);
        }

    }, function (err) {
        alert("Error loading module from " + modulePath + " msg:" + err.message);
        debugger;
    });
}

function WidgetContext(widget) {
    this.widget = widget;
    var dashboard = widget.ownerCt.ownerCt ? widget.ownerCt.ownerCt : widget.ownerCt;
    var self = this;
    if (dashboard)
        dashboard.addListener("drop", function (e) {
            if (self.ondrop && e.panel == self.widget)
                self.ondrop.apply(self, arguments);
        });

    if (dashboard)
        dashboard.addListener("beforedrop", function (e) {
            if (self.onbeforedrop && e.panel == self.widget)
                return self.onbeforedrop.apply(self, arguments);
        });


    this.destroy = function () {
        if (this.userModule.destroyRecursive)
            this.userModule.destroyRecursive();
    }

    this.sendCommand = function (name, args, maskMsg) {
        var props = {};
        props['commandName'] = name;
        props['msg'] = maskMsg;
        props['commandArg'] = args;
        return doWidgetCmd(null, props, null, this.widget);
    }

    this.callModule = function (method) {
        var fn = this.userModule[method];
        if (!fn)
            alert(method + " doesnot exist on client module");
        var args = Array.prototype.slice.call(arguments, 1);
        fn.apply(this.userModule, args);
    }
}


if ((verOffset = nAgt.indexOf("MSIE")) != -1) {
    browserName = "Microsoft Internet Explorer";
    fullVersion = parseFloat(nAgt.substring(verOffset + 5));
    majorVersion = parseInt('' + fullVersion);
}

else if ((verOffset = nAgt.indexOf("Opera")) != -1) {
    browserName = "Opera";
    fullVersion = parseFloat(nAgt.substring(verOffset + 6));
    majorVersion = parseInt('' + fullVersion);
}

else if ((verOffset = nAgt.indexOf("Firefox")) != -1) {
    browserName = "Firefox";
    fullVersion = parseFloat(nAgt.substring(verOffset + 8));
    majorVersion = parseInt('' + fullVersion);
}

else if ((nameOffset = nAgt.lastIndexOf(' ') + 1) < (verOffset = nAgt.lastIndexOf('/'))) {
    browserName = nAgt.substring(nameOffset, verOffset);
    fullVersion = parseFloat(nAgt.substring(verOffset + 1));
    if (!isNaN(fullVersion)) majorVersion = parseInt('' + fullVersion);
    else { fullVersion = 0; majorVersion = 0; }
}

if (browserName.toLowerCase() == browserName.toUpperCase()
 || fullVersion == 0 || majorVersion == 0) {
    browserName = navigator.appName;
    fullVersion = parseFloat(nVer);
    majorVersion = parseInt(nVer);
}

if (browserName != "Microsoft Internet Explorer") {
    HTMLAnchorElement.prototype.click = function () {
        var evt = window.document.createEvent('MouseEvents');
        evt.initMouseEvent('click', true, true, this.ownerDocument.defaultView, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
        this.dispatchEvent(evt);
    }
}


Kalitte.Dashboards.API.showWidgetHeaders = function (props) {
    var portal = Ext.getCmp(props["dashboardId"]);
    for (var col = 0; col < portal.items.items.length; col++)
        for (var p = 0; p < portal.items.items[col].items.items.length; p++) {
            var portlet = portal.items.items[col].items.items[p];
            if (portlet.header)
                portlet.header.show();
        }
}

Kalitte.Dashboards.API.hideWidgetHeaders = function (props) {
    var portal = Ext.getCmp(props["dashboardId"]);
    for (var col = 0; col < portal.items.items.length; col++)
        for (var p = 0; p < portal.items.items[col].items.items.length; p++) {
            var portlet = portal.items.items[col].items.items[p];
            if (portlet.header && portlet.header != false)
                portlet.header.hide();
        }
}

Kalitte.Dashboards.API.Window = function (id) {
    var window = Ext.getCmp(id);
    if (window)
        window.show();
}

function doAjaxClick(e) {
    if (isDashboardAjaxCall)
        return;
    isDashboardAjaxCall = true;
    var el = document.getElementById(e);
    var postId = e.replace(/_/g, '$');
    if (el && browserName != "Firefox")
        el.click();
    else
        __doPostBack(postId, '');


}


Kalitte.Dashboards.API.MaximizeTool = function (cfg) {
    Ext.apply(this, { config: cfg });
    this.init = function (ct) {
        var maximizeTool = {
            id: 'maximize',
            handler: handleMaximize,
            scope: ct,
            //qtip: cmd_Maximize  //EARTHSOFT: localized in EQuIS
        };
        ct.tools = ct.tools || [];
        var newTools = ct.tools.slice();
        ct.tools = newTools;
        for (var i = 0, len = ct.tools.length; i < len; i++) {
            if (ct.tools[i].id == 'maximize') return;
          }
      
        //**EARTHSOFT: put maximize before close
        if (ct.tools.length > 0 && ct.tools[ct.tools.length - 1].id == 'close') {
          ct.tools[ct.tools.length] = ct.tools[ct.tools.length - 1];
          ct.tools[ct.tools.length - 2] = maximizeTool;
        }
        else {
          ct.tools[ct.tools.length] = maximizeTool;
        }
        //**
        ct.maximizeConfig = this.config;
    };

    function sendEvent(w, cmd, message, args) {
        if (w.maximizeConfig.notify == 'true') {
            var props = { commandName: cmd, msg: message, commandArg: args };
            doWidgetCmd(null, props, null, w);
        }
    }

    function handleMaximize(event, toolEl, panel) {
        var openInNewWindow = panel.widgetConfig["maximizeMode"] == "external";

        if (panel.header != false && !openInNewWindow)
            panel.header.setDisplayed('none');
        panel.originalOwnerCt = panel.ownerCt;
        panel.originalPosition = panel.ownerCt.items.indexOf(panel);
        panel.originalSize = panel.getSize();
        panel.originalHeader = panel.header;
        var openInNewWindow = panel.widgetConfig["maximizeMode"] == "external";

        if (!openInNewWindow) {
            for (var i = 0; i < panel.toolbars.length; i++)
                panel.toolbars[i].hide();
        }
        var dashboard = panel.ownerCt.ownerCt.ownerCt;
        var dashBox = dashboard.getBox();
        var html = document.documentElement;

        var height = html.clientHeight - 15;
        var winHeight = panel.maximizeConfig.height == '0' ? height : parseInt(panel.maximizeConfig.height);
        var winWidth = panel.maximizeConfig.width == '0' ? dashBox.width - 15 : parseInt(panel.maximizeConfig.width);
        var win = null;

        if (!win) {
            var maximizePageUrl = widgetMaximizeUrl + "?ID=" + panel.widgetConfig["instanceKey"] + "&w=" + (winWidth - 18).toString() + "&h=" + (winHeight - 36).toString() + "&R=" + Math.random() * 100;
            var defaultConfig = {
                id: (panel.getId() + '-MAX'),
                width: winWidth,
                height: winHeight,
                resizable: true,
                draggable: true,
                closable: true,
                closeAction: 'hide',
                hideBorders: true,
                plain: true,
                layout: 'fit',
                modal: true,
                title: panel.title,
                iconCls: panel.iconCls,
                maximizable: false,
                animateTarget: dashboard.id,
                bodyStyle: 'background-color: #ffffff;',
                autoLoad: openInNewWindow ? {
                    showMask: msg_Maximizing ? true : false,
                    url: maximizePageUrl,
                    mode: 'iframe',
                    maskMsg: msg_Maximizing
                } : null
            };

            win = new Ext.Window(defaultConfig);
            win.on('hide', handleMinimize, panel);
            win.on("beforeshow",
                                        function (el) {

                                        });
            win.on("maximize", function (el) {
                this.setPosition(document.body.scrollLeft, document.body.scrollTop);
                if (openInNewWindow) {
                    var v = Ext.getBody().getViewSize();
                    el.setSize(v.width, v.height);
                }
            });
        }
        if (!openInNewWindow) {
            if (!panel.dummyComponent) {
                var dummyCompConfig = {
                    title: panel.title,
                    width: panel.getSize().width,
                    height: panel.getSize().height,
                    html: '&nbsp;'
                };
                panel.dummyComponent = new Ext.Panel(dummyCompConfig);
            }

            win.add(panel);
            if (panel.toolsDisplayed != null)
                doMouseEnterLeaveOnWidgetHeader(this, false);
            panel.maximized = true;

            sendEvent(this, 'maximized', msg_Maximizing, { width: win.width - 18, height: win.height - 36 });
            panel.originalOwnerCt.insert(panel.originalPosition, panel.dummyComponent);
            panel.originalOwnerCt.doLayout();
            panel.dummyComponent.setSize(panel.originalSize);
            panel.dummyComponent.setVisible(true);
        }
        win.show(this);
    };

    function handleMinimize(window) {
        var openInNewWindow = this.widgetConfig["maximizeMode"] == "external";
        if (!openInNewWindow) {
            this.dummyComponent.setVisible(false);
            this.originalOwnerCt.insert(this.originalPosition, this);
            this.maximized = false;
            for (var i = 0; i < this.toolbars.length; i++)
                this.toolbars[i].show();
            this.originalOwnerCt.doLayout();
            this.setSize(this.originalSize);
            if (this.originalHeader != false)
                this.originalHeader.setDisplayed('block');
            var box = this.originalPosition;
            sendEvent(this, 'restored', msg_Restoring, { width: box.width, height: box.height });

        }
        window.destroy();
    }
}

function editorWindow(e, props, widget) {
    var pageUrl = editorUrl + "?ID=" + widget.widgetConfig['instanceKey'] + "&R=" + Math.random() * 100;
    var handler = props["editorHandle"];
    if (handler) {
        props["editorUrl"] = pageUrl;
        handler(props, widget);
    }
    else {
        
      //**EARTHSOFT: allow "full screen" by setting editor size to 0x0
      // copied from handleMaximize, assumes dashboard is full page width

      // make sure values are integers
      props.commandArg['height'] = parseInt(props.commandArg['height']);
      props.commandArg['width'] = parseInt(props.commandArg['width']);

      //could use $('#DashboardSurface_db')[0].clientHeight/clientWidth to match dashboard
      var html = document.documentElement;
      var editorHeight = html.clientHeight - 100;
      var editorWidth = html.clientWidth - 100;

      // use client size if zero or too large
      props.commandArg['height'] = props.commandArg['height'] == 0 || props.commandArg['height'] > editorHeight ? editorHeight : props.commandArg['height'];
      props.commandArg['width'] = props.commandArg['width'] == 0 || props.commandArg['width'] > editorWidth ? editorWidth : props.commandArg['width'];
     
      // update the URL to pass the width and height
      pageUrl = pageUrl + "&w=" + (props.commandArg['width'] - 18).toString() + "&h=" + (props.commandArg['height'] - 36).toString();
      //**

        win = new Ext.Window(
                            {
                                layout: 'fit',
                                width: props.commandArg['width'],
                                height: props.commandArg['height'],
                                closeAction: 'close',
                                plain: false,
                                bodyStyle: 'background-color: #ffffff;',
                                modal: true,
                                title: props.commandArg['title'],
                                maximizable: false,
                                padding: 5,
                                resizable: false,
                                animateTarget: props['widgetId'],
                                autoLoad: {
                                    showMask: msg_LoadingEditor ? true : false,
                                    url: pageUrl,
                                    mode: 'iframe',
                                    maskMsg: msg_LoadingEditor
                                }

                            });
        win.on("maximize",
                                        function (el) {
                                            var v = Ext.getBody().getViewSize();
                                            el.setSize(v.width, v.height);
                                        });

        win.on("beforeshow",
                                        function (el) {
                                            el.alignTo(Ext.getBody(), "c-c");
                                        });
        win.on("beforeclose", function (el) {
            EnableAutoRefresh(props['widgetId']);
            var iFrame = win.body.first();
            delete (iFrame);
            window.EditorWindow = null;
        });

        win.Props = props;
        win.widget = widget;
        window.EditorWindow = win;
        window.EditorWindow.show();
    };
}



function AutoRefreshData(key, timerId, props) {
    this.InstanceKey = key;
    this.data = new Object();
    this.data.timerId = timerId;
    this.data.props = props;
}

function GetAutoRefreshIndex(key) {
    var index = -1;

    for (var i = 0; i < WidgetAutoRefreshList.length; i++)
        if (WidgetAutoRefreshList[i] != null && WidgetAutoRefreshList[i].InstanceKey == key) {
            index = i;
            break;
        }

    return index;
}

function RemoveAutoRefresh(index) {
    if (WidgetAutoRefreshList[index] == null)
        return;
    clearInterval(WidgetAutoRefreshList[index].data.timerId);
    WidgetAutoRefreshList[index] = null;
}

function ClearAllAutoRefresh() {
    for (var i = 0; i < WidgetAutoRefreshList.length; i++)
        RemoveAutoRefresh(i);
    WidgetAutoRefreshList = new Array();
}

function DisableAutoRefresh(key) {
    var index = GetAutoRefreshIndex(key);
    if (index >= 0)
        WidgetAutoRefreshList[index].enabled = false;
}

function EnableAutoRefresh(key) {
    var index = GetAutoRefreshIndex(key);
    if (index >= 0)
        WidgetAutoRefreshList[index].enabled = true;
}

function AutoRefreshEnabled(key) {
    var index = GetAutoRefreshIndex(key);
    if (index >= 0)
        return WidgetAutoRefreshList[index].enabled = !false;
    else return false;
}

function CreateAutoRefresh(props) {
    var key = props["widgetId"];
    var handler = function () { AutoRefreshHandler(key, props); };
    var index = GetAutoRefreshIndex(key);
    var interval = props["interval"];

    if (index >= 0) {
        if (interval <= 0)
            RemoveAutoRefresh(index);
        else if (interval != WidgetAutoRefreshList[index].data.props["interval"]) {
            RemoveAutoRefresh(index);
            if (interval > 0) {
                var timerId = setInterval(handler, interval);
                var obj = new AutoRefreshData(key, timerId, props);
                WidgetAutoRefreshList.push(obj);
            }
        }
    }
    else
        if (interval > 0) {
            var timerId = setInterval(handler, interval);
            var obj = new AutoRefreshData(key, timerId, props);
            WidgetAutoRefreshList.push(obj);
        }
}

function createAutoMask(target, msg) {
    autoMaskTarget = target;
    autoMaskMessage = msg;
}

function createMaskForObject(extObj, msg) {
    createAutoMask(extObj.el.dom, msg == null ? msg_Loading : msg);
}

function clearAutoMask() {
    autoMaskTarget = null;
    autoMaskMessage = null;
}

function AutoRefreshHandler(key, props) {
    props['commandName'] = 'refresh';
    var widget = Ext.getCmp(props["widgetId"]);
    if (typeof (widget) == "undefined")
        return;
    if (InAjaxCall) {
        var func = function () { AutoRefreshHandler(key, props); };
        setTimeout(func, 1000);
    } else if (AutoRefreshEnabled(key) && window.EditorWindow == null) {
        try {
            DisableAutoRefresh(key);
            props['autoRefreshCall'] = true;
            doWidgetCmd(null, props);
        } finally {
            EnableAutoRefresh(key);
        }
    }
}


function CommandData(commandName, arguments, argumentsSerialized) {
    this.CommandName = commandName;
    this.Arguments = arguments;

}

function menuItemCheckHandler(e, props, checked, serverHandler) {
    props.commandArg["checked"] = checked;
    serverHandler(e, props);
}

function createWidgets(e, props) {
    var treeInstance = Ext.getCmp(props.commandArg['treeId']);
    var menuBtn = Ext.getCmp(props.commandArg['menuBtnId']);

    var selNodes = treeInstance.getChecked();
    var msg = "";
    Ext.each(selNodes, function (node) {
        if (msg.length > 0) {
            msg += ",";
        }

        msg += node.id;
    });
    props.commandArg = { widgetList: msg, sectionKey: props.commandArg['sectionKey'], rowId: props.commandArg['rowId'] };
    if (msg.length > 0) {
        menuBtn.hideMenu();
        doHostCommand(e, props);
    }
}

function closeTab(e, props) {
    tabClosed = true;
    doHostCommand(e, props);
    var dashboard = Ext.getCmp(props.commandArg['surfaceId']);
    //if (dashboard)
    Ext.net.ResourceMgr.destroyCmp(props.commandArg['surfaceId']);

}

function changeTab(e, props) {
    props.commandArg['activeTabTitle'] = e.activeTab.title;
    //if (!tabClosed)
    doHostCommand(e, props);
    tabClosed = false;

}


function doHostCommand(e, props) {
    var controller = props['hostId'] + "_Controller";
    var commandName = props['commandName'];
    var target = document.getElementById(props['hostId']);
    var loadMsg = props['msg'];
    var commandData = null;
    switch (commandName) {
        case 'close':
            {
                if (InAjaxCall != true) {
                    if (props.commandArg["confirmClose"] == true) {
                        Ext.MessageBox.confirm(msg_Confirm, msg_CloseWidgetQuestion, function (e) {
                            if (e == "yes") {
                                var w = Ext.getCmp(props.commandArg['widgetId']);
                                commandData = new CommandData('closeDone', { widgetId: w.id });
                                doServerCommand(controller, props['hostId'] + '_Command', commandData);
                                w.hide();
                                var widget = Ext.getCmp(props.commandArg['widgetId']);
                                Ext.net.ResourceMgr.destroyCmp(props.commandArg['widgetId']);
                            }
                        });
                    } else {
                        var w = Ext.getCmp(props.commandArg['widgetId']);
                        commandData = new CommandData('closeDone', { widgetId: w.id });
                        doServerCommand(controller, props['hostId'] + '_Command', commandData);
                        w.hide();
                        var tFunc = function () { Ext.net.ResourceMgr.destroyCmp(props.commandArg['widgetId']) };
                        if (props.commandArg['lazyDestroy'] != null && props.commandArg['lazyDestroy'].toLowerCase() == 'true')
                            setTimeout(tFunc, lazyDestroyTimeout);
                        else tFunc();

                    }
                }
                break;
            }
        case 'drag':
            {
                commandData = new CommandData('dragDone', { widgetId: e.panel.id, dashboardKey: props.commandArg['dashboardKey'], rowId: props.commandArg['rowId'], columnIndex: e.columnIndex, position: e.position });
                window.currentPortal = e.portal;
                doServerCommand(controller, props['hostId'] + '_Command', commandData);
                break;
            }
        default:
            {
                commandData = new CommandData(commandName, props.commandArg);
                doServerCommand(controller, props['hostId'] + '_Command', commandData, target, loadMsg);
                break;
            }
    }
}

function doWidgetCmd(e, props, extraData, w) {
    var widget = w;
    if (widget == null)
        widget = Ext.getCmp(props['widgetId']);
    if (typeof (widget) == 'undefined')
        return;
    var commandField = document.getElementById(widget.widgetConfig['widgetId'] + 'Command');
    var controller = widget.widgetConfig["widgetId"] + "Controller";

    var target = widget.el.dom;
    var commandData = null;
    var commandName = props['commandName'];
    var msg = props['msg'];
    switch (commandName) {
        case 'refresh':
            {
                commandData = new CommandData(commandName, props.commandArg);
                msg = msg_Refreshing;
                break;
            }
        case 'edit':
            {
              //** EARTHSOFT: force the widget editor title to localized string
              props.commandArg['title'] = msg_WidgetEditorTitle;
              
                props['target'] = target;
                editorWindow(e, props, widget);
                break;
            }
        case 'collapse':
            {
                commandData = new CommandData(commandName, props.commandArg);
                msg = '';
                break;
            }
        case 'expand':
            {
                commandData = new CommandData(commandName, props.commandArg);
                msg = '';
                break;
            }

        default:
            {
                commandData = new CommandData(commandName, props.commandArg);
                break;
            }
    }
    if (commandData != null) {
        doServerCommand(controller, widget.widgetConfig["widgetId"] + 'Command', commandData, target, msg);
    }
}



function doServerCommand(controllerFieldName, commandFieldName, commandData, target, msg) {
    var commandField = document.getElementById(commandFieldName);
    commandField.value = Ext.encode(commandData);
    if (msg != '' && msg != null) {
        setLoadMask(target, msg);
    }
    doAjaxClick(controllerFieldName);
}

function getMaskObjIndex(id) {
    var index = -1, list = window.widgetMasks;

    for (var i = 0; i < list.length; i++)
        if (list[i] != null && list[i].el.id == id) {
            index = i;
            break;
        }

    return index;
}

function getMaskObj(el) {
    var index = getMaskObjIndex(el.id);
    if (index < 0)
        return null;
    else return window.widgetMasks[index];
}

function setLoadMask(target, msg) {
    if (isAttached) {

        if (window.widgetMasks == null)
            window.widgetMasks = new Array();

        var currentMask = getMaskObj(target);

        if (currentMask != null)
            currentMask.hide();
        else {
            currentMask = new Ext.LoadMask(target);
            currentMask.msg = msg;
            window.widgetMasks.push(currentMask);
        }
        window.currentMask = currentMask;
    }
}



function changeWidgetTitle(e, props) {
    Ext.MessageBox.prompt(msg_ChangeWidgetTitleHeader, msg_ChangeWidgetTitleLabel, function (btn, text) {
        if (btn == "ok" && e.innerText != text && text != "") {
            var controller = props['widgetId'] + "Controller";
            var commandField = props['widgetId'] + "Command";
            e.innerHTML = text;
            doServerCommand(controller, commandField, new CommandData('changeTitle', { title: text }), null, null);
        }
    }, null, false, e.innerHTML);
}


function widgetTitleClicked(e) {
    if (!e) var e = window.event;
    if (e != null) {
        var sp = e.target || e.srcElement;
        changeWidgetTitle(sp, { widgetId: sp.widgetId });
    }
}

function XBrowserAddHandler(target, eventName, handlerName) {
    if (target.addEventListener)
        target.addEventListener(eventName, handlerName, false);
    else if (target.attachEvent)
        target.attachEvent("on" + eventName, handlerName);
    else
        target["on" + eventName] = handlerName;
}



function waRender(ref, e) {
    if (ref.widgetConfig["readonly"] != true && e.header && ref.widgetConfig["titleEditable"] != false) {
        var sp = e.el.dom.getElementsByTagName('span')[0];
        sp.style.cursor = "pointer";
        sp.title = msg_EditTitle;
        sp.onclick = widgetTitleClicked;
        sp.widgetId = ref.widgetConfig["widgetId"];
    }

    if (ref.header != false) {
        if (ref.widgetConfig['autoHideHeader'] == 1) {
            if (ref.collapsed == false)
                ref.header.setDisplayed('none');
            ref.el.dom.__owner = ref;
            if (browserName == "Microsoft Internet Explorer") {
                XBrowserAddHandler(ref.el.dom, "mouseenter", function () { widgetMouseEnter(ref) });
                XBrowserAddHandler(ref.el.dom, "mouseleave", function () { widgetMouseLeave(ref) });
            } else {
                XBrowserAddHandler(ref.el.dom, "mouseover", function () { widgetMouseEnter(ref) });
                XBrowserAddHandler(ref.el.dom, "mouseout", function () { widgetMouseLeave(ref) });
            }
        }
        if (ref.widgetConfig['autoHideTools'] == true) {
            doMouseEnterLeaveOnWidgetHeader(ref, false);
            if (browserName == "Microsoft Internet Explorer") {
                XBrowserAddHandler(ref.header.dom, "mouseenter", function () { widgetHeaderMouseEnter(ref) });
                XBrowserAddHandler(ref.header.dom, "mouseleave", function () { widgetHeaderMouseLeave(ref) });
                XBrowserAddHandler(ref.el.dom, "mouseenter", function () { widgetHeaderMouseEnter(ref) });
                XBrowserAddHandler(ref.el.dom, "mouseleave", function () { widgetHeaderMouseLeave(ref) });


            } else {
                XBrowserAddHandler(ref.header.dom, "mouseover", function () { widgetHeaderMouseEnter(ref) });
                XBrowserAddHandler(ref.header.dom, "mouseout", function () { widgetHeaderMouseLeave(ref) });
                XBrowserAddHandler(ref.el.dom, "mouseover", function () { widgetHeaderMouseEnter(ref) });
                XBrowserAddHandler(ref.el.dom, "mouseout", function () { widgetHeaderMouseLeave(ref) });
            }
        }

    }
}

function doMouseEnterLeaveOnWidget(widget, enter) {
    if (!widget || widget.header == false || widget.maximized)
        return;
    var style = enter ? 'block' : 'none';
    if (!widget.collapsed && widget.header.dom.style.display != style) {
        widget.header.setDisplayed(style);
    }
}



var widgetMouseEnter = function (w, e) {
    doMouseEnterLeaveOnWidget(w, true);

}

var widgetMouseLeave = function (w, e) {
    doMouseEnterLeaveOnWidget(w, false);

}

function doMouseEnterLeaveOnWidgetHeader(widget, enter) {
    if (!widget || widget.header == false || widget.maximized)
        return;
    widget.tools = widget.tools || [];
    for (var tool in widget.tools)
        widget.getTool(tool).setVisible(enter);
    widget.toolsDisplayed = enter;
}

var widgetHeaderMouseEnter = function (w, e) {
    doMouseEnterLeaveOnWidgetHeader(w, true);

}

var widgetHeaderMouseLeave = function (w, e) {
    doMouseEnterLeaveOnWidgetHeader(w, false);

}

function getninMouseOverWidget(e) {
    if (!e) var e = window.event;
    var tg = (window.event) ? e.srcElement : e.target;
    var dom = null;

    while (typeof (tg.parentElement) != "undefined" && typeof (tg.__owner) == "undefined") {
        tg = tg.parentElement;
    }

    if (typeof (tg.__owner) != "undefined")
        return tg.__owner;
    else return null;
}



var widgetBodyResize = function (params, width, iheight, e) {
    var wId = params['widgetId'];
    var widget = Ext.getCmp(wId);
    var controller = wId + "Controller";
    var commandField = wId + "Command";
    var calculatedHeight = iheight;
    if (widget.header != false)
        calculatedHeight = iheight + widget.header.getHeight()
    if (params['save'])
        doServerCommand(controller, commandField, new CommandData('resize', { height: calculatedHeight }), null, null);
    widget.setHeight(calculatedHeight);
};


function onActivatePortalTab(item, b) {
    var p = Ext.getCmp(b);
    if (p)
        p.doLayout();
}

function WidgetDropInfo(instance, columnIndex, position, widgetInstance) {
    this.dashboardInstance = instance;
    this.columnIndex = columnIndex;
    this.position = position;
    this.widgetInstance = widgetInstance.substring(widgetInstance.length - 32);
}

function validateWidgetDrop(e, instance, handler) {
    if (InAjaxCall)
        return false;
    var widgetDashboard = e.data.panel.widgetConfig['dashboardKey'];
    if (widgetDashboard != instance) {
        e.status = false;
    } else {
        var dropInfo = new WidgetDropInfo(instance, e.columnIndex, e.position, e.data.panel.id);
        if (handler && typeof (handler) != 'undefined' && !handler(dropInfo)) {
            e.status = false;
        }
    }
    return e.status;
}


function doLayoutWithContent(el, id) {
    var control = Ext.getCmp(id);
    if (typeof (control) != 'undefined')
        control.doLayout();
}

function animatePanelBody(id, animation) {
    try {
        var body = Ext.getCmp(id).body;
        eval("body." + animation);
    } catch (err) {
    }
}


function ShowMasks() {
    var result = null;
    if (autoMaskMessage != null && autoMaskTarget != null)
        setLoadMask(autoMaskTarget, autoMaskMessage);

    if (!window.widgetMasks)
        return;

    for (var i = 0; i < window.widgetMasks.length; i++) {
        var mask = window.widgetMasks[i];
        mask.show();
        if (window.currentMask == mask)
            result = window.currentMask.el.id;
    }

    return result;
}

function HideMasks(list) {
    if (!list)
        return;
    for (var i = 0; i < list.length; i++) {
        var mask = list[i];
        mask.hide();
    }
}

function KillMask(id) {
    if (id) {
        var index = getMaskObjIndex(id);
        if (index >= 0) {
            if (window.widgetMasks) {
                if (window.widgetMasks[index].el.id == id) {
                    window.widgetMasks[index].hide();
                    window.widgetMasks.splice(index, 1);
                }
            }
        }
    }
}

function BeginRequestHandler(sender, args) {
    InAjaxCall = true;

    //if (isDashboardAjaxCall)
    PageRequestManager._scrollPosition = null;

    var elId = args.get_postBackElement().id;
    var searchStr = 'db';
    var isInWidget = elId.indexOf(searchStr);

    if (isInWidget > 0) {
        var parts = elId.split('_');
        var wid = "";
        for (i = 0; i < parts.length; i++) {
            wid = wid + parts[i] + '_';
            if (parts[i] == searchStr) {
                if (parts.length > i + 3) {
                    wid = wid + parts[i + 1];
                    break;
                } else {
                    wid = "";
                    break;
                }
            }
        }
        if (wid != "") {
            var widget = Ext.getCmp(wid);
            if (widget != null && typeof (widget.widgetConfig['postbackMsg']) != 'undefined') {
                setLoadMask(widget.el.dom, widget.widgetConfig['postbackMsg']);
                //args._request._dashboardContext = wid;
            }
        }
    }
    var id = ShowMasks();
    if (id) {
        args._request._dashboardContext = id;
    }
}

function columnResize(props, rwidth, width, height, resizecol, portal) {
    var portalWidth = portal.body.getWidth();
    var colCount = portal.items.items.length;


    if (rwidth > portalWidth - (colCount * portalWidth * 0.05))
        rwidth = Math.round(portalWidth - (colCount * portalWidth * 0.05));

    if (rwidth < portalWidth * 0.05)
        rwidth = Math.round(portalWidth * 0.05);

    var sizeRatio = Math.round((rwidth / portalWidth) * 100) / 100;
    var othersRatio = Math.round((1.00 - resizecol.columnWidth) * 100) / 100;
    var newRatio = Math.round((1.00 - sizeRatio) * 100) / 100;
    resizecol.columnWidth = sizeRatio;
    var total = 0.00;
    for (var col = 0; col < portal.items.items.length; col++) {
        var column = portal.items.items[col];
        if (column.id != resizecol.id) {
            column.columnWidth = Math.round((column.columnWidth * (newRatio / othersRatio)) * 100) / 100;
        };
        if (col == portal.items.items.length - 1)
            column.columnWidth = Math.round((1.00 - total) * 100) / 100;
        else total = Math.round((total + column.columnWidth) * 100) / 100; ;
        column.setWidth(Math.round(column.columnWidth * portalWidth));
        column.doLayout();
        var resc = eval(column.columnrz);
        if (typeof (resc) != 'undefined') {
            resc.minWidth = portalWidth * 0.05;
            resc.maxWidth = Math.round(portalWidth - (colCount * portalWidth * 0.05));
        }
        props.commandArg["col" + col] = column.columnWidth;
    }

    portal.doLayout();
    if (props.save) {
        props['commandName'] = 'resizeColumn';
        doHostCommand(null, props);
    }
    return false;
}

function dashboardRowRender(item) {
    for (var col = 0; col < item.items.items.length; col++) {
        var column = item.items.items[col];
        if (typeof (column.columnrz) != 'undefined') {
            var resizer = Ext.getCmp(column.columnrz);
            //resizer.
        }
    }
}





function EndRequestHandler(sender, args) {
    InAjaxCall = false;
    clearAutoMask();

    var id = null;

    if (typeof (args._response._webRequest._dashboardContext) != 'undefined')
        id = args._response._webRequest._dashboardContext;

    KillMask(id);

    if (args.get_error() != undefined)
        HideMasks(window.widgetMasks);

    window.currentPortal = null;
    isDashboardAjaxCall = false;
}

function attachWidgetHandlers() {
    PageRequestManager = Sys.WebForms.PageRequestManager.getInstance();
    PageRequestManager.add_beginRequest(BeginRequestHandler);
    PageRequestManager.add_endRequest(EndRequestHandler);
    isAttached = true;

}


(function () {

    var DomReady = window.DomReady = {};

    // Everything that has to do with properly supporting our document ready event. Brought over from the most awesome jQuery. 

    var userAgent = navigator.userAgent.toLowerCase();

    // Figure out what browser is being used
    var browser = {
        version: (userAgent.match(/.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/) || [])[1],
        safari: /webkit/.test(userAgent),
        opera: /opera/.test(userAgent),
        msie: (/msie/.test(userAgent)) && (!/opera/.test(userAgent)),
        mozilla: (/mozilla/.test(userAgent)) && (!/(compatible|webkit)/.test(userAgent))
    };

    var readyBound = false;
    var isReady = false;
    var readyList = [];

    // Handle when the DOM is ready
    function domReady() {
        // Make sure that the DOM is not already loaded
        if (!isReady) {
            // Remember that the DOM is ready
            isReady = true;

            if (readyList) {
                for (var fn = 0; fn < readyList.length; fn++) {
                    readyList[fn].call(window, []);
                }

                readyList = [];
            }
        }
    };

    // From Simon Willison. A safe way to fire onload w/o screwing up everyone else.
    function addLoadEvent(func) {
        var oldonload = window.onload;
        if (typeof window.onload != 'function') {
            window.onload = func;
        } else {
            window.onload = function () {
                if (oldonload) {
                    oldonload();
                }
                func();
            }
        }
    };

    // does the heavy work of working through the browsers idiosyncracies (let's call them that) to hook onload.
    function bindReady() {
        if (readyBound) {
            return;
        }

        readyBound = true;

        // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
        if (document.addEventListener && !browser.opera) {
            // Use the handy event callback
            document.addEventListener("DOMContentLoaded", domReady, false);
        }

        // If IE is used and is not in a frame
        // Continually check to see if the document is ready
        if (browser.msie && window == top) (function () {
            if (isReady) return;
            try {
                // If IE is used, use the trick by Diego Perini
                // http://javascript.nwbox.com/IEContentLoaded/
                document.documentElement.doScroll("left");
            } catch (error) {
                setTimeout(arguments.callee, 0);
                return;
            }
            // and execute any waiting functions
            domReady();
        })();

        if (browser.opera) {
            document.addEventListener("DOMContentLoaded", function () {
                if (isReady) return;
                for (var i = 0; i < document.styleSheets.length; i++)
                    if (document.styleSheets[i].disabled) {
                        setTimeout(arguments.callee, 0);
                        return;
                    }
                // and execute any waiting functions
                domReady();
            }, false);
        }

        if (browser.safari) {
            var numStyles;
            (function () {
                if (isReady) return;
                if (document.readyState != "loaded" && document.readyState != "complete") {
                    setTimeout(arguments.callee, 0);
                    return;
                }
                if (numStyles === undefined) {
                    var links = document.getElementsByTagName("link");
                    for (var i = 0; i < links.length; i++) {
                        if (links[i].getAttribute('rel') == 'stylesheet') {
                            numStyles++;
                        }
                    }
                    var styles = document.getElementsByTagName("style");
                    numStyles += styles.length;
                }
                if (document.styleSheets.length != numStyles) {
                    setTimeout(arguments.callee, 0);
                    return;
                }

                // and execute any waiting functions
                domReady();
            })();
        }

        // A fallback to window.onload, that will always work
        addLoadEvent(domReady);
    };

    // This is the public function that people can use to hook up ready.
    DomReady.ready = function (fn, args) {
        // Attach the listeners
        bindReady();

        // If the DOM is already ready
        if (isReady) {
            // Execute the function immediately
            fn.call(window, []);
        } else {
            // Add the function to the wait list
            readyList.push(function () { return fn.call(window, []); });
        }
    };

    bindReady();

})();

DomReady.ready(function () {
    attachWidgetHandlers();
});