if (window.addEventListener) window.addEventListener("load", dynamicStartup, false);
else if (window.attachEvent) window.attachEvent("onload", dynamicStartup);

var portletInitialized;

var dpiEnabledPortlets = [];

VignettePortal.DynamicAJAXClient = function() {}

VignettePortal.DynamicAJAXClient.prototype = {
	formHandler : function (form, dpiOff) {
		try {
			var action = form.action;
			action = this.URLDecode(action);
			// Have to extract the state from the javascript.
			var portletURLPattern = /portletURL\(\s*({.*})\)/g;
			var portletURLExp = new RegExp(portletURLPattern);
			var matches = portletURLExp.exec(action);
			var actionState = null;
			var portlet  = null;
			if (matches != null) {
				actionState = eval('('+matches[1]+')');
				if (actionState != null) {
					portlet = dpiEnabledPortlets[actionState.targetUID];
				}
			}
			if (dpiOff == "undefined" || dpiOff == undefined) {
				dpiOff = false;
			}

			// Find the targeted portlet
			if (portlet != undefined && portlet != null && !dpiOff) {
				portlet.submitForm(form,actionState);
			} else {
				var url = form.action;
				var elements;
				if (actionState != null) {
					url = this.buildRenderURL(actionState, null);
					elements = pExt.DomQuery.select("input[name=vgnDPIButSub" + actionState.targetUID + "]", form);
					form.action = url;
				}
				if (elements != undefined && elements.length > 0) {
					var submitTracker = elements[0];
					// if form submission is on same page then only remove the hiddden variable details from the form.
					if (form.target == '_self' || form.target == '_top') {
						form.removeChild(submitTracker);
					}
				}
				form.submit();
			}
		} catch (err) {
			alert(err);
		}
		return false;
	},

	parseRPIURL : function (url, dpiOff) {
			var decodedURL = this.URLDecode(url);
		var portletURLPattern = /portletURL\(\s*({.*})\)/g;
		var portletURLExp = new RegExp(portletURLPattern);
		var matches = portletURLExp.exec(decodedURL);
		var actionState = null;
		var returnURL = url;
		try {
			if (matches != null) {
				actionState = eval('('+matches[1]+')');
				if (actionState != null) {
					var templateToUse = null ;
					if (dpiOff == "undefined") {
						dpiOff = false;
					}
					if (!isRenderedInDirectMode(actionState.targetState, actionState.urlType, actionState.pageParams) && (!dpiOff)) {
							templateToUse = this.getTemplateToUse(actionState.baseURL) ;
					}
					returnURL = this.buildRenderURL(actionState,templateToUse);
				}
			}
		} catch (err) {
			alert("Error: " + err);
			return url;
		}
		return returnURL;
	},

	updateTheAttrOfElement : function (replace,nodes,attributeName,pattern,pos,newValueFormat) {
		if (nodes == undefined || nodes == null || attributeName == undefined || attributeName == null) {
			return ;
		}
		var retArray = new Array();
		for(var i=0; i<nodes.length; i++){
			var attrValue = nodes[i].getAttribute(attributeName);
			if(attrValue != null && attrValue.length > 0){
				var posPattern = attrValue.indexOf(pattern);
				if (pos > -1 && posPattern == pos || pos < 0 && posPattern > -1) {
					var startIndex = posPattern + pattern.length;
					if (replace) {
						attrValue = attrValue.substring(startIndex,attrValue.indexOf(')'));
						attrValue = this.URLDecode(attrValue);
						var state =  eval('('+attrValue+')');
						var newValue = this.buildRenderURL(state, null) ;
						if (newValueFormat != undefined || newValueFormat != null) {
							newValue = newValueFormat.replace('#replace#',newValue);
						}
						nodes[i].setAttribute(attributeName,newValue);
					} else {
						retArray[retArray.length] = nodes[i];
					}
				}
			}
		}
		return retArray;
	},

	scanPortletDivForJScriptPopUp : function (portletDiv) {
		try {
			var popupRef = pExt.DomQuery.select("a[href*=javascript:doPopup]",portletDiv);
			var displayRef = pExt.DomQuery.select("a[href*=javascript:displayWindow]",portletDiv);
			pattern = 'javascript:portletURL(';
			var valuePatternPopUp = 'javascript:doPopup("#replace#")';
			var valuePatternDisplay = 'javascript:displayWindow("#replace#")';
			this.updateTheAttrOfElement(true,popupRef,'href',pattern,-1,valuePatternPopUp);
			this.updateTheAttrOfElement(true,displayRef,'href',pattern,-1,valuePatternDisplay);
		}  catch (err) {
			alert("Error: scanPortletDivForJScriptPopUp : " + err);
		}
	},

	scanPortletDivForImg : function (portletDiv) {
		try {
			var pattern = 'javascript:portletURL(';
			var images = pExt.DomQuery.select('img[src*=javascript:portletURL]',portletDiv);
			this.updateTheAttrOfElement(true,images,'src',pattern,0);
		}  catch (err) {
			alert("Error: scanPortletDivForImg : " + err);
		}

	},

	getPortletUIDFromURL : function (baseURL) {
		var uri = baseURL;
		var porletToRemove = "portletToRemove";
		var index1 = baseURL.indexOf(porletToRemove);
		var len = porletToRemove.length;
		var uid = uri.substring(index1 + len + 1);
		return uid;
	},

	buildRenderURL : function (params, template) {
		var base = params.baseURL;
		var tpst = params.tpst;
		var targetParams = params.targetParams;
		var pageParams = params.pageParams;
		var beginToken = params.BEGIN_CACHE_TOKEN;
		var endToken = params.END_CACHE_TOKEN;

		if(template!=null) {
			base = base.replace(/template\.\w*/g, 'template.'+template);
		}
		var ret = base;

		if (tpst != null) {
			if(base.indexOf("?")!=-1) {
				ret = ret + "&" + tpst;
			} else {
				ret = ret + "?" + tpst;
			}
		}

		if(pageParams != null && pageParams.length>0) {
			var tp = "";
			var first = true;

			for(var i=0;i<pageParams.length;i++) {
				if(first)
					first = false;
				else
					tp = tp + "&";
				var idx = pageParams[i].indexOf("=");
				var name = pageParams[i].substring(0, idx);
				var value = pageParams[i].substring(idx+1);

				tp = tp + name + "=" + this.URLEncode(value);
			}
			ret = ret + "&" + tp;
		}

		if(targetParams != null && targetParams.length>0) {
			var tp = "";
			var first = true;

			for(var i=0;i<targetParams.length;i++) {
				if(first)
					first = false;
				else
					tp = tp + "&";
				var idx = targetParams[i].indexOf("=");
				var name = targetParams[i].substring(0, idx);
				var value = targetParams[i].substring(idx+1);

				tp = tp + name + "=" + this.URLEncode(value);
			}
			ret = ret + "&" + tp;
		}

		if (beginToken != null && endToken != null) {
			ret = ret + "&" + beginToken;
			ret = ret + "&" + endToken;
		}

		return ret;
	},

	getTemplateToUse : function (baseURL) {
		var templateToUse ;
		if (isMyPageURL(baseURL)) {
			templateToUse = 'MY_PAGES_DYNAMIC';
		} else {
			templateToUse = 'DYNAMIC';
		}
		return templateToUse;

	},

	URLDecode : function (encodedString) {
		var output = '';
		var x = 0;
		var parseStr = encodedString.toString();
		var regex = /(%[^%]{2})/;
		while (x < encodedString.length) {
			parseStr = encodedString.substring(x);
			var match = regex.exec(parseStr);
			if (match != null && match.length > 1 && match[1] != '') {
				binVal = parseInt(match[1].substr(1),16);
				newValue = String.fromCharCode(binVal);
				output += parseStr.substring(0,match.index) + newValue;
				x += match.index + match[1].length;
			} else {
				output += parseStr;
				break;
			}
		}
		return output;
	},

	URLEncode : function (clearString) {
		var output = '';
		var x = 0;
		clearString = clearString.toString();
		var regex = /(^[a-zA-Z0-9_.]*)/;
		while (x < clearString.length) {
			var match = regex.exec(clearString.substr(x));
			if (match != null && match.length > 1 && match[1] != '') {
				output += match[1];
				x += match[1].length;
			} else {
				if (clearString[x] == ' ')
					output += '+';
				else {
					var charCode = clearString.charCodeAt(x);
					var hexVal = charCode.toString(16);
					output += '%' + ( hexVal.length < 2 ? '0' : '' ) + hexVal.toUpperCase();
				}
				x++;
			}
		}
		return output;
	}

};

/**
 * This method is called when the portlet loads.  Its job is to find all the portlets on the page, create a portlet
 * object for that portlet and initialize the state of the portlet object.  For each portlet object we set the
 * containing div, the portlet state, and the UID of the portlet.   We also scan the HTML of the portlet for any
 * forms.  For any forms found we add an onsubmit handler so that we can capture the form submission process and
 * send it back to Portal through an AJAX request.
 */
function dynamicStartup() {
    try {
	    if (!isdefined('portletInitialized')) {
            // find the portlets on the page as per the orientation on page
		    if (isdefined('portletLayout')) {
                portletDivs = pExt.select('div.epi-modDrgTable').elements;
		    } else {
                portletDivs = pExt.select('div.epi-modDrg').elements;
		    }

		    for (var i = 0; i < portletDivs.length; i++) {
			    if (!isdefined('portletInitialized')) {
				    portletInitialized = true;
			    }
		        var uid = portletDivs[i].getAttribute("uid");
		        // extract render state from portlet rendering.  This is placed here from the insertportletrenderingtag
		        var s = eval('( window.portletState'+uid+')');
		        if (s != undefined && s != null) {
		            dpiEnabledPortlets[uid] = new Portlet(uid, portletDivs[i]);
		            dpiEnabledPortlets[uid].state = s;
		            scanPortletForms(portletDivs[i]);
		        }
		    }
	    }
    } catch (err) {
        alert("Error: " + err);
    }
}


/**
 * This is the function that is called from within the rendered portlet URLs
 * (i.e. <A HREF="javascript:portletURL(...)">)
 * @param params state information
 */
function portletURL(params) {
	var portlet ;
    var removeAction = false;
    if (params.targetUID != undefined) {
        portlet = dpiEnabledPortlets[params.targetUID];
    } else {
        var targetUID = new VignettePortal.DynamicAJAXClient().getPortletUIDFromURL(params.baseURL);
        if (targetUID != undefined) {
            portlet = dpiEnabledPortlets[targetUID];
            removeAction = true;
        }
    }
    // render or action?
    if(portlet != undefined) {
        if (params.urlType == 'action') {
            portlet.submitActionLink(params,removeAction);
        } else {
            if (isRenderedInDirectMode(params.targetState,params.urlType,params.pageParams)) {
                renderInDirectMode(params);
            } else {
                var wasMaximized = false ;
                if (portlet.state.targetState == 'maximized') {
                    wasMaximized = true ;
                }
                portlet.state = params;
                portlet.reRender(wasMaximized);
            }
        }
    } else {
       // due to some reason if dynamicStartup isn't invoked - we will allow it to work
       // in non ajax mode
       var url = new VignettePortal.DynamicAJAXClient().buildRenderURL(params,null);
       submitURLDirectly(url);
    }
}

/**
 * Portlet object.  We create one per portlet on the page.
 * @param uid
 * @param divNode
 */
function Portlet(uid, divNode) {
    this.uid = uid;
    this.divNode = divNode;
    this.divNodeId = this.divNode.id;
    this.state = null;
    this.divPosInfo = null;
}

/**
 * SizeOfPanel object. It'll save the width of the panel to
 * restore the portlet back to normal state from maximised state.
 */
function SizeOfPanel(width) {
    this.widthOfPanel = width;
}

/**
*  THis structure holds the information of various div tags that are hidden during
*  maximized operation
*/
function DivPosInfo(curDivider,allDividers,divInDivider,divInPanel) {
   this.curDivider = curDivider;
   this.AllDividers = allDividers;
   this.divInDivider = divInDivider;
   this.divInPanel = divInPanel;
}

/**
 * Method on the portlet object that is called when the portlet needs to be re-rendered.  Uses its current state
 * to get a URL to use for AJAX call to get current rendering.  On the AJAX callback it replaces its rendering in
 * its DIV container.
 */
Portlet.prototype.reRender = function(wasMaximized) {
    var url;
	var vapDynamic = new VignettePortal.DynamicAJAXClient();
	if (isMyPageURL(this.state.baseURL)) {
        url = vapDynamic.buildRenderURL(this.state, 'MY_PAGES_DYNAMIC');
    } else if(this.state.baseURL.indexOf("/resolver.") != -1) {
        url = vapDynamic.buildRenderURL(this.state, 'PAGE');
        return;
    } else {
        url = vapDynamic.buildRenderURL(this.state, 'DYNAMIC');
    }
    var div = this.divNode;
    var uid = this.uid;
    var curPortlet = this;
    var mask = new pExt.LoadMask(div);
    mask.msg = '...';
    mask.show();
    new VignettePortal.AJAXClient().sendURL(url, function(resp) {
        var responseText = resp.responseText;
        curPortlet.renderResponseHandler(responseText,wasMaximized);
        mask.hide();
    });
}

Portlet.prototype.renderResponseHandler = function(responseText,wasMaximized,fromFormSubmit) {
	var div = this.divNode;
	var uid = this.uid;
	var curPortlet = this;
	var origHTMLContent = responseText;
	var stateInfo = null ;
	var updateDivLater = false ;
	if (origHTMLContent != null) {
		origHTMLContent = trim(origHTMLContent);
		if (origHTMLContent.indexOf("<body><script") == 0) {
			updateDivLater = true;
		}
		var refreshURL = identifyMetaRefresh(origHTMLContent);
		if (refreshURL != null) {
			if (refreshURL.indexOf("javascript:portletURL") == 0) {
				refreshURL = new VignettePortal.DynamicAJAXClient().parseRPIURL(refreshURL, true);
			}
			submitURLDirectly(refreshURL);
			return;
		}
	}
	if (!updateDivLater) {
		div.innerHTML = origHTMLContent;
	}
	new VignettePortal.AJAXClient().addScripts(origHTMLContent);
	returnedState = eval('( window.portletState'+uid+')');

	if (returnedState.isRedirect != undefined && returnedState.isRedirect) {
		var mask = new pExt.LoadMask(div);
		mask.msg = '...';
		mask.show();
		if (curPortlet.uid == returnedState.targetUID) {
			curPortlet.state = returnedState ;
			curPortlet.reRender(wasMaximized);
			mask.hide();
			return;
		} else {
			renderInDirectMode(returnedState);
			mask.hide();
			return;
		}
	} else if (fromFormSubmit  != undefined && fromFormSubmit) {
		curPortlet.state = returnedState ;
	}
	if (updateDivLater) {
		div.innerHTML = origHTMLContent;
	}
	if ((wasMaximized == undefined || (!wasMaximized)) && returnedState.targetState == 'maximized') {
		curPortlet.handleMaximize();
	}

	if (wasMaximized != undefined && wasMaximized && (returnedState.targetState == 'normal' ||
													  returnedState.targetState == 'minimized')) {
		curPortlet.restoreNormalState(true);
	}

	for(var o in returnedState.nonTargetParams) {
		var nonTargetInfo = returnedState.nonTargetParams[o];
		var p = dpiEnabledPortlets[o];
		if (p != undefined && nonTargetInfo.length != 0) {
			if (trim(nonTargetInfo[0]) != '') {
				p.state.targetParams = nonTargetInfo;
				p.reRender();
			}
		}
	}
	if (isdefined('PageLayout')) {
		PageLayout.render();
	}
	scanPortletForms(div);
}

function identifyMetaRefresh(htmlContent) {
	metaTagPattern = /<META[^>]*?HTTP-EQUIV="Refresh"[^>]*?URL=([^"]*?)\"/gi
	metaPatternExp = new RegExp(metaTagPattern);
	var matches = metaPatternExp.exec(htmlContent);
	if (matches != null) {
		return matches[1] ;
	}
	return null ;
}

/**
*   This method is called to submit the url at page level rather through AJAX call
*/
function renderInDirectMode(params) {
    var url = new VignettePortal.DynamicAJAXClient().buildRenderURL(params, null);
    submitURLDirectly(url);
}

/**
*  This method is called to determine how the url should be submitted
*/
function isRenderedInDirectMode(state, urlType, pageParams) {
    if (state == "raw" || state == "solo" || state == "binary" || urlType == 'resource' || urlType == 'resolver' || (pageParams != null && pageParams.length > 0)) {
        return true;
    } else {
        return false;
    }
}

/**
*  return true if the page accessed if of my page type
*/
function isMyPageURL(baseURL) {

    if(baseURL.indexOf("template.MY_PAGES_")!=-1) {
        return true ;
    } else {
        return false;
    }
}

function trim(str) {
   return str.replace(/(^[\s\xA0]+|[\s\xA0]+$)/g, '');
}

/**
* This method is called to handle maximizing the portlet.
*/
Portlet.prototype.handleMaximize = function() {
    if (isdefined('typeOfOrientation')) {
        if (typeOfOrientation == "row") {
            this.handleMaxInRowMode();
        } else if (typeOfOrientation == "column") {
            this.handleMaxInColumnMode();
        } else if (typeOfOrientation == "table") {
            this.handleMaxInTableMode();
        }
        window.scrollTo(0, 0);
    }
}
/**
* This method is called to restore a maximized portlet into normal state
*/
Portlet.prototype.restoreNormalState = function(reRenderPage) {
    if (isdefined('typeOfOrientation')) {
        if(typeOfOrientation == "row") {
            this.restoreNormalInRowMode();
        } else if (typeOfOrientation == "column") {
            this.restoreNormalInColumnMode();
        } else if (typeOfOrientation == "table") {
            this.restoreNormalInTableMode();
        }
        if (reRenderPage != undefined && reRenderPage && typeOfOrientation != "table") {
            PageLayout.render();
        }
    }
}

/**
* This method is called to handle maximizing the portlet when portlet placement layout is
* displayed in column mode
*/
Portlet.prototype.handleMaxInColumnMode = function() {
    var curDivide ;
    var curRow;
    var curPanel ;
    var moduleDiv ;
    var curOrgDivider = null ;
    var allDivider = new Array();
    var divInDivider = new Array();
    var divInPanel = new Array();

    if (isdefined('Panels')) {
        var gotPanel = false ;
        for(j = 0 ; j < Panels.length && (!gotPanel); j++) {
            for (k = 0; k < Panels[j].rows.length; k++) {
                if(this.divNodeId == Panels[j].rows[k].id) {
                    moduleDiv = Panels[j].rows[k];
                    curPanel = Panels[j];
                    curDivide = Panels[j].parent.parent;
                    gotPanel = true;
                    break;
                }
            }
        }
    }
    for (k = 0; k < Dividers.length ; k++) {
        if(curDivide.id == Dividers[k].id) {
            allDivider[allDivider.length] = Dividers[k].copyObject();
        } else {
            allDivider[allDivider.length] = Dividers[k];
        }
    }
    var curRowFound = false ;

    for (k = 0; k < curDivide.rows.length ; k++) {
        var row = curDivide.rows[k];
        for (j = 0 ; j < row.columns.length && (!curRowFound) ; j++) {
            if(curPanel.id == row.columns[j].id) {
                curRow = row;
                break;
            }
        }
        if (curRow == row) {
            divInDivider[divInDivider.length] = curDivide.rows[k].copyObject();
        } else {
            divInDivider[divInDivider.length] = curDivide.rows[k];
        }
    }

    for (k = 0; k < curPanel.rows.length; k++) {
        if(moduleDiv.id == curPanel.rows[k].id) {
            divInPanel[divInPanel.length] = curPanel.rows[k].copyObject();
        } else {
            divInPanel[divInPanel.length] = curPanel.rows[k];
        }
    }

    // first hide and remove all the Dividers except the one that contains a given panel
    if (curDivide != undefined && curDivide != null) {
        curOrgDivider = curDivide.copyObject();
        curDivide.parent.removeAllColumnExceptThis(curDivide);
    }

    // hide and remove all the rows in current divider except for the one that contains our panel
    if (curRow != undefined && curDivide != undefined && curRow != null && curDivide != null) {
        curDivide.removeAllRowExceptThis(curRow);
    }

    // hide and remove all the modules except our module from a given panel
    if (curPanel != undefined && moduleDiv != undefined && curPanel != null && moduleDiv != null) {
        curPanel.removeAllRowExceptThis(moduleDiv);
    }

    this.divPosInfo = new DivPosInfo(curOrgDivider,allDivider,divInDivider,divInPanel);

    curDivide.width = "100%";
    curDivide.height = "100%"

    curPanel.width = "100%";
    curPanel.height = "100%";

    PageLayout.render();
}

/**
* This method is called to restore a maximized portlet into normal window state when
* page layout is column oriented
*/
Portlet.prototype.restoreNormalInColumnMode = function() {
    var dividerParent = null ;
    var curDivide = null;
    var curPanel = null ;
    var moduleDiv = null;

    if (this.divPosInfo == undefined || this.divPosInfo == null || (!isdefined('Dividers')) || (!isdefined('PageLayout'))) {
        alert("error");
    }

    var gotPanel = false ;
    for(j = 0 ; j < Panels.length && (!gotPanel); j++) {
        for (k = 0; k < Panels[j].rows.length; k++) {
            if(this.divNodeId == Panels[j].rows[k].id) {
                moduleDiv = Panels[j].rows[k];
                curPanel = Panels[j];
                curDivide = Panels[j].parent.parent;
                gotPanel = true;
                break;
            }
        }
    }
    for (k = 0 ; k < this.divPosInfo.AllDividers.length; k++) {
        if (curDivide.id == this.divPosInfo.AllDividers[k].id) {
            var curDivWidth = this.divPosInfo.AllDividers[k].width;
            this.divPosInfo.AllDividers[k] = curDivide;
            this.divPosInfo.AllDividers[k].setWidth(curDivWidth);
            break;
        }
    }

    for (j = 0 ; j < curDivide.rows.length ; j++) {
        var keepLooping = true ;
        for (k = 0 ; k < this.divPosInfo.divInDivider.length && keepLooping ; k++) {
            if (curDivide.rows[j].id == this.divPosInfo.divInDivider[k].id) {
                keepLooping = false ;
                var curDivRowWidth = this.divPosInfo.divInDivider[k].width;
                this.divPosInfo.divInDivider[k] = curDivide.rows[j];
                this.divPosInfo.divInDivider[k].setWidth(curDivRowWidth);
            }
        }
    }
    for (j = 0 ; j < curPanel.rows.length ; j++) {
        var keepLooping = true ;
        for (k = 0 ; k < this.divPosInfo.divInPanel.length && keepLooping ; k++) {
            if (curPanel.rows[j].id == this.divPosInfo.divInPanel[k].id) {
                keepLooping = false ;
                var curDivPanelWidth = this.divPosInfo.divInPanel[k].width;
                this.divPosInfo.divInPanel[k] = curPanel.rows[j];
                this.divPosInfo.divInPanel[k].setWidth(curDivPanelWidth);
            }
        }
    }
    dividerParent = this.divPosInfo.curDivider.parent ;
    curPanel.removeAllRowExceptThis();
    curDivide.removeAllRowExceptThis();
    dividerParent.removeAllColumnExceptThis();

    dividerParent.replaceAllColumns(this.divPosInfo.AllDividers);
    curDivide.replaceAllRows(this.divPosInfo.divInDivider);
    curPanel.replaceAllRows(this.divPosInfo.divInPanel);
}

/**
* This method is called to handle maximizing the portlet when portlet placement layout is
* displayed in row mode
*/
Portlet.prototype.handleMaxInRowMode = function() {
    var curDivide ;
    var curColumn;
    var curPanel ;
    var moduleDiv ;
    var curOrgDivider = null ;
    var allDivider = new Array();
    var divInDivider = new Array();
    var divInPanel = new Array();


    if (isdefined('Panels')) {
        var gotPanel = false ;
        for(j = 0 ; j < Panels.length && (!gotPanel); j++) {
            for (k = 0; k < Panels[j].rows.length; k++) {
                if(this.divNodeId == Panels[j].rows[k].id) {
                    moduleDiv = Panels[j].rows[k];
                    curPanel = Panels[j];
                    curDivide = Panels[j].parent;
                    gotPanel = true;
                    break;
                }
            }
        }
    }
    curOrgDivider = curDivide.copyObject();

    for (k = 0; k < Dividers.length ; k++) {
        if(curDivide.id == Dividers[k].id) {
            allDivider[allDivider.length] = Dividers[k].copyObject();
        } else {
            allDivider[allDivider.length] = Dividers[k];
        }
    }

    for (k = 0; k < curDivide.columns.length; k++) {
        if(curPanel.id == curDivide.columns[k].id) {
            curColumn = curDivide.columns[k];
        }
        if (curColumn == curDivide.columns[k]) {
            divInDivider[divInDivider.length] = curDivide.columns[k].copyObject();
        } else {
            divInDivider[divInDivider.length] = curDivide.columns[k];
        }
    }

    for (k = 0; k < curPanel.rows.length; k++) {
        if(moduleDiv.id == curPanel.rows[k].id) {
            curModulePos=k;
            divInPanel[divInPanel.length] = curPanel.rows[k].copyObject();
        } else {
            divInPanel[divInPanel.length] = curPanel.rows[k];
        }
    }

    // first hide and remove all the Dividers except the one that contains a given panel
    if (curDivide != undefined && curDivide != null) {
        curDivide.parent.removeAllRowExceptThis(curDivide);
    }

    if (curDivide != undefined && curDivide != null && curColumn != undefined && curColumn != null) {
        curDivide.removeAllColumnExceptThis(curColumn);
    }

    // hide and remove all the rows except the module from a given panel
    if (moduleDiv != undefined || moduleDiv != null) {
        curPanel.removeAllRowExceptThis(moduleDiv);
    }

    this.divPosInfo = new DivPosInfo(curOrgDivider,allDivider,divInDivider,divInPanel);

    curDivide.width = "100%";
    curDivide.height = "100%"
    curPanel.width = "100%";
    curPanel.height = "100%";

    PageLayout.render();
}

Portlet.prototype.restoreNormalInRowMode = function() {
    var dividerParent = null ;
    var curDivide = null;
    var curPanel = null ;
    var moduleDiv =null;

    if (this.divPosInfo == undefined || this.divPosInfo == null || (!isdefined('Dividers')) || (!isdefined('PageLayout'))) {
        alert("error");
    }

    var gotPanel = false ;
    for(j = 0 ; j < Panels.length && (!gotPanel); j++) {
        for (k = 0; k < Panels[j].rows.length; k++) {
            if(this.divNodeId == Panels[j].rows[k].id) {
                moduleDiv = Panels[j].rows[k];
                curPanel = Panels[j];
                curDivide = Panels[j].parent;
                gotPanel = true;
                break;
            }
        }
    }
    for (k = 0 ; k < this.divPosInfo.AllDividers.length; k++) {
        if (curDivide.id == this.divPosInfo.AllDividers[k].id) {
            var curDivWidth = this.divPosInfo.AllDividers[k].width;
            this.divPosInfo.AllDividers[k] = curDivide;
            this.divPosInfo.AllDividers[k].setWidth(curDivWidth);
            break;
        }
    }

    for (j = 0 ; j < curDivide.columns.length ; j++) {
        var keepLooping = true ;
        for (k = 0 ; k < this.divPosInfo.divInDivider.length && keepLooping ; k++) {
            if (curDivide.columns[j].id == this.divPosInfo.divInDivider[k].id) {
                keepLooping = false ;
                var curDivColWidth = this.divPosInfo.divInDivider[k].width;
                this.divPosInfo.divInDivider[k] = curDivide.columns[j];
                this.divPosInfo.divInDivider[k].setWidth(curDivColWidth);
            }
        }
    }
    for (j = 0 ; j < curPanel.rows.length ; j++) {
        var keepLooping = true ;
        for (k = 0 ; k < this.divPosInfo.divInPanel.length && keepLooping ; k++) {
            if (curPanel.rows[j].id == this.divPosInfo.divInPanel[k].id) {
                keepLooping = false ;
                var curDivPanelWidth = this.divPosInfo.divInPanel[k].width;
                this.divPosInfo.divInPanel[k] = curPanel.rows[j];
                this.divPosInfo.divInPanel[k].setWidth(curDivPanelWidth);
            }
        }
    }
    dividerParent = this.divPosInfo.curDivider.parent ;
    curPanel.removeAllRowExceptThis();
    curDivide.removeAllColumnExceptThis();
    dividerParent.removeAllRowExceptThis();

    dividerParent.replaceAllRows(this.divPosInfo.AllDividers);
    curDivide.replaceAllColumns(this.divPosInfo.divInDivider);
    curPanel.replaceAllRows(this.divPosInfo.divInPanel);
}

/**
* This method is called to handle maximizing the portlet when portlet placement layout is
* displayed in table orientation
*/
Portlet.prototype.handleMaxInTableMode = function() {
    var curItem ;
    var curPanel ;
    var moduleDiv ;

    var moduleItems = null;
    var panelItems = portletLayout.items.items;

    if (isdefined('portletLayout')) {
        var gotPanel = false ;
        for(j = 0 ; j < panelItems.length && (!gotPanel); j++) {
            moduleItems = panelItems[j].items.items
            for (k = 0; k < moduleItems.length; k++) {
                if(this.divNodeId == moduleItems[k].moduleId) {
                    moduleDiv = this.divNode;
                    curItem = moduleItems[k];
                    curPanel = panelItems[j];
                    gotPanel = true;
                    break;
                }
            }
        }
    }

    for(j = 0 ; j < panelItems.length ; j++) {
        if (curPanel.cellId != panelItems[j].cellId) {
            pExt.get(panelItems[j].cellId).dom.style.display = "none";
        }
    }

    moduleItems = curPanel.items.items;
    for(j = 0 ; j < moduleItems.length ; j++) {
        if (curItem.moduleId != moduleItems[j].moduleId) {
            moduleItems[j].body.dom.firstChild.style.display = "none";
        }
    }

    this.sizeOfPanel = new SizeOfPanel(pExt.get(curPanel.id).dom.style.width);
    pExt.get(curPanel.id).dom.style.width = portletLayout.getSize().width - 4;

}

Portlet.prototype.restoreNormalInTableMode = function() {
    var curItem ;
    var curPanel ;
    var moduleDiv ;

    var moduleItems = null;
    var panelItems = portletLayout.items.items;

    if (isdefined('portletLayout')) {
        var gotPanel = false ;
        for(j = 0 ; j < panelItems.length && (!gotPanel); j++) {
            moduleItems = panelItems[j].items.items
            for (k = 0; k < moduleItems.length; k++) {
                if(this.divNodeId == moduleItems[k].moduleId) {
                    moduleDiv = this.divNode;
                    curItem = moduleItems[k];
                    curPanel = panelItems[j];
                    gotPanel = true;
                    break;
                }
            }
        }
    }

    for(j = 0 ; j < panelItems.length ; j++) {
        if (curPanel.cellId != panelItems[j].cellId) {
            pExt.get(panelItems[j].cellId).dom.style.display = "";
        }
    }

    moduleItems = curPanel.items.items;
    for(j = 0 ; j < moduleItems.length ; j++) {
        if (curItem.moduleId != moduleItems[j].moduleId) {
            moduleItems[j].body.dom.firstChild.style.display = "";
        }
    }

    pExt.get(curPanel.id).dom.style.width = this.sizeOfPanel.widthOfPanel;
}

/**
 * Link click handler for a portlet action link.  We build the URL, submit it through AJAX and set our portlet
 * actionResponseHandler as the callback handler.
 * @param params portlet state map
 * @param removeAction whether the action request is for removing a portlet from a page
 */
Portlet.prototype.submitActionLink = function(params,removeAction) {
    try {
		var vapDynamic = new VignettePortal.DynamicAJAXClient();
		var templateToUse = vapDynamic.getTemplateToUse(params.baseURL) ;
        var url = vapDynamic.buildRenderURL(params, templateToUse);

        var mask = new pExt.LoadMask(this.divNode);
        mask.msg = '...';
        mask.show();
        var me = this;
        new VignettePortal.AJAXClient().sendURL(url, function(resp) {
            var responseText = resp.responseText;
            me.actionResponseHandler(responseText,removeAction);
            mask.hide();
        });
    } catch (err) {
        alert(err);
    }
    return false;
}

/**
 * Callback handler from a Portlet action link click or a form submission.  In both cases the response will contain
 * a set of new portlet states.  We update each portlet objects state with any new state and rerender that portlet.
 * @param res
 * @param removeAction whether the action request was for removing a portlet from a page
 */
Portlet.prototype.actionResponseHandler = function(responseText,removeAction) {
    try {
        var wasMaximized = false ;
        if (this.state.targetState == 'maximized') {
            wasMaximized = true ;
        }
        if (removeAction) {
            this.handleRemoveAction(wasMaximized);
            return ;
        }
        var newHtmlContent = responseText;

        var stateInfo = responseText ;
        var returnedState = eval('('+stateInfo+')');
        if (isRenderedInDirectMode(returnedState.targetState, returnedState.urlType, returnedState.pageParams)) {
            renderInDirectMode(returnedState);
            return ;
        } else {
            this.state = returnedState;
            this.reRender(wasMaximized);
        }

        // Assign each portlet any new state that may have resulted from the action
        for(var o in returnedState.nonTargetParams) {
           var nonTargetInfo = returnedState.nonTargetParams[o];
           var p = dpiEnabledPortlets[o];
           var portletWasInMaxState = false ;
           if (nonTargetInfo.windowState != undefined) {
               if (p.state.targetState == 'maximized') {
                  portletWasInMaxState = true;
               }
               p.state.targetState = nonTargetInfo.windowState;
           }
           if (nonTargetInfo.portletMode != undefined) {
               p.state.targetMode = nonTargetInfo.portletMode;
           }
           if (nonTargetInfo.tpst != undefined) {
               p.state.tpst = nonTargetInfo.tpst;
           }
           if (nonTargetInfo.parameter != undefined && nonTargetInfo.parameter.length != 0) {
               p.state.targetParams = nonTargetInfo.parameter;
           }
           if (this.state.targetState == 'maximized') {
                wasMaximized = true ;
            }
            p.reRender(portletWasInMaxState);
        }
    } catch (err) {
        alert(err);
    }
}

/**
* This method is called to handle updation of client div tags after remove operation
* was successfully completed on server.
*/
Portlet.prototype.handleRemoveAction = function(wasMaximized) {

    if (wasMaximized != undefined && wasMaximized) {
       this.restoreNormalState(false);
    }
    if (isdefined('typeOfOrientation')) {
        if (typeOfOrientation == "table") {
            this.handleRemoveInTableOrientation();
        } else {
            this.handleRemoveInRowColumnOrientation();
        }
    }
}

Portlet.prototype.handleRemoveInTableOrientation = function() {
    var curItem ;
    var curPanel;

    var moduleItems = null;
    var panelItems = portletLayout.items.items;

    if (isdefined('portletLayout')) {
        var gotPanel = false ;
        for(j = 0 ; j < panelItems.length; j++) {
            moduleItems = panelItems[j].items.items
            for (k = 0; k < moduleItems.length; k++) {
                if(this.divNodeId == moduleItems[k].moduleId) {
                    curItem = moduleItems[k];
                    curPanel = panelItems[j];
                    break;
                }
            }
        }
    }

    var portletDiv = dpiEnabledPortlets[this.uid].divNode;
//    var portletDiv = document.getElementById(this.divNodeId);
    var parentNode = portletDiv.parentNode;
    parentNode.removeChild(portletDiv);

    parentNode = curItem.dd.panel.el.dom.parentNode;
    parentNode.removeChild(curItem.dd.panel.el.dom);

    curPanel.items.remove(curItem);
    curPanel.renumberItemModuleIds();
}

Portlet.prototype.handleRemoveInRowColumnOrientation = function() {
    var gotPanel = false ;
    var curPanel ;
    var moduleDiv ;
    for(j = 0 ; j < Panels.length && (!gotPanel); j++) {
        for (k = 0; k < Panels[j].rows.length; k++) {
            if(this.divNodeId == Panels[j].rows[k].id) {
                curPanel = Panels[j];
                moduleDiv = Panels[j].rows[k];
                gotPanel = true;
                break;
            }
        }
    }

    if (curPanel != undefined && curPanel != null && moduleDiv != undefined && moduleDiv != null) {
        curPanel.removeRow(moduleDiv);
    }

    getSubmittingData(curPanel);

    var portletDiv = document.getElementById(this.divNode.id);
    var parentNode =  portletDiv.parentNode;
    parentNode.removeChild(portletDiv);

    if (isdefined('PageLayout')) {
       PageLayout.render();
    }
}

/**
 * Finds all forms under the current DIV node in the DOM.  Create a form object and set an onsubmit handler back to
 * the form object's formHandler() method. In this way we capture the submission of all portlet forms.
 * @param portletDiv
 */
function scanPortletForms(portletDiv) {
	try {
		var vapDynamic = new VignettePortal.DynamicAJAXClient();
		vapDynamic.scanPortletDivForImg(portletDiv);
		vapDynamic.scanPortletDivForJScriptPopUp(portletDiv);
		var forms = pExt.DomQuery.select('FORM',portletDiv);
		var count = 0;
		for (var i = 0; i < forms.length; i++) {
			var form = forms[i];
			if(form.action != null && form.action.indexOf("portletURL") != -1) {
				var uid = portletDiv.getAttribute("uid");
				var div = portletDiv;
				var vgnDPIButSub = "vgnDPIButSub"+ uid;
				count++;
				var actionForm = new ActionForm(form, div);
				var submitButtonExist = false ;
				var inputs = pExt.DomQuery.select('input[type=submit]',form);
				submitButtonExist = processInputElements(inputs,uid);
				if (submitButtonExist) {
					var sub = document.createElement("input");
					sub.setAttribute("name", vgnDPIButSub);
					sub.setAttribute("id", vgnDPIButSub);
					sub.setAttribute("value", "");
					sub.setAttribute("type", "hidden");
					form.appendChild(sub);
				}
				// Add a standard submit input to form.  When we send with ajax the submit element is lost otherwise
				// and some portlets expect to find that element.

				form.onsubmit = function() {
					new VignettePortal.DynamicAJAXClient().formHandler(this);
					return false;
				};
			}

		}

	} catch (err) {
		alert("Error: " + err);
	}
	return count;
}

function processInputElements(inputs,uid) {
	var submitButtonExist = false;
	for(var k=0; k<inputs.length; k++){
		var inputElement = inputs[k];
        var orginalMethod = null;
        if (inputElement.getAttribute('onclick') != null) {
            orginalMethod = inputElement.getAttribute('onclick');
        }
        if (bw.ie) {
            if (orginalMethod != undefined || orginalMethod != null) {
                // Temporarily creating an attribute to hold current button's onclick method.
                inputElement.setAttribute("orginalMethod", orginalMethod);
                inputElement.onclick = function() {updateBtnName(uid,this,this.form,true); return false;}
            } else {
                inputElement.onclick = function() {updateBtnName(uid,this,this.form,false); return true;}
            }
        } else {
            if (orginalMethod != undefined || orginalMethod != null) {
                inputElement.onclick = function() {updateBtnName(uid,this,this.form,true); return false;}
            } else {
                inputElement.onclick = function() {updateBtnName(uid,this,this.form,false); return true;}
            }
        }
		submitButtonExist = true;
	}
	return submitButtonExist;
}

function updateBtnName(uid,button,form,originalExist) {
	var vgnButSub = "vgnDPIButSub" + uid;
	var elements = pExt.DomQuery.select("input[name=" + vgnButSub + "]", form);
    if (elements != undefined && elements.length > 0) {
        elements[0].value = button.name;
    } else {
        var sub = document.createElement("input");
        sub.setAttribute("name", vgnButSub);
        sub.setAttribute("id", vgnButSub);
        sub.setAttribute("value", button.name);
        sub.setAttribute("type", "hidden");
        form.appendChild(sub);
    }


	if (originalExist) {
		executeOriginalMethod(button);
	}
}

function executeOriginalMethod(button) {
	  if (bw.ie) {
		Function.prototype.toFunction = function() { return this; 	}
		fun = button.getAttribute("orginalMethod").toFunction();
		fun();
		button.removeAttribute("orginalMethod");
	} else {
		method = button.getAttribute("onclick");
		var methodName = method.substring(0, method.indexOf('('));
		var url = method.substring(method.indexOf('(')+1, method.lastIndexOf(')'));
		var exmethod = "javascript:" + methodName +"("+url+");";
		eval(exmethod);
	}
}

/**
*  This method is called to submit the URL directly (causing complete refresh of page)
*  rather through AJAX call.
* This method might be called in case of redirect and when targetState is 'RAW' or 'SOLO'
*/
function submitURLDirectly(url) {
    parent.location=url;
}
/**
 * Form object.  We create one per form in a Portlet.
 * @param formElement
 * @param divNode
 */
function ActionForm(formElement, divNode) {
    this.formElement = formElement;
    this.divNode = divNode;
}

Portlet.prototype.submitForm = function(form,actionState) {
    var elName;
    var submitTracker;
	var vapDynamic = new VignettePortal.DynamicAJAXClient();
	var vgnButSub = "vgnDPIButSub" + actionState.targetUID;
	var extQuery = "input[name=" + vgnButSub + "]";
	var elements = pExt.DomQuery.select(extQuery,form);
       if (elements != undefined && elements.length > 0) {
           elName = elements[0].value ;
           submitTracker = elements[0];
       }
    if (elName != undefined && elName != null && elName != "") {
        elements = pExt.DomQuery.select('input[type=submit]',form);
        for (var i = 0 ; elements != undefined && i < elements.length ; i++) {
            if (elements[i].name == elName) {
            var sub = document.createElement("input");
            sub.setAttribute("name", elName);
            sub.setAttribute("value", elements[i].value);
            sub.setAttribute("type", "hidden");
            form.appendChild(sub);
                break;
            }
        }
        form.removeChild(submitTracker);
    }

    // build an appropriate URL and put into the form action for submission.
    // Must be in the form action as thats where the sendForm() call is going to look for it
    var templateToUse = vapDynamic.getTemplateToUse(actionState.baseURL) ;
    var url = vapDynamic.buildRenderURL(actionState, templateToUse);
    form.action = url;
    var currentPortlet = this;
    var wasMaximized = false;
    if (currentPortlet.state.targetState == 'maximized') {
        wasMaximized = true ;
    }

    var mask = new pExt.LoadMask(this.divNode);
    mask.msg = '...';
    mask.show();

    if (form.encoding !=undefined && form.encoding == 'multipart/form-data') {
        new VignettePortal.AJAXClient().sendMultiPartForm(form, function(responseText) {
            currentPortlet.renderResponseHandler(responseText,wasMaximized,true);
            mask.hide();
         },"text/html");
    } else {
        new VignettePortal.AJAXClient().sendForm(form, function(resp) {
            var responseText = resp.responseText;
            if (actionState.urlType == 'action') {
                currentPortlet.actionResponseHandler(responseText,false);
            } else {
                currentPortlet.renderResponseHandler(responseText,wasMaximized,true);
            }
            mask.hide();
        });
    }
}

/**
 * Search for elements under a given DOM node that have a particular CSS class.
 * @param searchClass
 * @param node
 * @param tag
 */
function getElementsByClass(searchClass, node, tag) {

    var classElements = new Array();
    if (node == null)
        node = document;
    if (tag == null)
        tag = '*';
    var els = node.getElementsByTagName(tag);
    var elsLen = els.length;
    var pattern = new RegExp("(^|\\s)" + searchClass + "(\\s|$)");
    var j = 0;
    for (i = 0; i < elsLen; i++) {
        if (pattern.test(els[i].className)) {
            classElements[j] = els[i];
            j++;
        }
    }
    return classElements;
}

function isdefined(variable)
{
    return (typeof(window[variable]) == "undefined") ? false : true;
}

function updatePortletDivId(uid, newDivId) {
    if (dpiEnabledPortlets[uid] != null && dpiEnabledPortlets[uid] != undefined) {
        dpiEnabledPortlets[uid].divNodeId = newDivId;
    }
}