//Concept Studio Scripts
//-----------------------------------Relative Box Positioning---------------------------//


//--------Old Method(Relative Position/Size)------//
//* Note: Position is now handled by anchors, kept only for compatibility *//

var relativeLayers=[];
function AddRelative(Id,RefId,RefValue,RefType){
	relativeLayers[relativeLayers.length] = [Id, RefId, RefValue, RefType, 0, 0];
}

function HandleRelative(RId){
for (var i=0; i<relativeLayers.length; i++) {
  var layerData =  relativeLayers[i];
  var Id             =  layerData[0];
  var RefId       =  layerData[1];
  var RefValue =  layerData[2];
  var RefType  =  layerData[3];
  var MinHeight= 0;//layerData[4];
  var MinWidth = 0;//layerData[5];
  if (RefId == RId){
    var baseObject = MM_findObj(Id, false);
    var refObject     = MM_findObj(RefId, false);
    if (baseObject && refObject){
      MinHeight = baseObject.style.height;
      MinWidth  = baseObject.style.width;
      switch(RefType){
        case "top":
          baseObject.style.top = (parseInt(refObject.offsetTop) + parseInt(RefValue)) + "px";
          break;
        case "left":
          baseObject.style.left = (parseInt(refObject.offsetLeft) + parseInt(RefValue)) + "px";
          break;
        case "right":
          baseObject.style.left = (parseInt(refObject.offsetLeft) + parseInt(refObject.offsetWidth) + parseInt(RefValue)) + "px";
          break;
        case "bottom":
          baseObject.style.top = (parseInt(refObject.offsetTop) + parseInt(refObject.offsetHeight) + parseInt(RefValue)) + "px";
          break;
        case "width":
          baseObject.style.width = Math.max(parseInt(MinWidth), parseInt(refObject.offsetWidth) + parseInt(RefValue)) + "px";
          break;
        case "height":
          //alert(parseInt(ApproxHeight(refObject)));
          baseObject.style.height = Math.max(baseObject.offsetHeight, parseInt(ApproxHeight(refObject, 0) + parseInt(RefValue)) ) + 'px';
          break;
        }
      }
    }
  }
}

function AlignRelatives(){
var processed = [];
for (var j=0; j<relativeLayers.length; j++) {
  var layerData = relativeLayers[j];
  var RID = layerData[1];
  var b = true;
  for (var k=0;k<processed.length; k++){
    if (processed[k] == RID){b = false;break;}
    }
  if(b){
    HandleRelative(RID);
    processed[processed.length] = RID;
    }
}
}

//--------Anchor Handling------//
var anchors = new Array();
var widthRelatives = new Array();
var heightRelatives = new Array();
var c = 0;

function AddAnchor(parentId, parentAnchorPoint, referenceId, referenceAnchorPoint, referenceProperty, offsetX, offsetY)
{
	if (anchors[parentId] == null)
	{		
		/*alert("anchor: " + parentID);*/
		anchorPoints = new Array();
		anchors[parentId] = anchorPoints;
	}
	anchors[parentId][parentAnchorPoint] = new Object();
	anchors[parentId][parentAnchorPoint].referenceId = referenceId;
	anchors[parentId][parentAnchorPoint].referenceAnchorPoint = referenceAnchorPoint;
	anchors[parentId][parentAnchorPoint].referenceProperty = referenceProperty;
	anchors[parentId][parentAnchorPoint].offsetX = parseInt(offsetX);
	anchors[parentId][parentAnchorPoint].offsetY = parseInt(offsetY);
	var elem;
	if (referenceId == "Window")
	{
		elem = window;	
	}else{
		elem = GetObject(referenceId);
		//elem.onresize = function(){RePositionHandle(referenceId);}
	}
	
}

function AddRelativeWidth(parentId, referenceId, offset)
{
	widthRelatives[parentId] = new Object();
	widthRelatives[parentId].referenceId = referenceId;
	widthRelatives[parentId].offset = offset;
}

function AddRelativeHeight(parentId, referenceId, offset)
{
	heightRelatives[parentId] = new Object();
	heightRelatives[parentId].referenceId = referenceId;
	heightRelatives[parentId].offset = offset;
}

function RePositionHandle(Id)
{
	var anchorDefinedWidth = false;
	var anchorDefinedHeight = false;
	//Parse all referenced anchors
	ReCalcReferencedAnchoredBoxes(Id);
	/*
	for(key in anchors)
	{
		if(key == Id)
			continue;
		var boxAnchors = anchors[key];
		if(boxAnchors != null)
		{
			var hasReferenceToThis = false;
			for(key2 in boxAnchors)
			{
				if(anchor[key2].referenceId == Id)
				{
					hasReferenceToThis = true;
					break;
				}
			}
			var anchorFlags = ReCalcAnchoredBox(key);
			
				
			ReCalcReferencedAnchoredBoxes(key, new Array(Id));
		}
	}	*/
	
}

//Returns : flags of value:  0 - Nothing done   1 - Failed   2 - left   4 - top   8 - width   16 - height
function ReCalcAnchoredBox(Id)
{
	var boxAnchors = anchors[Id];
	if (boxAnchors == null)
		return 0;
	var usedCoords = [false, false, false, false]; //left, right, top, bottom
	var usedValues = [0, 0, 0, 0];
	var propUsage = [0, 0, 0 ,0];
	var left=0; var right=1; var top=2; var bottom=3;
	
	//Calc property usage
	for (bkey in boxAnchors)
	{
		switch(boxAnchors[bkey].referenceProperty)
		{
			case "Left":
				propUsage[left]++;
				break;
			case "Top":
				propUsage[top]++;
				break;
			case "Right":
				propUsage[right]++;
				break;
			case "Bottom":
				propUsage[bottom]++;
				break;
		}
	}
	
	
	//Parse corner points and middle point spacer properties
	for(bkey in boxAnchors)
	{
		switch(bkey)
		{
			case "TopLeft":
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Left")) && !usedCoords[left])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[left] = true;
						usedValues[left] = position.Left + boxAnchors[bkey].offsetX;
					}
				}
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Top")) && !usedCoords[top])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[top] = true;
						usedValues[top] = position.Top + boxAnchors[bkey].offsetY;
					}
				}
				break;
			case "TopMiddle":
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Top")) && !usedCoords[top])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[top] = true;
						usedValues[top] = position.Top + boxAnchors[bkey].offsetY;
					}
				}
				break;
			case "TopRight":
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Right")) && !usedCoords[right])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[right] = true;
						usedValues[right] = position.Left + boxAnchors[bkey].offsetX;
					}
				}
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Top")) && !usedCoords[top])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[top] = true;
						usedValues[top] = position.Top + boxAnchors[bkey].offsetY;
					}
				}
				break;
			case "MiddleLeft":
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Left")) && !usedCoords[left])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[left] = true;
						usedValues[left] = position.Left + boxAnchors[bkey].offsetX;
					}
				}
				break;
			case "MiddleRight":
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Top")) && !usedCoords[top])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[top] = true;
						usedValues[top] = position.Top + boxAnchors[bkey].offsetY;
					}
				}
				break;
			case "BottomLeft":
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Left")) && !usedCoords[left])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[left] = true;
						usedValues[left] = position.Left + boxAnchors[bkey].offsetX;
					}
				}
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Bottom")) && !usedCoords[bottom])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[bottom] = true;
						usedValues[bottom] = position.Top + boxAnchors[bkey].offsetY;
					}
				}
				break;
			case "BottomMiddle":
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Bottom")) && !usedCoords[bottom])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[bottom] = true;
						usedValues[bottom] = position.Top + boxAnchors[bkey].offsetY;
					}
				}
				break;
			case "BottomRight":
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Right")) && !usedCoords[right])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[right] = true;
						usedValues[right] = position.Left + boxAnchors[bkey].offsetX;
					}
				}
				if (((boxAnchors[bkey].referenceProperty == "") || (boxAnchors[bkey].referenceProperty == "Bottom")) && (!usedCoords[bottom] || (propUsage[bottom] > 1)))
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						var bottomCoord = position.Top + boxAnchors[bkey].offsetY; 
						if((!usedCoords[bottom]) || (bottomCoord > usedValues[bottom]))
							usedValues[bottom] = bottomCoord;
						usedCoords[bottom] = true;
					}
				}
				break;
		}
	}
	
	//Parse Middle Point rules (in 2nd phase, to avoid property collisions, corners always have priority) 
	for(bkey in boxAnchors)
	{
		switch(bkey)
		{
			case "TopMiddle":
			case "BottomMiddle":
				if(!usedCoords[left])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint); 
					if (position != null)
					{
						usedCoords[left] = true;
						var middlePoint = position.Left + boxAnchors[bkey].offsetX;
						var nW = ApproxWidth(GetObject(Id), 0);
						usedValues[left] = middlePoint - Math.round(nW / 2);
						
					}
				}else{
					if (!usedCoords[right])
					{/*
						var position = GetAnchorPosition(boxAnchors[key].referenceId, boxAnchors[key].referenceAnchorPoint);
						if (position != null)
						{
							usedCoords[right] = true;
							var middlePoint = position.Left + boxAnchors[key].offsetX;
							usedValues[right] = position.Left + 2 * ( middlePoint - position.Left );
						}
					*/}
				}
				break;
			case "MiddleLeft":
			case "MiddleRight":
				if(!usedCoords[top])
				{
					var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
					if (position != null)
					{
						usedCoords[top] = true;
						var middlePoint = position.Top + boxAnchors[bkey].offsetY;
						
						usedValues[top] = middlePoint - Math.round( (position.Bottom - position.Top) / 2);
					}
				}else{
					if (!usedCoords[bottom])
					{
						var position = GetAnchorPosition(boxAnchors[bkey].referenceId, boxAnchors[bkey].referenceAnchorPoint);
						if (position != null)
						{
							usedCoords[bottom] = true;
							var middlePoint = position.Top + boxAnchors[bkey].offsetY;
							usedValues[bottom] = position.Top + 2 * ( middlePoint - position.Top );
						}
					}
				}
				break;
		}
	} 
	
	var retFlags = 0;

	
	//Parsing over, set unused coords with default values
	var topLeftPosition = GetAnchorPosition(Id, "TopLeft");
	/*var bottomRightPosition = GetAnchorPosition(Id, "BottomRight");*/
	if (!usedCoords[left]) 
	{ usedValues[left] = (!usedCoords[right])?topLeftPosition.Left:(usedValues[right] - (GetAnchorPosition(Id, "TopRight").Left - topLeftPosition.Left)); 
	}else { retFlags |= 2; }
	 
	if (!usedCoords[top])
	{ usedValues[top]  = topLeftPosition.Top; }else{ retFlags |= 4;}
	
	if (!usedCoords[right])
	{usedValues[right]= usedValues[left] + ApproxWidth(GetObject(Id), 0);}/*(bottomRightPosition.Left - topLeftPosition.Left);*/
	else{ retFlags |= 8;}
	
	if (!usedCoords[bottom])
	{usedValues[bottom]= usedValues[top] + ApproxHeight(GetObject(Id), 0);}//(bottomRightPosition.Top - topLeftPosition.Top);}
	else{retFlags |= 16;}
	
	SetBoxProperty(Id, usedValues[left], usedValues[top], usedValues[right], usedValues[bottom]);
	
	return retFlags;
}

var dCount = 0;
function dInfo(elem, left, top, right, bottom)
{
	if(dCount < 3)
		alert("left:"+left+"  top:"+top+"  right:"+right+"  bottom:"+bottom);
	dCount++;
}

function SetBoxProperty(Id, left, top, right, bottom)
{
	var elem = GetObject(Id);
	/*if(Id == "Content")
		dInfo(elem, left, top, right, bottom);*/
	elem.style.width = (right-left) + "px";
	elem.style.height = (bottom-top) + "px";
	elem.style.left = left + "px";
	elem.style.top = top + "px";
	
	//alert("Setting "+ Id + "    L:" + left + "    T:"+top+"    R:"+right+"    B:"+bottom);
}

function GetAnchorPosition(Id, anchor)
{
	var elem;
	var eLeft;
	var eTop;
	var eWidth;
	var eHeight;
	if (Id == "Window")
	{
		eLeft = 0;
		eTop = 0;
		if((typeof(window.innerHeight) == 'number') && (window.innerHeight > 0))
		{
			//Standard
			eWidth = window.innerWidth;
			eHeight = window.innerHeight;
		}else{
			//No luck, do some hack
			
			/*var br = document.CreateElement("div");
			br.style.position = "absolute";
			br.style.width = "0px";
			br.style.height = "0px";
			br.style.right = "0px";
			br.style.bottom = "0px";
			document.body.appendChild(br);*/
			//eWidth = screen.width;			eHeight = screen.height;
			eWidth = 800;			eHeight = 600;
			//document.body.removeChild(br);
		}
	}else{
		elem = GetObject(Id);
		eLeft = parseInt(elem.offsetLeft);
		eTop = parseInt(elem.offsetTop);
		eWidth = ApproxWidth(elem, 0);//parseInt(elem.offsetWidth);
		eHeight = ApproxHeight(elem, 0);
	}
	var pos = new Object();
	switch(anchor)
	{
		case "TopLeft":
			pos.Left = eLeft;
			pos.Top = eTop;
			break;
		case "TopMiddle":
			pos.Left = eLeft + Math.round(eWidth / 2);
			pos.Top = eTop;
			break;
		case "TopRight":
			pos.Left = eLeft + eWidth;
			pos.Top = eTop;
			break;
		case "MiddleLeft":
			pos.Left = eLeft;
			pos.Top = eTop + Math.round(eHeight / 2);
			break;
		case "MiddleRight":
			pos.Left = eLeft + eWidth;
			pos.Top = eTop + Math.round(eHeight / 2);
			break;
		case "BottomLeft":
			pos.Left = eLeft;
			pos.Top = eTop + eHeight;
			break;
		case "BottomMiddle":
			pos.Left = eLeft + Math.round(eWidth / 2);
			pos.Top = eTop + eHeight;
			
			break;
		case "BottomRight":
			pos.Left = eLeft + eWidth;
			pos.Top = eTop + eHeight;
			break;
		default:
			pos.Left = 0;
			pos.Top = 0;		
	}
	//alert(Id + "   " + anchor + "              posleft:" + pos.Left + "        postop:" + pos.Top);
	return pos;
}

function ReCalcReferencedAnchoredBoxes(Id, exclude)
{
	if (exclude == null) exclude = new Array();
	for(key in anchors)
	{
		if((key == Id) || (exclude[key] != null))
			continue;
		var boxAnchors = anchors[key];
		if(boxAnchors != null)
		{
			/*var s = "";
			for(key2 in boxAnchors)
			   {s += boxAnchors[key2].referenceId + ",";}
			alert (Id + " " + key + " " + s);*/
			var hasReferenceToThis = false;
			for(key2 in boxAnchors)
			{
				if(boxAnchors[key2].referenceId == Id)
				{
					hasReferenceToThis = true;
					break;
				}
			}
			if(hasReferenceToThis)
			{
				var ar = new Array();
				for(kkey in exclude)
				{
					ar[kkey] = exclude[kkey];
				}
				ar[Id] = Id;
				var kk = key;
				var kk2 = key;
				if (GetObject(kk) != null)
				{
					if(ReCalcAnchoredBox(kk) > 1)
					//alert(key);
						ReCalcReferencedAnchoredBoxes(kk2, ar);
				}
			}else{
				
			}
		}
	}
}

var calledFromRHandler = false;
var rePositionPassed = 0;

function RepositionAll()
{
	if(!calledFromRHandler)
		rePositionPassed = 0;
	for(key in anchors)
	{
		for(key2 in anchors[key])
		{
			if(anchors[key][key2] != undefined)
			{
				if(anchors[anchors[key][key2].referenceId] == null)
				{
					RePositionHandle(anchors[key][key2].referenceId);
				}
			}
		}
	}

}
var anchorsFiltered = false;
function rHandler()
{
	if(!anchorsFiltered)
	{
		var altAnchors = new Array();
		for(key in anchors)
		{
			var kObj = GetObject(key);
			if(kObj)
			{
				for(key2 in anchors[key])
				{
					if ((GetObject(anchors[key][key2].referenceId)) || (anchors[key][key2].referenceId == "Window"))
					{
						if(!altAnchors[key])
							altAnchors[key] = new Array();
						altAnchors[key][key2] = anchors[key][key2];
					}
				}
			}
		}
		anchors = altAnchors;
		anchorsFiltered = true;
	}
	calledFromRHandler = true;
	RepositionAll();
	calledFromRHandler = false;
	rePositionPassed++;
	if (rePositionPassed < 2)
	{
		//setTimeout("rHandler();", 1000);
	}else{
		//setTimeout("rHandler();", 6000);
	}
}

//-----------------------------------Relative Box Positioning---------------------------//