/* This notice must be untouched at all times.

wz_dragdrop.js	v. 4.82
The latest version is available at
http://www.walterzorn.com
or http://www.devira.com
or http://www.walterzorn.de

Copyright (c) 2002-2003 Walter Zorn. All rights reserved.
Created 26. 8. 2002 by Walter Zorn (Web: http://www.walterzorn.com )
Last modified: 9. 11. 2005

This DHTML & Drag&Drop Library adds Drag&Drop functionality
to the following types of html-elements:
- images, even if not positioned via layers,
  nor via stylesheets or any other kind of "hard-coding"
- relatively and absolutely positioned layers (DIV elements).
Moreover, it provides extended DHTML abilities.

LICENSE: LGPL

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License (LGPL) as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

For more details on the GNU Lesser General Public License,
see http://www.gnu.org/copyleft/lesser.html
*/

// PATH TO THE TRANSPARENT 1*1 PX IMAGE (required by NS 4 as spacer)

//window.onerror = new Function('return true;');

// Optional commands passed to SET_DHTML() on the html-page (g: may be applied globally, i: individually)

var CLONE			= 'C10nE';   // i  img	  clone image
var COPY			 = 'C0pY';	// i  img	  create copies
var DETACH_CHILDREN  = 'd37aCH';  // i  lyr	  detach images
var HORIZONTAL	   = 'H0r1Z';   // i  img,lyr  horizontally draggable only
var MAXHEIGHT		= 'm7x8I';   // i  img,lyr  maximum height limit, "
var MAXOFFBOTTOM	 = 'm7xd0wN'; // i  img,lyr  downward offset limit
var MAXOFFLEFT	   = 'm7x23Ft'; // i  img,lyr  leftward offset limit
var MAXOFFRIGHT	  = 'm7x0Ff8'; // i  img,lyr  rightward offset limit
var MAXOFFTOP		= 'm7xu9';   // i  img,lyr  upward offset limit
var MAXWIDTH		 = 'm7xW1';   // i  img,lyr  maximum width limit, use with resizable or scalable
var MINWIDTH		 = 'm1nw1';   // i  img,lyr  minimum width limit, "
var MINHEIGHT		= 'm1n8I';   // i  img,lyr  minimum height limit, "
var NO_ALT		   = 'no81T';   // gi img	  disable alt and title attributes
var NO_DRAG		  = 'N0d4Ag';  // i  img,lyr  disable draggability
var RESET_Z		  = 'r35E7z';  // gi img,lyr  reset z-index when dropped
var RESIZABLE		= 'r5IZbl';  // gi img,lyr  resizable if <ctrl> or <shift> pressed
var SCALABLE		 = 'SCLbl';   // gi img,lyr  scalable		   "
var SCROLL		   = 'sC8lL';   // gi img,lyr  enable auto scroll functionality
var TRANSPARENT	  = 'dIApHAn'; // gi img,lyr  translucent while dragged
var VERTICAL		 = 'V3Rt1C';  // i  img,lyr  vertically draggable only
var dd_cursors = new Array(
	'c:default',
	'c:crosshair',
	'c:e-resize',
	'c:hand',
	'c:help',
	'c:move',
	'c:n-resize',
	'c:ne-resize',
	'c:nw-resize',
	'c:s-resize',
	'c:se-resize',
	'c:sw-resize',
	'c:text',
	'c:w-resize',
	'c:wait'
);
var dd_i = dd_cursors.length; while(dd_i--)
	eval('var CURSOR_' + (dd_cursors[dd_i].substring(2).toUpperCase().replace('-', '_')) + ' = "' + dd_cursors[dd_i] + '";');
var dd_u = "undefined";
function WZDD()
{
	this.elements = new Array(0);
	this.obj = null;
	this.n = navigator.userAgent.toLowerCase();
	this.db = (document.compatMode && document.compatMode.toLowerCase() != "backcompat")?
		document.documentElement
		: (document.body || null);
	this.op = !!(window.opera && document.getElementById);
	if(this.op) document.onmousedown = new Function('e',
		'if(((e = e || window.event).target || e.srcElement).tagName == "IMAGE") return false;');
	this.ie = !!(this.n.indexOf("msie") >= 0 && document.all && this.db && !this.op);
	this.iemac = !!(this.ie && this.n.indexOf("mac") >= 0);
	this.ie4 = !!(this.ie && !document.getElementById);
	this.n4 = !!(document.layers && typeof document.classes != dd_u);
	this.n6 = !!(typeof window.getComputedStyle != dd_u && typeof document.createRange != dd_u);
	this.w3c = !!(!this.op && !this.ie && !this.n6 && document.getElementById);
	//this.ce = !!(document.captureEvents && document.releaseEvents);
	this.px = this.n4? '' : 'px';
	this.tiv = this.w3c? 40 : 10;
}
var dd = new WZDD();

dd.Int = function(d_x, d_y)
{
	return isNaN(d_y = parseInt(d_x))? 0 : d_y;
};
dd.getWndW = function()
{
	return dd.Int(
		(dd.db && !dd.op && !dd.w3c && dd.db.clientWidth)? dd.db.clientWidth
		: (window.innerWidth || 0)
	);
};
dd.getWndH = function()
{
	return dd.Int(
		(dd.db && !dd.op && !dd.w3c && dd.db.clientHeight)? dd.db.clientHeight
		: (window.innerHeight || 0)
	);
};
dd.getScrollX = function()
{
	return dd.Int(window.pageXOffset || (dd.db? dd.db.scrollLeft : 0));
};
dd.getScrollY = function()
{
	return dd.Int(window.pageYOffset || (dd.db? dd.db.scrollTop : 0));
};
dd.getPageXY = function(d_o)
{
	if(dd.n4 && d_o)
	{
		dd.x = d_o.pageX || 0;
		dd.y = d_o.pageY || 0;
	}
	else
	{
		dd.x = dd.y = 0; //global helper vars
		while(d_o)
		{
			dd.x += dd.Int(d_o.offsetLeft);
			dd.y += dd.Int(d_o.offsetTop);
			d_o = d_o.offsetParent || null;
		}
	}
};
dd.getCssXY = function(d_o)
{
	if(d_o.div)
	{
		if(dd.n4)
		{
			d_o.cssx = d_o.div.x;
			d_o.cssy = d_o.div.y;
		}
		else if(dd.ie4)
		{
			d_o.cssx = d_o.css.pixelLeft;
			d_o.cssy = d_o.css.pixelTop;
		}
		else
		{
			d_o.css.left = d_o.css.top = 0 + dd.px;
			dd.getPageXY(d_o.div);
			d_o.cssx = d_o.x - dd.x;
			d_o.cssy = d_o.y - dd.y;
			d_o.css.left = d_o.cssx + dd.px;
			d_o.css.top = d_o.cssy + dd.px;
		}
	}
	else
	{
		d_o.cssx = 0;
		d_o.cssy = 0;
	}
};
dd.getImgW = function(d_o)
{
	return d_o? dd.Int(d_o.width) : 0;
};
dd.getImgH = function(d_o)
{
	return d_o? dd.Int(d_o.height) : 0;
};
dd.getDivW = function(d_o)
{
	return dd.Int(
		dd.n4? (d_o.div? d_o.div.clip.width : 0)
		: d_o.div? (d_o.div.offsetWidth || d_o.css.pixelWidth || d_o.css.width || 0)
		: 0
	);
};
dd.getDivH = function(d_o)
{
	return dd.Int(
		dd.n4? (d_o.div? d_o.div.clip.height : 0)
		: d_o.div? (d_o.div.offsetHeight || d_o.css.pixelHeight || d_o.css.height || 0)
		: 0
	);
};
dd.getWH = function(d_o)
{
	d_o.w = dd.getDivW(d_o);
	d_o.h = dd.getDivH(d_o);
	if(d_o.css)
	{
		d_o.css.width = d_o.w + dd.px;
		d_o.css.height = d_o.h + dd.px;
		d_o.dw = dd.getDivW(d_o)-d_o.w;
		d_o.dh = dd.getDivH(d_o)-d_o.h;
		d_o.css.width = (d_o.w-d_o.dw) + dd.px;
		d_o.css.height = (d_o.h-d_o.dh) + dd.px;
	}
	else d_o.dw = d_o.dh = 0;
};
dd.getCssProp = function(d_o, d_pn6, d_pstyle, d_pn4)
{
    try
    {
        if(d_o && dd.n6) return ''+window.getComputedStyle(d_o, null).getPropertyValue(d_pn6);
	if(d_o && d_o.currentStyle) return ''+eval('d_o.currentStyle.'+d_pstyle);
	if(d_o && d_o.style) return ''+eval('d_o.style.'+d_pstyle);
	if(d_o && dd.n4) return ''+eval('d_o.'+d_pn4);
	return '';
    }
    catch(err)
    {

    }
};
dd.getDiv = function(d_x, d_d)
{
	d_d = d_d || document;
	if(dd.n4)
	{
		if(d_d.layers[d_x]) return d_d.layers[d_x];
		for(var d_i = d_d.layers.length; d_i--;)
		{
			var d_y = dd.getDiv(d_x, d_d.layers[d_i].document);
			if(d_y) return d_y;
		}
	}
	if(dd.ie) return d_d.all[d_x] || null;
	if(d_d.getElementById) return d_d.getElementById(d_x) || null;
	return null;
};
dd.getImg = function(d_o, d_nm, d_xy, d_w)
{
	d_w = d_w || window;
	var d_img;
	if(document.images && (d_img = d_w.document.images[d_nm]))
	{
		if(d_xy)
		{
			if(dd.n4)
			{
				dd.getPageXY(d_w);
				d_o.defx = d_img.x + dd.x;
				d_o.defy = d_img.y + dd.y;
			}
			else
			{
				dd.getPageXY(d_img);
				d_o.defx = dd.x;
				d_o.defy = dd.y;
			}
		}
		return d_img;
	}
	if(dd.n4) for(var d_i = d_w.document.layers.length; d_i--;)
	{
		var d_y = dd.getImg(d_o, d_nm, d_xy, d_w.document.layers[d_i]);
		if(d_y) return d_y;
	}
	return null;
};
dd.getParent = function(d_o, d_p)
{
	if(dd.n4)
	{
		for(d_p, d_i = dd.elements.length; d_i--;)
		{
			if(!((d_p = dd.elements[d_i]).is_image) && d_p.div && (d_p.div.document.layers[d_o.name] || d_o.oimg && d_p.div.document.images[d_o.oimg.name]))
				d_p.addChild(d_o, d_p.detach, 1);
		}
	}
	else
	{
		d_p = d_o.is_image? dd.getImg(d_o, d_o.oimg.name) : (d_o.div || null);
		while(d_p && !!(d_p = d_p.offsetParent || d_p.parentNode || null))
		{
			if(d_p.ddObj)
			{
				d_p.ddObj.addChild(d_o, d_p.ddObj.detach, 1);
				break;
			}
		}
	}
};
dd.getCmd = function(d_o, d_cmd, d_cmdStr)
{
	var d_i = d_o.id.indexOf(d_cmd), d_j,
	d_y = (d_i >= 0)*1;
	if(d_y)
	{
		d_j = d_i+d_cmd.length;
		if(d_cmdStr) d_o.cmd += d_o.id.substring(d_i, d_j);
		d_o.id = d_o.id.substring(0, d_i) + d_o.id.substring(d_j);
	}
	return d_y;
};
dd.getCmdVal = function(d_o, d_cmd, d_cmdStr, int0)
{
	var d_i = d_o.id.indexOf(d_cmd), d_j,
	d_y = (d_o.id.indexOf(d_cmd) >= 0)? dd.Int(d_o.id.substring(d_o.id.indexOf(d_cmd)+d_cmd.length)) : int0? -1 : 0;
	if(!int0 && d_y || int0 && d_y >= 0)
	{
		d_j = d_i+d_cmd.length+(""+d_y).length;
		if(d_cmdStr) d_o.cmd += d_o.id.substring(d_i, d_j);
		d_o.id = d_o.id.substring(0, d_i) + d_o.id.substring(d_j);
	}
	return d_y;
};
dd.addElt = function(d_o, d_p)
{
	dd.elements[d_o.name] = dd.elements[d_o.index = dd.elements.length] = d_o;
	if(d_p) d_p.copies[d_o.name] = d_p.copies[d_p.copies.length] = d_o;
};
dd.mkWzDom = function()
{
	var d_o, d_i = dd.elements.length; while(d_i--) dd.getParent(dd.elements[d_i]);
	d_i = dd.elements.length; while(d_i--)
	{
		d_o = dd.elements[d_i];
		if(d_o.children && !d_o.parent)
		{
			var d_j = d_o.children.length; while(d_j--)
			{
				d_o.children[d_j].setZ(parseInt(d_o.z)+parseInt(d_o.children[d_j].z), 1);
			}
		}
	}
};
dd.addProps = function(d_o)
{
	var d_i, d_c;
	if(d_o.is_image)
	{
		d_o.div = dd.getDiv(d_o.id);
		d_o.css = (d_o.div && typeof d_o.div.style != dd_u)? d_o.div.style : null;
		d_o.nimg = (dd.n4 && d_o.div)? d_o.div.document.images[0] : (document.images[d_o.id+'NImG'] || null);
		if(!d_o.noalt && !dd.noalt && d_o.nimg && d_o.oimg)
		{
			d_o.nimg.alt = d_o.oimg.alt || '';
            if(d_o.oimg.title) d_o.nimg.title = d_o.oimg.title;
		}
		d_o.bgColor = '';
	}
	else
	{
		d_o.bgColor = dd.getCssProp(d_o.div, 'background-color','backgroundColor','bgColor').toLowerCase();
		if(dd.n6 && d_o.div)
		{
			if((d_c = d_o.bgColor).indexOf('rgb') >= 0)
			{
				d_c = d_c.substring(4, d_c.length-1).split(',');
				d_o.bgColor = '#';
				for(d_i = 0; d_i < d_c.length; d_i++) d_o.bgColor += parseInt(d_c[d_i]).toString(0x10);
			}
			else d_o.bgColor = d_c;
		}
	}
	if(dd.scalable) d_o.scalable = d_o.resizable^1;
	else if(dd.resizable) d_o.resizable = d_o.scalable^1;
	d_o.setZ(parseInt(d_o.defz));
	d_o.cursor = d_o.cursor || dd.cursor || 'auto';
	d_o._setCrs(d_o.nodrag? 'auto' : d_o.cursor);
	d_o.diaphan = d_o.diaphan || dd.diaphan || 0;
	d_o.opacity = 1.0;
	if(dd.ie && !dd.iemac && d_o.div && d_o.div.style)
		d_o.div.style.filter = "Alpha(opacity=100)";
	d_o.visible = true;
};
dd.initz = function()
{
	if(!(dd && (dd.n4 || dd.n6 || dd.ie || dd.op || dd.w3c))) return;
	else if(dd.n6 || dd.ie || dd.op || dd.w3c) dd.recalc(1);
	var d_drag = (document.onmousemove == DRAG),
	d_resize = (document.onmousemove == RESIZE);
	if(dd.loadFunc) dd.loadFunc();
	if(d_drag) dd.setMovHdl(DRAG);
	else if(d_resize) dd.setMovHdl(RESIZE);
	if(d_drag || d_resize) dd.setUpHdl(DROP);
	dd.setDwnHdl(PICK);
};
dd.finlz = function()
{
	if(dd.ie && dd.elements)
	{
		var d_i = dd.elements.length; while(d_i--)
			dd.elements[d_i].del();
	}
	if(dd.uloadFunc) dd.uloadFunc();
};
dd.setCe = function(d_e, d_fnc)
{
	//d_fnc? document.captureEvents(d_e) : document.releaseEvents(d_e);
};
dd.setDwnHdl = function(d_x)
{
	if(document.onmousedown != d_x)
	{
		dd.downFunc = document.onmousedown;
		document.onmousedown = d_x;
		if(dd.ce) dd.setCe(Event.MOUSEDOWN, d_x);
	}
};
dd.setMovHdl = function(d_x)
{
	if(document.onmousemove != d_x)
	{
		dd.moveFunc = document.onmousemove;
		document.onmousemove = d_x;
		if(dd.ce) dd.setCe(Event.MOUSEMOVE, d_x);
	}
};
dd.setUpHdl = function(d_x)
{
	if(document.onmouseup != d_x)
	{
		dd.upFunc = document.onmouseup;
		document.onmouseup = d_x;
		if(dd.ce) dd.setCe(Event.MOUSEUP, d_x);
	}
};
dd.evt = function(d_e)
{
	this.but = (this.e = d_e || window.event).which || this.e.button || 0;
	this.button = (this.e.type == 'mousedown')? this.but
		: (dd.e && dd.e.button)? dd.e.button
		: 0;
	this.src = this.e.target || this.e.srcElement || null;
	this.src.tag = ("" + (this.src.tagName || this.src)).toLowerCase();
	this.x = dd.Int(this.e.pageX || this.e.clientX || 0);
	this.y = dd.Int(this.e.pageY || this.e.clientY || 0);
	if(dd.ie)
	{
		this.x += dd.getScrollX() - (dd.ie && !dd.iemac)*1;
		this.y += dd.getScrollY() - (dd.ie && !dd.iemac)*1;
	}
	this.modifKey = this.e.modifiers? this.e.modifiers&Event.SHIFT_MASK : (this.e.shiftKey || false);
};
dd.recalc = function(d_x)
{
	var d_o, d_i = dd.elements.length; while(d_i--)
	{
		if(!(d_o = dd.elements[d_i]).is_image && d_o.div)
		{
			dd.getWH(d_o);
			if(d_o.div.pos_rel)
			{
				dd.getPageXY(d_o.div);
				var d_dx = dd.x - d_o.x, d_dy = dd.y - d_o.y;
				d_o.defx += d_dx;
				d_o.x += d_dx;
				d_o.defy += d_dy;
				d_o.y += d_dy;
				var d_p, d_j = d_o.children.length; while(d_j--)
				{
					if(!(d_p = d_o.children[d_j]).detached && (d_o != d_p.defparent || !(d_p.is_image && dd.getImg(d_p, d_p.oimg.name, 1))))
					{
						d_p.defx += d_dx;
						d_p.defy += d_dy;
						d_p.moveBy(d_dx, d_dy);
					}
				}
			}
		}
		else if(d_o.is_image && !dd.n4)
		{
			if(dd.n6 && d_x && !d_o.defw) d_o.resizeTo(d_o.defw = dd.getImgW(d_o.oimg), d_o.defh = dd.getImgH(d_o.oimg));
			var d_defx = d_o.defx, d_defy = d_o.defy;
			if(!(d_o.parent && d_o.parent != d_o.defparent) && (d_x || !d_o.detached || d_o.horizontal || d_o.vertical) && dd.getImg(d_o, d_o.oimg.name, 1))
				d_o.moveBy(d_o.defx-d_defx, d_o.defy-d_defy);
		}
	}
};
function WINSZ(d_x)
{
	if(d_x)
	{
		if(dd.n4)
		{
			dd.iW = innerWidth;
			dd.iH = innerHeight;
		}
		window.onresize = new Function('WINSZ();');
	}
	else if(dd.n4 && (innerWidth != dd.iW || innerHeight != dd.iH)) location.reload();
	else if(!dd.n4) setTimeout('dd.recalc()', 0xa);
}
WINSZ(1);

function DDObj(d_o, d_i)
{
    this.txt = 'Ihr Text';
    this.zValue = 0;
    this.font = 'Arial';
    this.dragLocked = 0;
    this.lockLevel = 0;
    this.size = 12;
    this.bold = 0;
    this.align = 0;
    this.italic = 0;
    this.underline = 0;
    this.dpi = defaultDPI;
    this.color = '000000';
	this.id = d_o;
	this.cmd = '';
	this.cpy_n = dd.getCmdVal(this, COPY);
	this.maxoffb = dd.getCmdVal(this, MAXOFFBOTTOM, 0, 1);
	this.maxoffl = dd.getCmdVal(this, MAXOFFLEFT, 0, 1);
	this.maxoffr = dd.getCmdVal(this, MAXOFFRIGHT, 0, 1);
	this.maxofft = dd.getCmdVal(this, MAXOFFTOP, 0, 1);
	var d_j = dd_cursors.length; while(d_j--)
		if(dd.getCmd(this, dd_cursors[d_j], 1)) this.cursor = dd_cursors[d_j].substring(2);
	this.clone = dd.getCmd(this, CLONE, 1);
	this.detach = dd.getCmd(this, DETACH_CHILDREN);
	this.scalable = dd.getCmd(this, SCALABLE, 1);
	this.horizontal = dd.getCmd(this, HORIZONTAL);
	this.noalt = dd.getCmd(this, NO_ALT, 1);
	this.nodrag = dd.getCmd(this, NO_DRAG);
	this.scroll = dd.getCmd(this, SCROLL, 1);
	this.resizable = dd.getCmd(this, RESIZABLE, 1);
	this.re_z = dd.getCmd(this, RESET_Z, 1);
	this.diaphan = dd.getCmd(this, TRANSPARENT, 1);
	this.vertical = dd.getCmd(this, VERTICAL);
	this.maxw = dd.getCmdVal(this, MAXWIDTH, 1, 1);
	this.minw = Math.abs(dd.getCmdVal(this, MINWIDTH, 1, 1));
	this.maxh = dd.getCmdVal(this, MAXHEIGHT, 1, 1);
	this.minh = Math.abs(dd.getCmdVal(this, MINHEIGHT, 1, 1));
	this.pickFunc = this.dragFunc = this.resizeFunc = this.dropFunc = null;

	this.name = this.id + (d_i || '');
	this.oimg = dd.getImg(this, this.id, 1);
	this.is_image = !!this.oimg;
	this.copies = new Array();
	this.children = new Array();
	this.parent = this.original = null;
	if(this.oimg)
	{
		this.id = this.name + 'div';
		this.w = dd.getImgW(this.oimg);
		this.h = dd.getImgH(this.oimg);
		this.dw = this.dh = 0;
		this.defz = dd.Int(dd.getCssProp(this.oimg, 'z-index','zIndex','zIndex')) || 1;
		this.defsrc = this.src = this.oimg.src;
		this.htm = '<img name="' + this.id + 'NImG"'+
			' src="' + this.oimg.src + '" '+
			'width="' + this.w + '" height="' + this.h + '">';
		this.t_htm = '<div id="' + this.id +
			'" style="position:absolute;'+
			'left:' + (this.cssx = this.x = this.defx) + 'px;'+
			'top:' + (this.cssy = this.y = this.defy) + 'px;'+
			'width:' + this.w + 'px;'+
			'height:' + this.h + 'px;">'+
			this.htm + '<\/div>';
	}
	else
	{
		if(!!(this.div = dd.getDiv(this.id)) && typeof this.div.style != dd_u) this.css = this.div.style;
		dd.getWH(this);
		if(this.div)
		{
			this.div.ddObj = this;
			this.div.pos_rel = ("" + (this.div.parentNode? this.div.parentNode.tagName : this.div.parentElement? this.div.parentElement.tagName : '').toLowerCase().indexOf('body') < 0);
		}
		dd.getPageXY(this.div);
		this.defx = this.x = dd.x;
		this.defy = this.y = dd.y;
		dd.getCssXY(this);
		this.defz = dd.Int(dd.getCssProp(this.div, 'z-index','zIndex','zIndex'));
	}
	this.defw = this.w || 0;
	this.defh = this.h || 0;
}
DDObj.prototype.setPickFunc = function(d_x)
{
	this.pickFunc = d_x;
};
DDObj.prototype.setDragFunc = function(d_x)
{
	this.dragFunc = d_x;
};
DDObj.prototype.setResizeFunc = function(d_x)
{
	this.resizeFunc = d_x;
};
DDObj.prototype.setDropFunc = function(d_x)
{
	this.dropFunc = d_x;
};
DDObj.prototype.moveBy = function(d_x, d_y, d_kds, d_o)
{
	if(!this.div) return;
	this.x += (d_x = dd.Int(d_x));
	this.y += (d_y = dd.Int(d_y));
	if(!d_kds || this.is_image || this.parent != this.defparent)
	{
		(d_o = this.css || this.div).left = (this.cssx += d_x) + dd.px;
		d_o.top = (this.cssy += d_y) + dd.px;
	}
	var d_i = this.children.length; while(d_i--)
	{
		if(!(d_o = this.children[d_i]).detached) d_o.moveBy(d_x, d_y, 1);
		d_o.defx += d_x;
		d_o.defy += d_y;
	}
};

DDObj.prototype.moveTo = function(d_x, d_y)
{
	this.moveBy(dd.Int(d_x)-this.x, dd.Int(d_y)-this.y);
};
DDObj.prototype.hide = function(d_m, d_o, d_p)
{
	if(this.div && this.visible)
	{
		d_p = this.css || this.div;
		if(d_m && !dd.n4)
		{
			this.display = dd.getCssProp(this.div, "display", "display", "display");
			if(this.oimg)
			{
				this.oimg.display = dd.getCssProp(this.oimg, "display", "display", "display");
				this.oimg.style.display = "none";
			}
			d_p.display = "none";
			dd.recalc();
		}
		else d_p.visibility = "hidden";
	}
	this.visible = false;
	var d_i = this.children.length; while(d_i--)
		if(!(d_o = this.children[d_i]).detached) d_o.hide(d_m);
};
DDObj.prototype.show = function(d_o, d_p)
{
	if(this.div)
	{
		d_p = this.css || this.div;
		if(d_p.display && d_p.display == "none")
		{
			d_p.display = this.display || "block";
			if(this.oimg) this.oimg.style.display = this.oimg.display || "inline";
			dd.recalc();
		}
		else d_p.visibility = "visible";
	}
	this.visible = true;
	var d_i = this.children.length; while(d_i--)
		if(!(d_o = this.children[d_i]).detached) d_o.show();
};
DDObj.prototype.resizeTo = function(d_w, d_h, d_o)
{
	if(!this.div) return;
	d_w = (this.w = dd.Int(d_w))-this.dw;
	d_h = (this.h = dd.Int(d_h))-this.dh;
	if(dd.n4)
	{
		this.div.resizeTo(d_w, d_h);
		if(this.is_image)
		{
			this.write('<img src="' + this.src + '" width="' + d_w + '" height="' + d_h + '">');
			(this.nimg = this.div.document.images[0]).src = this.src;
		}
	}
	else if(typeof this.css.pixelWidth != dd_u)
	{
		this.css.pixelWidth = d_w;
		this.css.pixelHeight = d_h;
		if(this.is_image)
		{
			(d_o = this.nimg.style).pixelWidth = d_w;
			d_o.pixelHeight = d_h;
		}
	}
	else
	{
		this.css.width = d_w + dd.px;
		this.css.height = d_h + dd.px;
		if(this.is_image)
		{
			(d_o = this.nimg).width = d_w;
			d_o.height = d_h;
			if(!d_o.complete) d_o.src = this.src;
		}
	}
};

DDObj.prototype.resizeBy = function(d_dw, d_dh)
{
	this.resizeTo(this.w+dd.Int(d_dw), this.h+dd.Int(d_dh));
};

DDObj.prototype.getAlign = function()
{
  return (this.align);
}
DDObj.prototype.setAlign = function(_value)
{
  this.align=_value;
}

DDObj.prototype.getDpi = function()
{
  return (this.dpi);
}
DDObj.prototype.setDpi = function(_value)
{
  this.dpi=_value;
}

DDObj.prototype.getColor = function()
{
  return (this.color);
}
DDObj.prototype.setColor = function(_value)
{
  this.color=_value;
}

DDObj.prototype.getUnderline = function()
{
  return (this.underline);
}
DDObj.prototype.setUnderline = function(_value)
{
  this.underline=_value;
}

DDObj.prototype.getItalic = function()
{
  return (this.italic);
}
DDObj.prototype.setItalic = function(_value)
{
  this.italic=_value;
}

DDObj.prototype.getBold = function()
{
  return (this.bold);
}
DDObj.prototype.setBold = function(_value)
{
  this.bold=_value;
}

DDObj.prototype.getSize = function()
{
  return (this.size);
}
DDObj.prototype.setSize = function(_value)
{
  this.size=_value;
}

DDObj.prototype.getDragLocked = function()
{
  return (this.dragLocked);
}
DDObj.prototype.setDragLocked = function(_value)
{
  this.dragLocked=_value;
}

DDObj.prototype.getLockLevel = function()
{
  return (this.lockLevel);
}
DDObj.prototype.setLockLevel = function(_value)
{
  this.lockLevel=_value;
}
DDObj.prototype.getFont = function()
{
  return (this.font);
}
DDObj.prototype.setFont = function(txt_value)
{
  this.font=txt_value;
}

DDObj.prototype.getTXT = function()
{
  return (this.txt);
}
DDObj.prototype.setTXT = function(txt_value)
{
  this.txt=txt_value;
}
DDObj.prototype.getZ = function()
{
  return (this.zValue);
}
DDObj.prototype.setZ = function(z_value)
{
  this.zValue=parseInt(z_value);
}

DDObj.prototype.swapImage = function(d_x, d_cp)
{
	if(!this.nimg) return;
	this.nimg.src = d_x;
	this.src = this.nimg.src;
	if(d_cp)
	{
		var d_i = this.copies.length; while(d_i--)
			this.copies[d_i].src = this.copies[d_i].nimg.src = this.nimg.src;
	}
};
DDObj.prototype.setBgColor = function(d_x)
{
	if(dd.n4 && this.div) this.div.bgColor = d_x;
	else if(this.css) this.css.background = d_x;
	this.bgColor = d_x;
};
DDObj.prototype.write = function(d_x, d_o)
{
	this.text = d_x;
	if(!this.div) return;
	if(dd.n4)
	{
		(d_o = this.div.document).open();
		d_o.write(d_x);
		d_o.close();
		dd.getWH(this);
	}
	else
	{
		this.css.height = 'auto';
		this.div.innerHTML = d_x;
		if(!dd.ie4) dd.recalc();
		if(dd.ie4 || dd.n6) setTimeout('dd.recalc();', 0); // n6.0: recalc twice
	}
};
DDObj.prototype.copy = function(d_n, d_p, d_b)
{
	if(!this.oimg) return;
	d_b = (dd.ie && document.all.tags('body'))? document.all.tags('body')[0] : document.getElementsByTagName? (document.getElementsByTagName('body')[0] || dd.db) : dd.db;
	d_n = d_n || 1;
	while(d_n--)
	{
		var d_l = this.copies.length,
		d_o = new DDObj(this.name+this.cmd, d_l+1);
		if(dd.n4)
		{
			d_o.id = (d_p = new Layer(d_o.w)).name;
			d_p.clip.height = d_o.h;
			d_p.visibility = 'show';
			(d_p = d_p.document).open();
			d_p.write(d_o.htm);
			d_p.close();
		}
		else if(d_b && d_b.insertAdjacentHTML) d_b.insertAdjacentHTML("AfterBegin", d_o.t_htm);
		else if(document.createElement && d_b && d_b.appendChild)
		{
			d_b.appendChild(d_p = document.createElement('div'));
			d_p.innerHTML = d_o.htm;
			d_p.id = d_o.id;
			d_p.style.position = 'absolute';
			d_p.style.width = d_o.w + 'px';
			d_p.style.height = d_o.h + 'px';
		}
		else if(d_b && d_b.innerHTML) d_b.innerHTML += d_o.t_htm;
		d_o.defz = this.defz+1+d_l;
		dd.addProps(d_o);
		d_o.original = this;
		dd.addElt(d_o, this);
		if(this.parent)
		{
			this.parent.addChild(d_o, this.detached);
			d_o.defparent = this.defparent;
		}
		d_o.moveTo(d_o.defx = this.defx, d_o.defy = this.defy);
		if(dd.n4) d_o.defsrc = d_o.src = this.defsrc;
		d_o.swapImage(this.src);
	}
};
DDObj.prototype.addChild = function(d_kd, detach, defp)
{
	if(typeof d_kd != "object") d_kd = dd.elements[d_kd];
	if(d_kd.parent && d_kd.parent == this || d_kd == this || !d_kd.is_image && d_kd.defparent && !defp) return;

	this.children[this.children.length] = this.children[d_kd.name] = d_kd;
	d_kd.detached = detach || 0;
	if(defp) d_kd.defparent = this;
	else if(this == d_kd.defparent && d_kd.is_image) dd.getImg(this, d_kd.oimg.name, 1);
	if(!d_kd.defparent || this != d_kd.defparent)
	{
		d_kd.defx = d_kd.x;
		d_kd.defy = d_kd.y;
	}
	if(!detach)
	{
		d_kd.defz = d_kd.defz+this.defz-(d_kd.parent? d_kd.parent.defz : 0)+(!d_kd.is_image*1);
		var newZValue = d_kd.z+this.z-(d_kd.parent? d_kd.parent.z : 0)+(!d_kd.is_image*1);
		//alert(d_kd.z + "addChild zu" + this.z + "Minus: " + (d_kd.parent? d_kd.parent.z : 0) + "Ergebnis" + newZValue);
        d_kd.setZ(parseInt(newZValue), 1);
	}
	if(d_kd.parent) d_kd.parent._removeChild(d_kd, 1);
	d_kd.parent = this;
};
DDObj.prototype._removeChild = function(d_kd, d_newp)
{
	if(typeof d_kd != "object") d_kd = this.children[d_kd];
	var d_oc = this.children, d_nc = new Array();
	for(var d_i = 0; d_i < d_oc.length; d_i++)
		if(d_oc[d_i] != d_kd) d_nc[d_nc.length] = d_oc[d_i];
	this.children = d_nc;
	d_kd.parent = null;
	if(!d_newp)
	{
		d_kd.detached = d_kd.defp = 0;
		if(d_kd.is_image) dd.getImg(d_kd, d_kd.oimg.name, 1);
	}
};
DDObj.prototype.attachChild = function(d_kd)
{
	(d_kd = (typeof d_kd != "object")? this.children[d_kd]: d_kd).detached = 0;
	var newZValue = d_kd.defz + this.z-this.defz;
	//alert(d_kd.defz + "attachChild" + this.z + " Minus" + this.defz + " Ergebnis:" + newZValue);
	d_kd.setZ(parseInt(newZValue), 1);
};
DDObj.prototype.detachChild = function(d_kd)
{
	(d_kd = (typeof d_kd != "object")? this.children[d_kd]: d_kd).detached = 1;
};
DDObj.prototype.setZ = function(d_x, d_kds, d_o)
{
	if(d_kds)
	{
		var d_dz = d_x-this.z,
		d_i = this.children.length; while(d_i--)
			if(!(d_o = this.children[d_i]).detached)
            {
              var newZValue = parseInt(d_o.z)+parseInt(d_dz);
              //alert(parseInt(d_o.z) + " f1 zu " +parseInt(d_dz)+ " Ergebnis: " + newZValue);
              d_o.setZ(newZValue, 1);
            }
	}
	dd.z = Math.max(dd.z, this.z = this.div? ((this.css || this.div).zIndex = d_x) : 0);
};
DDObj.prototype.maximizeZ = function()
{
	this.setZ(parseInt(dd.z)+1, 1);
};
DDObj.prototype._resetZ = function(d_o)
{
	if(this.re_z || dd.re_z)
	{
		this.setZ(this.defz);
		var d_i = this.children.length; while(d_i--)
			if(!(d_o = this.children[d_i]).detached) d_o.setZ(d_o.defz);
	}
};
DDObj.prototype.setOpacity = function(d_x)
{
	this.opacity = d_x;
	this._setOpaRel(1.0, 1);
};
DDObj.prototype._setOpaRel = function(d_x, d_kd, d_y, d_o)
{
	if(this.diaphan || d_kd)
	{
		d_y = this.opacity*d_x;
		if(dd.n6) this.css.MozOpacity = d_y;
		else if(dd.ie && !dd.iemac)
		{
			if(this.css)
				this.css.filter = "Alpha(opacity="+parseInt(100*d_y)+")";
		}
		else if(this.css) this.css.opacity = d_y;
		var d_i = this.children.length; while(d_i--)
			if(!(d_o = this.children[d_i]).detached) d_o._setOpaRel(d_x, 1);
	}
};
DDObj.prototype.setCursor = function(d_x)
{
	this._setCrs(this.cursor = (d_x.indexOf('c:')+1)? d_x.substring(2) : d_x);
};
DDObj.prototype._setCrs = function(d_x)
{
	if(this.css) this.css.cursor = ((!dd.ie || dd.iemac) && d_x == 'hand')? 'pointer' : d_x;
};
DDObj.prototype.setDraggable = function(d_x)
{
	this.nodrag = !d_x*1;
	this._setCrs(d_x? this.cursor : 'auto');
};
DDObj.prototype.setResizable = function(d_x)
{
	this.resizable = d_x*1;
	if(d_x) this.scalable = 0;
};
DDObj.prototype.setScalable = function(d_x)
{
	this.scalable = d_x*1;
	if(d_x) this.resizable = 0;
};
DDObj.prototype.getEltBelow = function(d_ret, d_x, d_y)
{
	var d_o, d_cmp = -1, d_i = dd.elements.length; while(d_i--)
	{
		d_o = dd.elements[d_i];
		d_x = d_o.x-this.w/2;
		d_y = d_o.y-this.h/2;
		if(d_o.visible && d_o.z < this.z && this.x >= d_x && this.x <= d_x+d_o.w && this.y >= d_y && this.y <= d_y+d_o.h)
		{
			if(d_o.z > d_cmp)
			{
				d_cmp = d_o.z;
				d_ret = d_o;
			}
		}
	}
	return d_ret;
};
DDObj.prototype.del = function(d_os, d_o)
{
	var d_i;
	if(this.parent && this.parent._removeChild) this.parent._removeChild(this);
	if(this.original)
	{
		this.hide();
		if(this.original.copies)
		{
			d_os = new Array();
			for(d_i = 0; d_i < this.original.copies.length; d_i++)
				if((d_o = this.original.copies[d_i]) != this) d_os[d_o.name] = d_os[d_os.length] = d_o;
			this.original.copies = d_os;
		}
	}
	else if(this.is_image)
	{
		this.hide();
		if(this.oimg)
		{
		  if(dd.n4) this.oimg.src = this.defsrc;
		  else this.oimg.style.visibility = 'visible';
		}
	}
	else if(this.moveTo)
	{
		if(this.css) this.css.cursor = 'default';
		this.moveTo(this.defx, this.defy);
		this.resizeTo(this.defw, this.defh);
	}
	d_os = new Array();
	for(d_i = 0; d_i < dd.elements.length; d_i++)
	{
		if((d_o = dd.elements[d_i]) != this) d_os[d_o.name] = d_os[d_o.index = d_os.length] = d_o;
		else d_o._free();
	}
	dd.elements = d_os;
	if(!dd.n4) dd.recalc();
};
DDObj.prototype._free = function()
{
	for(var d_i in this)
		this[d_i] = null;
	dd.elements[this.name] = null;
};

dd.n4RectVis = function(vis)
{
	for(var d_i = 4; d_i--;)
	{
		dd.rectI[d_i].visibility = dd.rectA[d_i].visibility = vis? 'show' : 'hide';
		if(vis) dd.rectI[d_i].zIndex = dd.rectA[d_i].zIndex = dd.z+2;
	}
};
dd.n4RectPos = function(d_o, d_x, d_y, d_w, d_h)
{
	d_o.x = d_x;
	d_o.y = d_y;
	d_o.clip.width = d_w;
	d_o.clip.height = d_h;
};
// NN4: draw img resize rectangle
dd.n4Rect = function(d_w, d_h)
{
	var d_i;
	if(!dd.rectI)
	{
		dd.rectI = new Array();
		dd.rectA = new Array();
	}
	if(!dd.rectI[0])
	{
		for(d_i = 4; d_i--;)
		{
			(dd.rectI[d_i] = new Layer(1)).bgColor = '#000000';
			(dd.rectA[d_i] = new Layer(1)).bgColor = '#ffffff';
		}
	}
	if(!dd.rectI[0].visibility || dd.rectI[0].visibility == 'hide') dd.n4RectVis(1);
	dd.obj.w = d_w;
	dd.obj.h = d_h;
	for(d_i = 4; d_i--;)
	{
		dd.n4RectPos(dd.rectI[d_i], dd.obj.x + (!(d_i-1)? (dd.obj.w-1) : 0), dd.obj.y + (!(d_i-2)? (dd.obj.h-1) : 0), d_i&1 || dd.obj.w, !(d_i&1) || dd.obj.h);
		dd.n4RectPos(dd.rectA[d_i], !(d_i-1)? dd.rectI[1].x+1 : (dd.obj.x-1), !(d_i-2)? dd.rectI[2].y+1 : (dd.obj.y-1), d_i&1 || dd.obj.w+2, !(d_i&1) || dd.obj.h+2);
	}
};
dd.reszTo = function(d_w, d_h)
{
	if(dd.n4 && dd.obj.is_image) dd.n4Rect(d_w, d_h);
	else dd.obj.resizeTo(d_w, d_h);
};
dd.embedVis = function(d_vis)
{
	var d_o = new Array('iframe', 'applet', 'embed', 'object');
	var d_i = d_o.length; while(d_i--)
	{
		var d_p = dd.ie? document.all.tags(d_o[d_i]) : document.getElementsByTagName? document.getElementsByTagName(d_o[d_i]) : null;
		if(d_p)
		{
			var d_j = d_p.length; while(d_j--)
			{
				var d_q = d_p[d_j];
				while(d_q.offsetParent || d_q.parentNode)
				{
					if((d_q = d_q.parentNode || d_q.offsetParent || null) == dd.obj.div)
					{
						d_p[d_j].style.visibility = d_vis;
						break;
					}
				}
			}
		}
	}
};

dd.maxOffX = function(d_x, d_y)
{
	return(
		(dd.obj.maxoffl+1 && (d_y = dd.obj.defx-dd.obj.maxoffl)-d_x > 0
		|| dd.obj.maxoffr+1 && (d_y = dd.obj.defx+dd.obj.maxoffr)-d_x < 0)? d_y
		: d_x
	);
};
dd.maxOffY = function(d_x, d_y)
{
	return(
		(dd.obj.maxofft+1 && (d_y = dd.obj.defy-dd.obj.maxofft)-d_x > 0
		|| dd.obj.maxoffb+1 && (d_y = dd.obj.defy+dd.obj.maxoffb)-d_x < 0)? d_y
		: d_x
	);
};
dd.inWndW = function(d_x, d_y)
{
	var d_wx = dd.getScrollX(),
	d_ww = dd.getWndW();
	return(
		((d_y = d_wx+2)-d_x > 0) || ((d_y = d_wx+d_ww+dd.obj.w-2)-d_x < 0)? d_y
		: d_x
	);
};
dd.inWndH = function(d_x, d_y)
{
	var d_wy = dd.getScrollY(),
	d_wh = dd.getWndH();
	return(
		((d_y = d_wy+2)-d_x > 0) || ((d_y = d_wy+d_wh+dd.obj.h-2)-d_x < 0)? d_y
		: d_x
	);
};
// These two funcs limit the size of element when mouseresized.
// Implemented 22.5.2003 by Gregor Ltolf <gregor@milou.ch>, modified by Walter Zorn
dd.limW = function(d_w)
{
	return(
		(dd.obj.minw-d_w > 0)? dd.obj.minw
		: (dd.obj.maxw > 0 && dd.obj.maxw-d_w < 0)? dd.obj.maxw
		: d_w
	);
};
dd.limH = function(d_h)
{
	return(
		(dd.obj.minh-d_h > 0)? dd.obj.minh
		: (dd.obj.maxh > 0 && dd.obj.maxh-d_h < 0)? dd.obj.maxh
		: d_h
	);
};
// Optional autoscroll-page functionality. Courtesy Cedric Savarese.
// Implemented by Walter Zorn
function DDScroll()
{
	if(!dd.obj || !dd.obj.scroll && !dd.scroll || dd.ie4 || dd.whratio)
	{
		dd.scrx = dd.scry = 0;
		return;
	}
	var d_bnd = 0x1c,
	d_wx = dd.getScrollX(), d_wy = dd.getScrollY();
	if(dd.msmoved)
	{
		var d_ww = dd.getWndW(), d_wh = dd.getWndH(), d_y;
		dd.scrx = ((d_y = dd.e.x-d_ww-d_wx+d_bnd) > 0)? (d_y>>=2)*d_y
			: ((d_y = d_wx+d_bnd-dd.e.x) > 0)? -(d_y>>=2)*d_y
			: 0;
		dd.scry = ((d_y = dd.e.y-d_wh-d_wy+d_bnd) > 0)? (d_y>>=2)*d_y
			: ((d_y = d_wy+d_bnd-dd.e.y) > 0)? -(d_y>>=2)*d_y
			: 0;
	}
	if(dd.scrx || dd.scry)
	{
		window.scrollTo(
			d_wx + (dd.scrx = dd.obj.is_resized? dd.limW(dd.obj.w+dd.scrx)-dd.obj.w : dd.obj.vertical? 0 : (dd.maxOffX(dd.obj.x+dd.scrx)-dd.obj.x)),
			d_wy + (dd.scry = dd.obj.is_resized? dd.limH(dd.obj.h+dd.scry)-dd.obj.h : dd.obj.horizontal? 0 : (dd.maxOffY(dd.obj.y+dd.scry)-dd.obj.y))
		);
		dd.obj.is_dragged? dd.obj.moveTo(dd.obj.x+dd.getScrollX()-d_wx, dd.obj.y+dd.getScrollY()-d_wy)
			: dd.reszTo(dd.obj.w+dd.getScrollX()-d_wx, dd.obj.h+dd.getScrollY()-d_wy);
	}
	dd.msmoved = 0;
	window.setTimeout('DDScroll()', 0x33);
}
function PICK(d_ev)
{
	dd.e = new dd.evt(d_ev);
	if(dd.e.x >= dd.getWndW()+dd.getScrollX() || dd.e.y >= dd.getWndH()+dd.getScrollY()) return true; // on scrollbar
	var d_o, d_t, d_cmp = -1, d_i = dd.elements.length; while(d_i--)
	{
		d_o = dd.elements[d_i];
		if(dd.n4 && dd.e.but > 1 && dd.e.src == d_o.oimg && !d_o.clone) return false;
		if(d_o.visible && dd.e.but <= 1 && dd.e.x >= d_o.x && dd.e.x <= d_o.x+d_o.w && dd.e.y >= d_o.y && dd.e.y <= d_o.y+d_o.h)
		{
			if(d_o.z > d_cmp && (d_t = dd.e.src.tag).indexOf('inpu') < 0 && d_t.indexOf('texta') < 0 && d_t.indexOf('sele') < 0 && d_t.indexOf('opti') < 0 && d_t.indexOf('scrol') < 0)
			{
				d_cmp = d_o.z;
				dd.obj = d_o;
			}
		}
	}
	if(dd.obj)
	{
		if(dd.obj.nodrag) dd.obj = null;
		else
		{
			dd.e.e.cancelBubble = true;
			var d_rsz = dd.e.modifKey && (dd.obj.resizable || dd.obj.scalable);
			if(dd.op)
			{
				(d_o = document.getElementById('OpBlUr')).style.pixelLeft = dd.e.x;
				d_o.style.pixelTop = dd.e.y;
				(d_o = d_o.children[0].children[0]).focus();
				d_o.blur();
			}
			else if(dd.ie && !dd.ie4)
			{
				if(document.selection && document.selection.empty) document.selection.empty();
				dd.db.onselectstart = function()
				{
					event.returnValue = false;
				};
			}
			if(d_rsz)
			{
				dd.obj._setCrs('se-resize');
				dd.obj.is_resized = 1;
				dd.whratio = dd.obj.scalable? dd.obj.defw/dd.obj.defh : 0;
				if(dd.ie)
				{
					if(dd.ie4)
					{
						window.dd_x = dd.getScrollX();
						window.dd_y = dd.getScrollY();
					}
					setTimeout(
						'if(dd.obj && document.selection && document.selection.empty)'+
						'{'+
							'document.selection.empty();'+
							'if(dd.ie4) window.scrollTo(window.dd_x, window.dd_y);'+
						'}'
					,0);
				}
				dd.setMovHdl(RESIZE);
				dd.reszTo(dd.obj.w, dd.obj.h);
			}
			else
			{
				dd.obj.is_dragged = 1;
				dd.setMovHdl(DRAG);
			}
			dd.setUpHdl(DROP);
			dd.embedVis('hidden');
			dd.obj._setOpaRel(0.7);
			dd.obj.maximizeZ();
			dd.ofx = dd.obj.x+dd.obj.w-dd.e.x;
			dd.ofy = dd.obj.y+dd.obj.h-dd.e.y;
			if(window.my_PickFunc) my_PickFunc();
			if(dd.obj.pickFunc) dd.obj.pickFunc();
			DDScroll();
			return !(
				dd.obj.is_resized
				|| dd.n4 && dd.obj.is_image
				|| dd.n6 || dd.w3c
			);
		}
	}
	if(dd.downFunc) return dd.downFunc(d_ev);
	return true;
}
function DRAG(d_ev)
{
	if(!dd.obj || !dd.obj.visible) return true;
	if(dd.ie4 || dd.w3c || dd.n6 || dd.obj.children.length > 0xf)
	{
		if(dd.wait) return false;
		dd.wait = 1;
		setTimeout('dd.wait = 0;', dd.tiv);
	}
	dd.e = new dd.evt(d_ev);
	if(dd.ie && !dd.e.but)
	{
		DROP(d_ev);
		return true;
	}
	if (dd.obj.getDragLocked()==0)
	{
    	dd.msmoved = 1;
    	dd.obj.moveTo(
    		dd.obj.vertical? dd.obj.x : dd.maxOffX(dd.inWndW(dd.ofx+dd.e.x)-dd.obj.w),
    		dd.obj.horizontal? dd.obj.y : dd.maxOffY(dd.inWndH(dd.ofy+dd.e.y)-dd.obj.h)
    	);

    	if(window.my_DragFunc) my_DragFunc();
    	if(dd.obj.dragFunc) dd.obj.dragFunc();
    	if(dd.moveFunc) return dd.moveFunc(d_ev);
    }
	return false;
}
function RESIZE(d_ev)
{
	if(!dd.obj || !dd.obj.visible) return true;
	if(dd.wait) return false;

	dd.wait = 1;
	setTimeout('dd.wait = 0;', dd.tiv);
	dd.e = new dd.evt(d_ev);
	if(dd.ie && !dd.e.but)
	{
		DROP(d_ev);
		return true;
	}
	dd.msmoved = 1;
	var d_w = dd.limW(dd.inWndW(dd.ofx+dd.e.x)-dd.obj.x), d_h;
	if(!dd.whratio) d_h = dd.limH(dd.inWndH(dd.ofy+dd.e.y)-dd.obj.y);
	else
	{
		d_h = dd.limH(dd.inWndH(Math.round(d_w/dd.whratio)+dd.obj.y)-dd.obj.y);
		d_w = Math.round(d_h*dd.whratio);

	}
 
	dd.reszTo(d_w, d_h);
	if(window.my_ResizeFunc) my_ResizeFunc();
	if(dd.obj.resizeFunc) dd.obj.resizeFunc();
	if(dd.moveFunc) return dd.moveFunc(d_ev);
	return false;
}
function DROP(d_ev)
{
	if(dd.obj)
	{
		if(dd.obj.is_dragged)
		{
			if(!dd.obj.is_image) dd.getWH(dd.obj);
		}
		else if(dd.n4)
		{
			if(dd.obj.is_image)
			{
				dd.n4RectVis(0);
				dd.obj.resizeTo(dd.obj.w, dd.obj.h);
			}
		}
		if(!dd.n4 || !dd.obj.is_image) dd.recalc();
		dd.setMovHdl(dd.moveFunc);
		dd.setUpHdl(dd.upFunc);
		if(dd.db) dd.db.onselectstart = null;
		dd.obj._setOpaRel(1.0);
		dd.obj._setCrs(dd.obj.cursor);
		dd.embedVis('visible');
		dd.obj._resetZ();
		dd.e = new dd.evt(d_ev);
		if(window.my_DropFunc) my_DropFunc();
		if(dd.obj.dropFunc) dd.obj.dropFunc();
		dd.msmoved = dd.obj.is_dragged = dd.obj.is_resized = dd.whratio = 0;
		dd.obj = null;
	}
	dd.setDwnHdl(PICK);
}
function SET_DHTML()
{
	var d_a = arguments, d_ai, d_htm = '', d_o, d_i = d_a.length;
    while(d_i--)
	{
		if(!(d_ai = d_a[d_i]).indexOf('c:')) dd.cursor = d_ai.substring(2);
		else if(d_ai == NO_ALT) dd.noalt = 1;
		else if(d_ai == SCROLL) dd.scroll = 1;
		else if(d_ai == RESET_Z) dd.re_z = 1;
		else if(d_ai == RESIZABLE) dd.resizable = 1;
		else if(d_ai == SCALABLE) dd.scalable = 1;
		else if(d_ai == TRANSPARENT) dd.diaphan = 1;
		else
		{
			d_o = new DDObj(d_ai);
			dd.addElt(d_o);
			d_htm += d_o.t_htm || '';
			if(d_o.oimg && d_o.cpy_n)
			{
				var d_j = 0; while(d_j < d_o.cpy_n)
				{
					var d_p = new DDObj(d_o.name+d_o.cmd, ++d_j);
					dd.addElt(d_p, d_o);
					d_p.defz = d_o.defz+d_j;
					d_p.original = d_o;
					d_htm += d_p.t_htm;
				}
			}
		}
	}
	if(dd.n4 || dd.n6 || dd.ie || dd.op || dd.w3c) document.write(
		(dd.n4? '<div style="position:absolute;"><\/div>\n'
		: dd.op? '<div id="OpBlUr" style="position:absolute;visibility:hidden;width:0px;height:0px;"><form><input type="text" style="width:0px;height:0px;"><\/form><\/div>'
		: '') + d_htm
	);
	dd.z = 0x33;
	d_i = dd.elements.length; while(d_i--)
	{
		dd.addProps(d_o = dd.elements[d_i]);
		try
        {
            if(d_o.is_image && !d_o.original && !d_o.clone)
			dd.n4? d_o.oimg.src = spacer : d_o.oimg.style.visibility = 'hidden';
        }
        catch(err)
        {
        }
	}
	dd.mkWzDom();
	if(window.onload) dd.loadFunc = window.onload;
	if(window.onunload) dd.uloadFunc = window.onunload;
	window.onload = dd.initz;
	window.onunload = dd.finlz;
	dd.setDwnHdl(PICK);
}
function ADD_DHTML(d_o) // layers only!
{
	d_o = new DDObj(d_o);
	dd.addElt(d_o);
	dd.addProps(d_o);
	dd.mkWzDom();
}


////////////////////////////////////////////////////////////
// If not needed, all code below this line may be removed


// For backward compatibility
dd.d = document;			// < v. 2.72
var RESET_ZINDEX = RESET_Z; // < 3.44
var KEYDOWN_RESIZE = RESIZABLE; // < 4.43
var CURSOR_POINTER = CURSOR_HAND; // < 4.44
var NO_SCROLL = '';		 // < v. 4.49

function LD_setWorkplace(resizeWindow)
{
  //workplaceX = $('workingArea').style.left;
  //workplaceY = $('workingArea').style.top;
  workplaceX = LD_findPosX($('hruler')) + 15;
  workplaceY = LD_findPosY($('vruler'));
  
  //***** Mit 10px Abstand für Randabfallend
  //workplaceX = LD_findPosX($('hruler')) + 25;
  //workplaceY = LD_findPosY($('vruler')) + 10;

  workplaceMaxX = workplaceX + workingWidth;
  workplaceMaxY = workplaceY + workingHeight;
  if (LD_fuckingXMLObject.length<21)
  {
  	LD_fuckingXMLObject = LD_defaultXMLObject;
  }
  if (LD_fuckingXMLObject.length>20 && !resizeWindow)
  {
    var parser = new XMLParser();
    var doc = null;
    try {
      parser.parse(LD_fuckingXMLObject);
      doc = parser.doc;
    }
    catch (e) {
      LD_alert("Fehler beim Parsen der XML-Datei.");
    }
    if (doc != null)
    {
        var root = doc.getDocumentElement();
        var layoutArea = root.getElementsByTagName("layoutArea");
        var layoutAreaDpi = layoutArea[0].getElementsByTagName("dpi");
        var layoutAreaLayoutWidthSvr = layoutArea[0].getElementsByTagName("width");
        var layoutAreaLayoutHeightSvr = layoutArea[0].getElementsByTagName("height");

        var layoutAreaLayoutWidthSvrText = layoutAreaLayoutWidthSvr[0].getFirstChild();
        var layoutAreaLayoutHeightSvrText = layoutAreaLayoutHeightSvr[0].getFirstChild();
        var layoutAreaDpiText = layoutAreaDpi[0].getFirstChild();
        
        if (layoutAreaLayoutWidthSvrText.nodeValue != 0)
        {
          layoutHeight=layoutAreaLayoutHeightSvrText.nodeValue;
          layoutWidth=layoutAreaLayoutWidthSvrText.nodeValue;
        }

        if (layoutAreaDpiText.nodeValue != currentDPI)
        {
            $('Zoom').value = layoutAreaDpiText.nodeValue;
            LD_zoom();
            return (true);
        }
    }
    return (false);
  }
      
  else 
  {
	  if (layoutHeightSvr!=0 && layoutWidthSvr!=0)
	  {
	    layoutHeight=layoutHeightSvr;
	    layoutWidth=layoutWidthSvr;
	    return (false);
	  }
  }
  return (false);
}

function LD_setFocusLayout(value)
{
  focusOutsideLayout = value;
}

function LD_hideAll()
{
  var imageLayers = LD_getDraggableImageLayers();
 var dd_i = imageLayers.length; while(dd_i--)
 {
	imageLayers[dd_i].hide(true);
 }
var txtLayers = LD_getDraggableTextLayers();
 var dd_i = txtLayers.length; while(dd_i--)
 {
	txtLayers[dd_i].hide(true);
 }

  if (!LD_setWorkplace(false))
  {
    var src = LD_path;
	src +="getruler.aspx?type=horizontal&dpi=";
	src += defaultDPI;
	src += "&size=";
	src += horizontalRulerLength;
	$('hruler').src=src;

	src = LD_path;
	src +="getruler.aspx?type=vertical&dpi=";
	src += defaultDPI;
	src += "&size=";
	src += verticalRulerLength;
	$('vruler').src=src;
	
	var gridPath = "url(";
	gridPath += LD_path;
	gridPath += "getRuler.aspx?type=grid&dpi=";
	gridPath += defaultDPI;
    gridPath += "&sizex=";
    gridPath += gridWidth;
    gridPath += "&sizey=";
    gridPath += gridHeight;
    gridPath += "&wasxmm=";
    gridPath += layoutWidth;
    gridPath += "&wasymm=";
    gridPath += layoutHeight;
    gridPath += ")";
    
	$('DesignerLayer').style.backgroundImage = gridPath;
  }
	
LD_arrangeLiner();
LD_setEditorLayer();
LD_setUploadFormLayer();
dd.elements.FontTable.hide();
dd.elements.ColorTable.hide();
dd.elements.submitLayer.moveTo(LD_findPosX($('Zoom')) + 50,LD_findPosY($('Zoom')));
//****Load xmlObject if available

if (LD_fuckingXMLObject.length>1)
{
  var parser = new XMLParser();
  var doc = null;
  
  try {
      parser.parse(LD_fuckingXMLObject);
      doc = parser.doc;
    }
    catch (e) {
      LD_alert("Fehler beim Parsen der XML-Datei.");
    }
    if (doc != null)
    {
      LD_xmlToObject();
    }
}
}

function LD_deselectItem()
{
  if (lastpickedObject!=null)
  {
    if(LD_isDraggableTextElement(lastpickedObject))
    {
      LD_textChangedHidden();
    }
  }
  $('border').className='deselected';
  dd.elements.border.hide();
  lastpickedObject=null;
  $('txtEditorField').value = "Ihr Text";
  dd.elements.resizeElement.hide();
  $('editorTitle').className='editorTitleBlend';
  $('TextEditor').className='windowElementBodyBlend';
  if (dd.elements.FontTable.visible)
  {
    dd.elements.FontTable.hide();
  }
    if (dd.elements.ColorTable.visible)
  {
    dd.elements.ColorTable.hide();
  }
}

function LD_zoomStep(value)
{
  if (value)
  {
    var value = $('Zoom').value;
    if (value == 46)
    {
      $('Zoom').value = 92;
      LD_zoom();
    }
    else if (value == 92)
    {
      $('Zoom').value = 120;
      LD_zoom();
    }
    else if (value == 120)
    {
      $('Zoom').value = 138;
      LD_zoom();
    }
    /*
    else if (value == 138)
    {
      $('Zoom').value = 184;
      LD_zoom();
    }*/
  }
  else if (!value)
  {
    var value = $('Zoom').value;
    if (value == 184)
    {
      $('Zoom').value = 138;
      LD_zoom();
    }
    else if (value == 138)
    {
      $('Zoom').value = 120;
      LD_zoom();
    }
    else if (value == 120)
    {
      $('Zoom').value = 92;
      LD_zoom();
    }
    else if (value == 92)
    {
      $('Zoom').value = 46;
      LD_zoom();
    }
  }
}

function LD_zoom()
{
  var value = $('Zoom').value;
    var src = LD_path;
	src +="getruler.aspx?type=horizontal&dpi=";
	src += value;
	src += "&size=";
	src += horizontalRulerLength;
	$('hruler').src=src;

	src = LD_path;
	src +="getruler.aspx?type=vertical&dpi=";
	src += value;
	src += "&size=";
	src += verticalRulerLength;
	$('vruler').src=src;
	
	var gridPath = "url(";
	gridPath += LD_path;
	gridPath += "getRuler.aspx?type=grid&dpi=";
	gridPath += value;
    gridPath += "&sizex=";
    gridPath += gridWidth;
    gridPath += "&sizey=";
    gridPath += gridHeight;
    gridPath += "&wasxmm=";
    gridPath += layoutWidth;
    gridPath += "&wasymm=";
    gridPath += layoutHeight;
    gridPath += ")";

	$('DesignerLayer').style.backgroundImage = gridPath;

	var txtLayers = LD_getDraggableTextLayers();
    var dd_i = txtLayers.length; while(dd_i--)
    {
      if (txtLayers[dd_i].visible)
      {
       var ratio = value/currentDPI;
       var deltaX = txtLayers[dd_i].x - workplaceX;
       deltaX = Math.round(ratio*deltaX);
       var deltaY = txtLayers[dd_i].y - workplaceY;
       deltaY = Math.round(ratio*deltaY);
       txtLayers[dd_i].moveTo(workplaceX + deltaX, workplaceY + deltaY);
	   txtLayers[dd_i].setDpi(value);
   	   LD_setImageSource(txtLayers[dd_i]);
       LD_refreshTextZoom(txtLayers[dd_i]);
      }
    }

    var imageLayers = LD_getDraggableImageLayers();
     var dd_i = imageLayers.length; while(dd_i--)
     {
       if (imageLayers[dd_i].visible)
       {
       var ratio = value/currentDPI;
       imageLayers[dd_i].resizeTo(Math.round(ratio*imageLayers[dd_i].w), Math.round(ratio*imageLayers[dd_i].h) )
       imageLayers[dd_i].setDpi(value);
       var deltaX = imageLayers[dd_i].x - workplaceX;
       deltaX = Math.round(ratio*deltaX);
       var deltaY = imageLayers[dd_i].y - workplaceY;
       deltaY = Math.round(ratio*deltaY);
       imageLayers[dd_i].moveTo(workplaceX + deltaX, workplaceY + deltaY);
       LD_setImageSource(imageLayers[dd_i]);
       }
     }
     
     var ratio = value/currentDPI;
     var deltaX = dd.elements.vliner.x - workplaceX;
     var deltaY = dd.elements.hliner.y - workplaceY;
     deltaX = Math.round(ratio*deltaX);
     deltaY = Math.round(ratio*deltaY);
     dd.elements.vliner.moveTo(workplaceX + deltaX, dd.elements.vliner.y);
     dd.elements.hliner.moveTo(dd.elements.hliner.x, workplaceY + deltaY);
     
     currentDPI = value;
     LD_arrangeEdgeLiners();
     //LD_setBorderActive();
     LD_deselectItem();
}

function LD_xmlEncode(str)
{
    str=str.replace(new RegExp('\\&','g'),'&amp;');
    str=str.replace(new RegExp('\\<','g'),'&lt;');
    str=str.replace(new RegExp('\\>','g'),'&gt;');
    return (str);
}
function LD_xmlDecode(str)
{
  if (str!=null)
  {
    str=str.replace(new RegExp('&gt;','g'),'>');
    str=str.replace(new RegExp('&lt;','g'),'<');
    str=str.replace(new RegExp('&amp;','g'),'&');
    return (str);
  }
  return("");
}

function LD_urlEncode(str, getImage)
{
  str=encodeURIComponent(str);
  if (getImage)
  {
    //str=str.replace(new RegExp('\\+','g'),'%2B');
    //str=str.replace(new RegExp('\\&','g'),'%26');
  }
  //str=str.replace(new RegExp('%20','g'),'+');
  str=str.replace(new RegExp('%0D','g'),'');
  return str;
}

function LD_urlDecode(str, save)
{
    if (str!=null)
    {
        //str=str.replace(new RegExp('%26','g'),'\\&');
        //str=str.replace(new RegExp('%2B','g'),'\\+');
        str = decodeURIComponent(str);
        return (str);
    }
    return ("");
}

//************************ Function for Help bubble*******************

function LD_setCssHoverIn(hoveredElement, stringID)
{
  if(helpMode)
  {
    switch(stringID)
    {
      case("newDesign"):
      $('helpBubbleContent').innerHTML = newDesign;
      break;
      case("saveXML"):
      $('helpBubbleContent').innerHTML = saveXML;
      break;
      case("openXML"):
      $('helpBubbleContent').innerHTML = openXML;
      break;
      case("alignBottom"):
      $('helpBubbleContent').innerHTML = alignBottom;
      break;
      case("alignTop"):
      $('helpBubbleContent').innerHTML = alignTop;
      break;
      case("alignLeft"):
      $('helpBubbleContent').innerHTML = alignLeft;
      break;
      case("alignRight"):
      $('helpBubbleContent').innerHTML = alignRight;
      break;
      case("alignCenter"):
      $('helpBubbleContent').innerHTML = alignCenter;
      break;
      case("newText"):
      $('helpBubbleContent').innerHTML = newText;
      break;
      case("newImage"):
      $('helpBubbleContent').innerHTML = newImage;
      break;
      case("colorTable"):
      $('helpBubbleContent').innerHTML = colorTable;
      break;
      case("deleteObject"):
      $('helpBubbleContent').innerHTML = deleteObject;
      break;
      case("movieClap"):
      $('helpBubbleContent').innerHTML = movieClap;
      break;
      case("questionMark"):
      $('helpBubbleContent').innerHTML = questionMark;
      break;
      case("boldButton"):
      $('helpBubbleContent').innerHTML = boldButton;
      break;
      case("italicButton"):
      $('helpBubbleContent').innerHTML = italicButton;
      break;
      case("underlineButton"):
      $('helpBubbleContent').innerHTML = underlineButton;
      break;
      case("textLeftButton"):
      $('helpBubbleContent').innerHTML = textLeftButton;
      break;
      case("textCenterButton"):
      $('helpBubbleContent').innerHTML = textCenterButton;
      break;
      case("textRightButton"):
      $('helpBubbleContent').innerHTML = textRightButton;
      break;
      case("textSize"):
      $('helpBubbleContent').innerHTML = textSize;
      break;
      case("textFont"):
      $('helpBubbleContent').innerHTML = textFont;
      break;
      case("zoomIn"):
      $('helpBubbleContent').innerHTML = zoomIn;
      break;
      case("zoomOut"):
      $('helpBubbleContent').innerHTML = zoomOut;
      break;
      case("zoomDropDown"):
      $('helpBubbleContent').innerHTML = zoomDropDown;
      break;
      case("sendToBack"):
      $('helpBubbleContent').innerHTML = sendToBack;
      break;
      case("moveToCoord"):
      $('helpBubbleContent').innerHTML = moveToCoord;
      break;
      case("dragLock"):
      $('helpBubbleContent').innerHTML = dragLock;
      break;
      default:
      $('helpBubbleContent').innerHTML = "Keine Hilfe verf&uuml;gbar";
      break;
      
    }
    hoveredElement.className='toolButtonHelp';
    $('helpBubble').style.left = LD_findPosX(hoveredElement);
    $('helpBubble').style.top = LD_findPosY(hoveredElement)-84;
    $('helpBubble').style.visibility="visible";
  }
  else
  {
    hoveredElement.className='overtoolButton';
  }
}

function LD_setCssHoverOut(hoveredElement)
{
    hoveredElement.className='toolButton';
    $('helpBubble').style.visibility="hidden";
}

function LD_movieSite()
{
  var win = window.open('../catalog/LD_Designer/movies/cardprint_Text_Edit/cardprint_Text_Edit.php','popupWindow','toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,copyhistory=no,width=550,height=700,screenX=150,screenY=150,top=150,left=150');
  win.focus();
}

function LD_helpSwitch()
{
  if(helpMode)
  {
    helpMode=false;
    $('LD_TB').className='tooltable';
    $('toolbar').className='toolbar';
    $('LD_MAIN').className='LDMain';
    $('helpButton').className = "toolButton";
    
  }
  else
  {
    helpMode=true;
    $('LD_TB').className='helpTooltable';
    $('toolbar').className='HelpToolbar';
    $('LD_MAIN').className='helpLDMain';
    $('helpButton').className = "clicked";
  }
}
//************************ End Function for Help bubble*******************

function LD_setUploadFormLayer()
{

  dd.elements.uploadHeader.moveTo(workplaceX + uploadWindowX, workplaceY + uploadWindowY);
  dd.elements.uploadBody.moveTo(dd.elements.uploadHeader.x,dd.elements.uploadHeader.y+27);
  dd.elements.uploadHeader.addChild(dd.elements.uploadBody);
}

function LD_setEditorLayer()
{
  //dd.elements.editorTitle.hide();
  //dd.elements.editorTitle.swapImage(LD_path + "images/EditorTitle.png");
  //dd.elements.editorTitle.swapImage("images/EditorTitle.png");
  dd.elements.TextEditor.hide();
  dd.elements.editorTitle.hide();
  
  dd.elements.editorTitle.moveTo(workplaceX + TextWindowX, workplaceY + TextWindowY);
  dd.elements.TextEditor.moveTo(dd.elements.editorTitle.x,dd.elements.editorTitle.y+27);
  dd.elements.editorTitle.addChild(dd.elements.TextEditor);
}
function LD_showEditorLayer()
{
  dd.elements.editorTitle.show();
  dd.elements.TextEditor.show();
  var zIndex = 0;
  var textLayers = LD_getDraggableTextLayers();
  for(j=0;j<textLayers.length;j++)
  {
    if (textLayers[j].z > zIndex)
    {
     zIndex = parseInt(textLayers[j].z);
    }
  }
  var imageLayers = LD_getDraggableImageLayers();
  for(k=0;k<imageLayers.length;k++)
  {
    if (imageLayers[k].z > zIndex)
    {
     zIndex = parseInt(imageLayers[k].z);
    }
  }
  dd.elements.TextEditor.setZ(parseInt(zIndex)+1);
}

function LD_showUploadLayer()
{
  dd.elements.uploadHeader.show();
  dd.elements.uploadBody.show();
  $('uploadHeader').className='uploadHeaderBlend';
  $('uploadBody').className='windowElementBodyBlend';
  
  uploadInterval = window.setInterval("uploadTimer()",200);
}

function uploadTimer()
{
  window.clearInterval(uploadInterval);
  $('uploadHeader').className='uploadHeader';
  $('uploadBody').className='windowElementBody';
}

function LD_resizeTimer()
{
  dd.obj=dd.elements.vEdgeLiner;
  if(!dd.n4 || !dd.obj.is_image) dd.recalc();
  dd.obj=null;
}

function LD_hideUploadLayer()
{
  dd.elements.uploadHeader.hide();
  dd.elements.uploadBody.hide();
}

function LD_hideEditorLayer()
{
  dd.elements.editorTitle.hide();
  dd.elements.TextEditor.hide();
}

function LD_arrangeEdgeLiners()
{
    dd.elements.vEdgeLiner.moveTo(Math.round(cardWidth/25.4*currentDPI)+workplaceX,workplaceY);
    dd.elements.hEdgeLiner.moveTo(workplaceX,Math.round(cardHeight/25.4*currentDPI)+workplaceY);
    dd.elements.vEdgeLiner.resizeTo(2,Math.round(cardHeight/25.4*currentDPI)+30);
    dd.elements.hEdgeLiner.resizeTo(Math.round(cardWidth/25.4*currentDPI)+30,2);
    dd.elements.cutterUp.moveTo(dd.elements.vEdgeLiner.x-7,dd.elements.vEdgeLiner.y+dd.elements.vEdgeLiner.h-16);
    dd.elements.cutterLeft.moveTo(dd.elements.hEdgeLiner.x+dd.elements.hEdgeLiner.w-16,dd.elements.hEdgeLiner.y-7);
    
    dd.elements.vLeftLiner.moveTo(workplaceX-1,workplaceY);
    dd.elements.hTopLiner.moveTo(workplaceX,workplaceY-1);
    dd.elements.vLeftLiner.resizeTo(2,Math.round(cardHeight/25.4*currentDPI));
    dd.elements.hTopLiner.resizeTo(Math.round(cardWidth/25.4*currentDPI),2);
}

function LD_arrangeLiner()
{
    dd.elements.vliner.resizeTo(5,vlinerInitLength);
    dd.elements.hliner.resizeTo(hlinerInitLength,5);
    dd.elements.vliner.moveTo(workplaceX+Math.round(cardWidth/50.8*currentDPI),workplaceY-10);
    dd.elements.hliner.moveTo(workplaceX-10,workplaceY+Math.round(cardHeight/50.8*currentDPI));
    LD_arrangeEdgeLiners();


    var zIndex = 0;
  var textLayers = LD_getDraggableTextLayers();
  for(j=0;j<textLayers.length;j++)
  {
    if (textLayers[j].z > zIndex)
    {
     zIndex = parseInt(textLayers[j].z);
    }
  }
  var imageLayers = LD_getDraggableImageLayers();
  for(k=0;k<imageLayers.length;k++)
  {
    if (imageLayers[k].z > zIndex)
    {
     zIndex = parseInt(imageLayers[k].z);
    }
  }
  dd.elements.hliner.setZ(parseInt(zIndex)+1);
  dd.elements.vliner.setZ(parseInt(zIndex)+1);
  dd.elements.hEdgeLiner.setZ(parseInt(zIndex)+1);
  dd.elements.vEdgeLiner.setZ(parseInt(zIndex)+1);
  dd.elements.vLeftLiner.setZ(parseInt(zIndex)+1);
  dd.elements.hTopLiner.setZ(parseInt(zIndex)+1);
  dd.elements.cutterUp.setZ(parseInt(zIndex)+1);
  dd.elements.cutterLeft.setZ(parseInt(zIndex)+1);
}

function LD_reloadPage()
{
  window.location.reload();
}


function LD_isDraggableTextElement(obj)
{
  var textLayers = LD_getDraggableTextLayers();
  for(j=0;j<textLayers.length;j++)
  {
    if (obj==textLayers[j])
    {
      return true;
    }
  }
  return false;

}

function LD_isDraggableDesignElement(obj)
{
  var imageLayers = LD_getDraggableImageLayers();
  var textLayers = LD_getDraggableTextLayers();
  
  for(i=0;i<imageLayers.length;i++)
  {
    if (obj==imageLayers[i])
    {
      return true;
    }
  }
  for(j=0;j<textLayers.length;j++)
  {
    if (obj==textLayers[j])
    {
      return true;
    }
  }
  return false;
}

function LD_getDraggableImageLayers()
{
  var arrayList = new Array(dd.elements.img1, dd.elements.img2, dd.elements.img3, dd.elements.img4, dd.elements.img5, dd.elements.img6, dd.elements.img7, dd.elements.img8, dd.elements.img9, dd.elements.img10);
  return arrayList;
}

function LD_getDraggableTextLayers()
{
  var arrayList = new Array(dd.elements.txt1, dd.elements.txt2, dd.elements.txt3, dd.elements.txt4, dd.elements.txt5, dd.elements.txt6, dd.elements.txt7, dd.elements.txt8, dd.elements.txt9, dd.elements.txt10);
  return arrayList;
}

function LD_addImageLayer()
{
  var imageLayers = LD_getDraggableImageLayers();
  var count = imageLayers.length;
  var i = 0;
  var amountExceeded = true;
  while(i<count)
    {
    	if (!imageLayers[i].visible)
        {
            lastpickedObject = imageLayers[i];
        	imageLayers[i].show();
        	imageLayers[i].moveTo(workplaceX,workplaceY);
        	LD_refreshText(imageLayers[i]);

            //set Border when addin a new Layer.
            LD_setBorderActive();
            amountExceeded = false;
        	break;
         }
         i++;
    }
    if (amountExceeded)
    {
      alert("Maximale Objektanzahl überschritten");
    }
}

function LD_deleteLayer()
{
  if (lastpickedObject!=null)
  {
    if (lastpickedObject.getLockLevel()==2)
        alert("Dieses Objekt kann nicht gelöscht werden.");
    else if (window.confirm( "Wollen Sie das Objekt wirklich entfernen?" ))
    {

         lastpickedObject.swapImage(lastpickedObject.defsrc);
         lastpickedObject.setTXT("Ihr Text");
         lastpickedObject.setDpi(defaultDPI);
         lastpickedObject.setAlign(0);
    	lastpickedObject.setColor('000000');
    	lastpickedObject.setUnderline(0);
    	lastpickedObject.setItalic(0);
    	lastpickedObject.setBold(0);
    	lastpickedObject.setSize(12);
    	lastpickedObject.setFont('Arial');

         lastpickedObject.resizeTo(0,0);
         lastpickedObject.hide();
         $('border').className='deselected';
         lastpickedObject = null;
         dd.elements.resizeElement.hide();
    }
   }
}

function LD_setTextLook(isTextElement)
{
  if (isTextElement)
  {
      if (lastpickedObject.getBold()==1)
        $('boldButton').className='clicked';
        else
        $('boldButton').className='toolButton';
      if (lastpickedObject.getItalic()==1)
        $('italicButton').className='clicked';
        else
        $('italicButton').className='toolButton';
      if (lastpickedObject.getUnderline()==1)
        $('underlineButton').className='clicked';
        else
        $('underlineButton').className='toolButton';
        
      if (lastpickedObject.getAlign()==0)
        $('leftAlignButton').className='clicked';
        else
        $('leftAlignButton').className='toolButton';
      if (lastpickedObject.getAlign()==1)
        $('centerAlignButton').className='clicked';
        else
        $('centerAlignButton').className='toolButton';
      if (lastpickedObject.getAlign()==2)
        $('rightAlignButton').className='clicked';
        else
        $('rightAlignButton').className='toolButton';
        
      if (lastpickedObject.getDragLocked()==1)
        $('dragLock').className='clicked';
        else
        $('dragLock').className='toolButton';
        
      $('editorTitle').className='editorTitle';
      $('TextEditor').className='windowElementBody';
      LD_setTextProperties();
  }
  else
  {
      $('editorTitle').className='editorTitleBlend';
      $('TextEditor').className='windowElementBodyBlend';
        for(i=0;i<LD_smartTextButtons.length;i++)
    {
      $(LD_smartTextButtons[i]).className = "disabledtoolButton";
    }
    
    if (lastpickedObject.getDragLocked()==1)
        $('dragLock').className='clicked';
        else
        $('dragLock').className='toolButton';
  }
}

function LD_helpButtonOut()
{
    if (helpMode)
    $('helpButton').className='clicked';
    else
    $('helpButton').className='toolButton';
}

function LD_toolButtonOut(toolButton)
{
  if (lastpickedObject!=null)
  {
      if (LD_isDraggableTextElement(lastpickedObject))
      {
        LD_setTextLook(true);
      }
      else
      {
        LD_setTextLook(false);
      }
  }
  else
  {
    toolButton.className = "toolButton";
  }
}

function LD_leftAlign()
{
  var vertical = dd.elements.vliner.x;
  if (lastpickedObject!=null)
  {
    LD_moveDesignObject(vertical+3, lastpickedObject.y, lastpickedObject, false, true );
  }

}

function LD_rightAlign()
{
  var vertical = dd.elements.vliner.x;
  if (lastpickedObject!=null)
  {
    LD_moveDesignObject(vertical+3-lastpickedObject.w, lastpickedObject.y, lastpickedObject, false, true );
  }

}

function LD_bottomAlign()
{
  var horizontal = dd.elements.hliner.y;
  if (lastpickedObject!=null)
  {
    LD_moveDesignObject(lastpickedObject.x, horizontal+3-(lastpickedObject.h), lastpickedObject, false, true );
  }

}
function LD_topAlign()
{
  var horizontal = dd.elements.hliner.y;
  if (lastpickedObject!=null)
  {
    LD_moveDesignObject(lastpickedObject.x, horizontal+3, lastpickedObject, false, true );
  }

}
function LD_centerAlign()
{
    var vertical = dd.elements.vliner.x;
  if (lastpickedObject!=null)
  {
    LD_moveDesignObject(vertical+3-(lastpickedObject.w/2), lastpickedObject.y, lastpickedObject, false, true );
  }

}

function LD_targetAlign()
{
  var vertical = dd.elements.vliner.x;
  var horizontal = dd.elements.hliner.y;
  if (lastpickedObject!=null)
  {
    LD_moveDesignObject(vertical+3-(lastpickedObject.w/2),horizontal+3-(lastpickedObject.h/2), lastpickedObject, false, true );
  }
}

function LD_switchDragLock()
{
  if (!layoutDragLocked)
      {
        layoutDragLocked = true;
        var txtLayers = LD_getDraggableTextLayers();
        var dd_i = txtLayers.length; while(dd_i--)
        {
          txtLayers[dd_i].setDragLocked(1);
          txtLayers[dd_i].setCursor("DEFAULT");
        }
        var imageLayers = LD_getDraggableImageLayers();
        var dd_i = imageLayers.length; while(dd_i--)
        {
          imageLayers[dd_i].setDragLocked(1);
          imageLayers[dd_i].setCursor("DEFAULT");
        }
        dd.elements.resizeElement.hide();
        var srcPath = LD_path;
        srcPath +="/images/lock.png";
        $('lockPicture').src = srcPath;
        //dd.elements.resizeElement.setDragLocked(1);
        //lastpickedObject.setDragLocked(1);
        //lastpickedObject.setCursor("DEFAULT");
      }
      else
      {
        layoutDragLocked = false;
        var txtLayers = LD_getDraggableTextLayers();
        var dd_i = txtLayers.length; while(dd_i--)
        {
          if (txtLayers[dd_i].getLockLevel()==0)
          {
              txtLayers[dd_i].setDragLocked(0);
              txtLayers[dd_i].setCursor("MOVE");
          }
        }
        var imageLayers = LD_getDraggableImageLayers();
        var dd_i = imageLayers.length; while(dd_i--)
        {
          if (imageLayers[dd_i].getLockLevel()!=2)
          {
              imageLayers[dd_i].setDragLocked(0);
              imageLayers[dd_i].setCursor("MOVE");
          }
        }
        if (!LD_isDraggableTextElement(lastpickedObject) && lastpickedObject!=null)
        {
           dd.elements.resizeElement.show();
        }
        var srcPath = LD_path;
        srcPath +="/images/lockopen.png";
        $('lockPicture').src = srcPath;
        //dd.elements.resizeElement.setDragLocked(0);
        //lastpickedObject.setDragLocked(0);
        //lastpickedObject.setCursor("MOVE");
      }
  /***** Lösung mit einzeln locken....
  if (lastpickedObject!=null)
  {
    if (LD_isDraggableDesignElement(lastpickedObject))
    {
      if (dd.elements.txt1.getDragLocked()== 0)
      {
        var txtLayers = LD_getDraggableTextLayers();
        var dd_i = txtLayers.length; while(dd_i--)
        {
          txtLayers[dd_i].setDragLocked(1);
          txtLayers[dd_i].setCursor("DEFAULT");
        }
        var imageLayers = LD_getDraggableImageLayers();
        var dd_i = imageLayers.length; while(dd_i--)
        {
          imageLayers[dd_i].setDragLocked(1);
          imageLayers[dd_i].setCursor("DEFAULT");
        }
        dd.elements.resizeElement.hide();
        var srcPath = LD_path;
        srcPath +="/images/lock.png";
        $('lockPicture').src = srcPath;
        //dd.elements.resizeElement.setDragLocked(1);
        //lastpickedObject.setDragLocked(1);
        //lastpickedObject.setCursor("DEFAULT");
      }
      else
      {
        var txtLayers = LD_getDraggableTextLayers();
        var dd_i = txtLayers.length; while(dd_i--)
        {
          txtLayers[dd_i].setDragLocked(0);
          txtLayers[dd_i].setCursor("MOVE");
        }
        var imageLayers = LD_getDraggableImageLayers();
        var dd_i = imageLayers.length; while(dd_i--)
        {
          imageLayers[dd_i].setDragLocked(0);
          imageLayers[dd_i].setCursor("MOVE");
        }
        if (!LD_isDraggableTextElement(lastpickedObject))
            dd.elements.resizeElement.show();
        var srcPath = LD_path;
        srcPath +="/images/BottomAlign.png";
        $('lockPicture').src = srcPath;
        //dd.elements.resizeElement.setDragLocked(0);
        //lastpickedObject.setDragLocked(0);
        //lastpickedObject.setCursor("MOVE");
      }
    }
  }***********************************************/
}

function LD_resizeResponse(originalRequest)
{
  var reply = originalRequest.responseText;
  var reply_Array=reply.split(";");
  if ( LD_isDraggableDesignElement(dd.elements[reply_Array[2]]) )
  {
    lastpickedObject = dd.elements[reply_Array[2]];
    var centerXValue = lastpickedObject.x + (lastpickedObject.w / 2);
    var rightXValue = lastpickedObject.x + (lastpickedObject.w);
    dd.elements[reply_Array[2]].resizeTo(reply_Array[0],reply_Array[1]);
    if (lastpickedObject.getAlign()==1)
    {
      var deltaX = lastpickedObject.x + (lastpickedObject.w / 2) - centerXValue;
      lastpickedObject.moveBy(-deltaX,0);
    }
    else if (lastpickedObject.getAlign()==2)
    {
      var deltaX = lastpickedObject.x + (lastpickedObject.w) - rightXValue;
      lastpickedObject.moveBy(-deltaX,0);
    }
    if (reply_Array.length>3)
    {
      //lastpickedObject.swapImage(reply_Array[3]);
      LD_setImageSource(lastpickedObject);
    }
    LD_setBorderActive();
    LD_manageZAxis();
  }
}

function LD_resizeResponseHidden(originalRequest)
{
  var reply = originalRequest.responseText;
  var reply_Array=reply.split(";");
  if ( LD_isDraggableDesignElement(dd.elements[reply_Array[2]]) )
  {
    var tempObj = dd.elements[reply_Array[2]];
    var centerXValue = tempObj.x + (tempObj.w / 2);
    var rightXValue = tempObj.x + (tempObj.w);
    dd.elements[reply_Array[2]].resizeTo(reply_Array[0],reply_Array[1]);
    if (tempObj.getAlign()==1)
    {
      var deltaX = tempObj.x + (tempObj.w / 2) - centerXValue;
      tempObj.moveBy(-deltaX,0);
    }
    else if (tempObj.getAlign()==2)
    {
      var deltaX = tempObj.x + (tempObj.w) - rightXValue;
      tempObj.moveBy(-deltaX,0);
    }
    if (reply_Array.length>3)
    {
      //lastpickedObject.swapImage(reply_Array[3]);
      LD_setImageSource(tempObj);
    }
  }
}

function LD_resizeResponseZoom(originalRequest)
{
  var reply = originalRequest.responseText;
  var reply_Array=reply.split(";");
  if ( LD_isDraggableDesignElement(dd.elements[reply_Array[2]]) )
  {
    //lastpickedObject = dd.elements[reply_Array[2]];
    //var centerXValue = lastpickedObject.x + (lastpickedObject.w / 2);
    //var rightXValue = lastpickedObject.x + (lastpickedObject.w);
    var redrawObject = dd.elements[reply_Array[2]];
    var centerXValue = redrawObject.x + (redrawObject.w / 2);
    var rightXValue = redrawObject.x + (redrawObject.w);
    
    dd.elements[reply_Array[2]].resizeTo(reply_Array[0],reply_Array[1]);
    if (reply_Array.length>3)
    {
      //lastpickedObject.swapImage(reply_Array[3]);
      //LD_setImageSource(lastpickedObject);
      LD_setImageSource(redrawObject);
    }
    //LD_setBorderActive();
    LD_manageZAxis();
  }
}

function LD_cancelSubmit()
{
  if (uploadingProcess)
  {
      $('btnUpload').disabled=false;
      uploadingProcess=false;
      var progressPath = LD_path;
      progressPath += "images/transparentpixel.gif";
      $('progressBar').src=progressPath;
      
      if (lastpickedObject != null)
        {
         lastpickedObject.swapImage(lastpickedObject.defsrc);
         lastpickedObject.setTXT("Ihr Text");
         lastpickedObject.setDpi(defaultDPI);
         lastpickedObject.setAlign(0);
    	lastpickedObject.setColor('000000');
    	lastpickedObject.setUnderline(0);
    	lastpickedObject.setItalic(0);
    	lastpickedObject.setBold(0);
    	lastpickedObject.setSize(12);
    	lastpickedObject.setFont('Arial');

         lastpickedObject.resizeTo(0,0);
         lastpickedObject.hide();
         $('border').className='deselected';
         lastpickedObject = null;
         dd.elements.resizeElement.hide();
        }
   }
}

function LD_submitform()
{
  if (!uploadingProcess)
  {
    if ($('uploadedfile').value.length>0)
    {
      LD_addImageLayer();
      if (lastpickedObject!=null)
      {
          $('btnUpload').disabled=true;
          uploadingProcess=true;
          var progressPath = LD_path;
          progressPath += "images/progress.gif";
          $('progressBar').src=progressPath;
          $('imageId').value = lastpickedObject.name;
          lastpickedObject.setDpi(currentDPI);
          $('dpi').value = currentDPI;
          $('submitImageForm').submit();
          //change dpi from upload...
      }
    }
    else
    {
      alert("Es wurde kein File angegeben!");
    }
  }
}

function LD_sendToBack()
{
  if (lastpickedObject != null)
  {
    if (LD_isDraggableDesignElement(lastpickedObject))
    {
        var zIndex = 0;
        var textLayers = LD_getDraggableTextLayers();
        for(j=0;j<textLayers.length;j++)
        {
          if (textLayers[j].z < zIndex)
          {
           zIndex = parseInt(textLayers[j].z);
          }
        }
        var imageLayers = LD_getDraggableImageLayers();
        for(k=0;k<imageLayers.length;k++)
        {
          if (imageLayers[k].z < zIndex)
          {
           zIndex = parseInt(imageLayers[k].z);
          }
        }
        if (zIndex<=1)
        {
            for(j=0;j<textLayers.length;j++)
            {
              textLayers[j].setZ(parseInt(textLayers[j].z)+1)
            }
            for(k=0;k<imageLayers.length;k++)
            {
              imageLayers[k].setZ(parseInt(imageLayers[k].z)+1)
            }
            lastpickedObject.setZ(1);
            LD_deselectItem();
        }
        else
        {
          lastpickedObject.setZ(parseInt(zIndex)-1);
          LD_deselectItem();
        }
    }
  }
}

function LD_setImageSource(obj)
{

  if (LD_isDraggableDesignElement(obj) && LD_isDraggableTextElement(obj))
  {

      //var requestURL = "http://melbourne/graphicDesignerSvr/gettext.aspx?";
      var requestURL = LD_path;
      requestURL += "getText.aspx?";
      requestURL += "dpi=";
      requestURL += obj.getDpi();
      requestURL += "&size=" + obj.getSize();
      requestURL += "&text=" + LD_urlEncode(obj.getTXT(),true);
      requestURL += "&font=" + obj.getFont();
      requestURL += "&bold=" + obj.getBold();
      requestURL += "&underline=" + obj.getUnderline();
      requestURL += "&italic=" + obj.getItalic();
      requestURL += "&align=" + obj.getAlign();
      requestURL += "&color="+ obj.getColor();
      requestURL += "&sizeonly=0";
      requestURL += "&id=" + obj.name;
      
      obj.swapImage(requestURL);

  }
  
  else if (LD_isDraggableDesignElement(obj) && !LD_isDraggableTextElement(obj))
  {
      //var requestURL = "http://melbourne/graphicDesignerSvr/gettext.aspx?";
      var requestURL = LD_path;
      requestURL += "getImage.aspx?";
      requestURL += "dpi=";
      requestURL += obj.getDpi();
      requestURL += "&width=" + obj.w;
      requestURL += "&height=" + obj.h;
      requestURL += "&id=" + obj.name;
      requestURL += "&sizeonly=0";
      requestURL += "&sessionId=" + sessionID;
      obj.swapImage(requestURL);
  }
  return true;
}

function popup(url) {
  args = 'width=430,height=500,resizable';
  ok = window.open(url,'',args)
  if (ok) return false;
  else return true;
}

function LD_xmlToObject()
{
  var parser = new XMLParser();
  var doc = null;
  var reply = "";
  if (LD_fuckingXMLObject.length>1)
  {
    reply = LD_fuckingXMLObject;
    //reply = LD_urlDecode(reply);
  }
  
    try {
      parser.parse(reply);
      doc = parser.doc;
    }
    catch (e) {
      LD_debugtext("Fehler beim Parsen der XML-Datei.");
    }

    if (doc != null) {
      var root = doc.getDocumentElement();
      var imageLayers = root.getElementsByTagName("imageLayer");
      var textLayers = root.getElementsByTagName("textLayer");
      var maxZindex = 1;
      
      for(i=0;i<imageLayers.length;i++)
      {
        //LD_debugtext (idText.nodeValue);
          var id = imageLayers[i].getElementsByTagName("id");
          var idText = id[0].getFirstChild();
          var xPos = imageLayers[i].getElementsByTagName("x");
          var xPosText = xPos[0].getFirstChild();
          var yPos = imageLayers[i].getElementsByTagName("y");
          var yPosText = yPos[0].getFirstChild();
          var hValue = imageLayers[i].getElementsByTagName("h");
          var hValueText = hValue[0].getFirstChild();
          var wValue = imageLayers[i].getElementsByTagName("w");
          var wValueText = wValue[0].getFirstChild();
          var zPosition = imageLayers[i].getElementsByTagName("z");
          var zPositionText = zPosition[0].getFirstChild();
          var dpiValue = imageLayers[i].getElementsByTagName("dpi");
          var dpiValueText = dpiValue[0].getFirstChild();
          var lockLevelValue = imageLayers[i].getElementsByTagName("locklevel");
          var objectLockLevel;
          if (lockLevelValue[0]!=null)
          {
            var lockLevelValueText = lockLevelValue[0].getFirstChild();
            objectLockLevel = lockLevelValueText.nodeValue;
            if (objectLockLevel>4)
                objectLockLevel=0;
          }
          else
          {
            objectLockLevel = 0;
          }
          var newTooltip = "Masse (BxH): ";
          var heightPx=hValueText.nodeValue;
          var widthPx=wValueText.nodeValue;
          try
          {
            heightPx = (heightPx)/currentDPI*25.4;
            widthPx = (widthPx)/currentDPI*25.4;
            heightPx = Math.round(heightPx*10)/10;
            widthPx = Math.round(widthPx*10)/10;
            newTooltip += widthPx;
            newTooltip += "x";
            newTooltip += heightPx;
            newTooltip += "mm";
          }
          catch(e)
          {}
          //var ddEnabled = imageLayers[i].getElementsByTagName("ddenabled");
          //var ddEnabledText = ddEnabled[0].getFirstChild();
          //set objectAttributes here... ToDo
          var LD_Object = dd.elements[idText.nodeValue];
          LD_Object.nimg.title = newTooltip;
          LD_Object.moveTo(xPosText.nodeValue, yPosText.nodeValue);
          if (dd.ie)
          {
            LD_Object.moveBy(workplaceX,workplaceY);
          }
          LD_Object.resizeTo(wValueText.nodeValue, hValueText.nodeValue);
          LD_Object.defh = hValueText.nodeValue;
          LD_Object.defw = wValueText.nodeValue;
          LD_Object.setZ(parseInt(maxZindex) + parseInt(zPositionText.nodeValue));
          LD_Object.setDpi(dpiValueText.nodeValue);
          LD_Object.setLockLevel(objectLockLevel);
          if (objectLockLevel==2)
          {
            LD_Object.setDraggable(false);
          }
          else if (objectLockLevel==1)
          {
            LD_Object.setDragLocked(1);
          }
          //if (ddEnabledText.nodeValue=="0")
          //LD_Object.setDraggable(false);
          LD_setImageSource(LD_Object);
          LD_Object.show();
      }
      
       for(i=0;i<textLayers.length;i++)
      {
          var id = textLayers[i].getElementsByTagName("id");
          var idText = id[0].getFirstChild();
          var xPos = textLayers[i].getElementsByTagName("x");
          var xPosText = xPos[0].getFirstChild();
          var yPos = textLayers[i].getElementsByTagName("y");
          var yPosText = yPos[0].getFirstChild();
          var hValue = textLayers[i].getElementsByTagName("h");
          var hValueText = hValue[0].getFirstChild();
          var wValue = textLayers[i].getElementsByTagName("w");
          var wValueText = wValue[0].getFirstChild();
          var zPosition = textLayers[i].getElementsByTagName("z");
          var zPositionText = zPosition[0].getFirstChild();
          var dpiValue = textLayers[i].getElementsByTagName("dpi");
          var dpiValueText = dpiValue[0].getFirstChild();
          var objectLockLevel;
          var lockLevelValue = textLayers[i].getElementsByTagName("locklevel");
          if (lockLevelValue[0]!=null)
          {
            var lockLevelValueText = lockLevelValue[0].getFirstChild();
            objectLockLevel = lockLevelValueText.nodeValue;
            if (objectLockLevel>4)
                objectLockLevel=0;
          }
          else
          {
            objectLockLevel = 0;
          }
          //var ddEnabled = imageLayers[i].getElementsByTagName("ddenabled");
          //var ddEnabledText = ddEnabled[0].getFirstChild();
          
          var size = textLayers[i].getElementsByTagName("size");
          var sizeText = size[0].getFirstChild();
          var content = textLayers[i].getElementsByTagName("text");
          var contentText = content[0].getFirstChild();
          var font = textLayers[i].getElementsByTagName("font");
          var fontText = font[0].getFirstChild();
          var bold = textLayers[i].getElementsByTagName("bold");
          var boldText = bold[0].getFirstChild();
          var italic = textLayers[i].getElementsByTagName("italic");
          var italicText = italic[0].getFirstChild();
          var underline = textLayers[i].getElementsByTagName("underline");
          var underlineText = underline[0].getFirstChild();
          var align = textLayers[i].getElementsByTagName("align");
          var alignText = align[0].getFirstChild();
          var color = textLayers[i].getElementsByTagName("color");
          var colorText = color[0].getFirstChild();
          
          var LD_Object = dd.elements[idText.nodeValue];

          LD_Object.moveTo(xPosText.nodeValue, yPosText.nodeValue);
          if (dd.ie)
          {
            LD_Object.moveBy(workplaceX,workplaceY);
          }
          LD_Object.resizeTo(wValueText.nodeValue, hValueText.nodeValue);
          LD_Object.setSize(sizeText.nodeValue);
          
          try
          {
            LD_xmlDecode(contentText.nodeValue);
          }
          catch (e)
          {
            continue;
          }

          LD_Object.setTXT(LD_xmlDecode(contentText.nodeValue));
          LD_Object.setFont(LD_xmlDecode(fontText.nodeValue));
          LD_Object.setBold(boldText.nodeValue);
          LD_Object.setItalic(italicText.nodeValue);
          LD_Object.setUnderline(underlineText.nodeValue);
          LD_Object.setAlign(alignText.nodeValue);
          LD_Object.setColor(LD_xmlDecode(colorText.nodeValue));
          LD_Object.setLockLevel(objectLockLevel);
          if (objectLockLevel==2)
          {
            LD_Object.setDraggable(false);
          }
          else if (objectLockLevel==1)
          {
            objectLockLevel = 1;
            LD_Object.setDragLocked(1);
          }
          
          var newTooltip = "RGB (HEX): #";
          newTooltip += LD_xmlDecode(colorText.nodeValue);
          try
          {
            LD_Object.nimg.title = newTooltip;
          }
          catch(e)
          {}
          LD_Object.setDpi(dpiValueText.nodeValue);
          LD_Object.setZ(parseInt(maxZindex) + parseInt(zPositionText.nodeValue));
          //if (ddEnabledText.nodeValue=="0")
          //  LD_Object.setDraggable(false);
          LD_Object.show();
          
          var requestURL = LD_path;
          requestURL += "getText.aspx?";
          requestURL += "dpi=";
          requestURL += LD_Object.getDpi();
          requestURL += "&size=" + LD_Object.getSize();
          requestURL += "&text=" + LD_urlEncode(LD_Object.getTXT(),false);
          requestURL += "&font=" + LD_Object.getFont();
          requestURL += "&bold=" + LD_Object.getBold();
          requestURL += "&underline=" + LD_Object.getUnderline();
          requestURL += "&italic=" + LD_Object.getItalic();
          requestURL += "&align=" + LD_Object.getAlign();
          requestURL += "&color="+ LD_Object.getColor();
          requestURL += "&sizeonly=0";
          requestURL += "&id=" + LD_Object.name;

          LD_Object.swapImage(requestURL);
      }
      LD_manageZAxis();
    }
}

function LD_getMMfromPixel(pixelValue)
{
  var mmValue = (pixelValue)/currentDPI*25.4;
  mmValue = Math.round(mmValue*10)/10;
  return (mmValue);
}

function LD_checkPointEvaluation(mmValueX, mmValueY)
{
  if (mmValueX < smartPositionLeft || mmValueX > smartPositionRight)
  	{return false;}
  if (mmValueY < smartPositionTop || mmValueY > smartPositionBottom)
  	{return false;}
  return true;
}

function LD_checkPointEvaluationImage(mmValueX, mmValueY)
{
  if (mmValueX > imagePositionOuterLeft && mmValueX < imagePositionInnerLeft)
  	{return false;}
  if (mmValueX < imagePositionOuterRight && mmValueX > imagePositionInnerRight)
  	{return false;}	
  if (mmValueY > imagePositionOuterTop && mmValueY < imagePositionInnerTop)
  	{return false;}
  if (mmValueY < imagePositionOuterBottom && mmValueY > imagePositionInnerBottom)
  	{return false;}
  return true;
}

function LD_checkDesign(checkOnly)
{
  var imageLayers = LD_getDraggableImageLayers();
  var textLayers = LD_getDraggableTextLayers();
  var checkFailed = false;
  
  for(i=0;i<imageLayers.length;i++)
  {
      if (imageLayers[i].visible)
      {
	    var checkpointAlphaX = imageLayers[i].x - workplaceX;
	    var checkpointAlphaY = imageLayers[i].y - workplaceY;
	    var checkpointBetaX = checkpointAlphaX + imageLayers[i].w;
	    var checkpointBataY = checkpointAlphaY + imageLayers[i].h;

	    checkpointAlphaX = LD_getMMfromPixel(checkpointAlphaX);
	    checkpointAlphaY = LD_getMMfromPixel(checkpointAlphaY);	    
	    checkpointBetaX = LD_getMMfromPixel(checkpointBetaX);
	    checkpointBataY = LD_getMMfromPixel(checkpointBataY);
	    
	    var testDesign = LD_checkPointEvaluationImage(checkpointAlphaX, checkpointAlphaY);
	    if (!testDesign)
	    {
	      if (checkOnly)
	      {
	        lastpickedObject = imageLayers[i];
            LD_setBorderActive();
		    LD_setTextLook(false);
	        alert("Das Grafikelement ist möglicherweise nicht optimal platziert. (Lesen Sie hierzu unsere FAQ bzw. die Videoanleitung)\n\nrandabfallende Grafik:  Hier sollte die Grafik mind. 1mm über den Kartenrand hinaus ragen.\nnormale Grafik:          Hier empfehlen wir einen Abstand von 2mm zum Kartenrand.");
	        return false;
		  }
	      var decision;	      
		  decision=confirm ("Das Grafikelement ist möglicherweise nicht optimal platziert. (Lesen Sie hierzu unsere FAQ bzw. die Videoanleitung)\n\nrandabfallende Grafik:  Hier sollte die Grafik mind. 1mm über den Kartenrand hinaus ragen.\nnormale Grafik:          Hier empfehlen wir einen Abstand von 2mm zum Kartenrand.\n\nOK: Trotzdem bestellen      Cancel: Design anpassen");
	      if (decision==true)
	      {  	        
		  }
		  else
		  {
		    lastpickedObject = imageLayers[i];
	        LD_setBorderActive();
			LD_setTextLook(false);
	      	checkFailed = true;
		    return false; 		    
		  }    
		}
	    testDesign = LD_checkPointEvaluationImage(checkpointBetaX, checkpointBataY);
	    if (!testDesign)
	    {
	      if (checkOnly)
	      {
	        lastpickedObject = imageLayers[i];
            LD_setBorderActive();
		    LD_setTextLook(false)
		    alert("Das Grafikelement ist möglicherweise nicht optimal platziert. (Lesen Sie hierzu unsere FAQ bzw. die Videoanleitung)\n\nrandabfallende Grafik:  Hier sollte die Grafik mind. 1mm über den Kartenrand hinaus ragen.\nnormale Grafik:          Hier empfehlen wir einen Abstand von 2mm zum Kartenrand.");
	        return false;
		  }
		  var decision;
		  decision=confirm ("Das Grafikelement ist möglicherweise nicht optimal platziert. (Lesen Sie hierzu unsere FAQ bzw. die Videoanleitung)\n\nrandabfallende Grafik:  Hier sollte die Grafik mind. 1mm über den Kartenrand hinaus ragen.\nnormale Grafik:          Hier empfehlen wir einen Abstand von 2mm zum Kartenrand.\n\nOK: Trotzdem bestellen      Cancel: Design anpassen");
	      if (decision==true)
	      {  	        
		  }
		  else
		  {
		    lastpickedObject = imageLayers[i];
            LD_setBorderActive();
		    LD_setTextLook(false);
      	    checkFailed = true;
		    return false; 		    
		  }  
		}				   
	  }
  }
  
  for(i=0;i<textLayers.length;i++)
  {
      if (textLayers[i].visible)
      {
	    var checkpointAlphaX = textLayers[i].x - workplaceX;
	    var checkpointAlphaY = textLayers[i].y - workplaceY;
	    var checkpointBetaX = checkpointAlphaX + textLayers[i].w;
	    var checkpointBataY = checkpointAlphaY + textLayers[i].h;

	    checkpointAlphaX = LD_getMMfromPixel(checkpointAlphaX);
	    checkpointAlphaY = LD_getMMfromPixel(checkpointAlphaY);	    
	    checkpointBetaX = LD_getMMfromPixel(checkpointBetaX);
	    checkpointBataY = LD_getMMfromPixel(checkpointBataY);
	    
	    var testDesign = LD_checkPointEvaluation(checkpointAlphaX, checkpointAlphaY);
	    if (!testDesign)
	    {
	      if (checkOnly)
	      {
	        lastpickedObject = textLayers[i];
            LD_setBorderActive();
		    LD_setTextLook(true);
      	    $('txtEditorField').value = lastpickedObject.getTXT();
	        alert("Das Textelement ist sehr nahe am Rand.\nWir empfehlen bei Textelementen einen Abstand von 4mm bis zum Visitenkartenrand.");
	        return false;
		  }
	      var decision;	      
		  decision=confirm ("Ein Textelement ist sehr nahe am Rand.\nWir empfehlen bei Textelementen einen Abstand von 4mm bis zum Visitenkartenrand.\n\nOK: Trotzdem bestellen      Cancel: Design anpassen");
	      if (decision==true)
	      {  	        
		  }
		  else
		  {
		    lastpickedObject = textLayers[i];
	        LD_setBorderActive();
			LD_setTextLook(true);
	      	$('txtEditorField').value = lastpickedObject.getTXT();
	      	checkFailed = true;
		    return false; 		    
		  }    
		}
	    testDesign = LD_checkPointEvaluation(checkpointBetaX, checkpointBataY);
	    if (!testDesign)
	    {
	      if (checkOnly)
	      {
	        lastpickedObject = textLayers[i];
            LD_setBorderActive();
		    LD_setTextLook(true);
      	    $('txtEditorField').value = lastpickedObject.getTXT();
	        alert("Ein Textelement ist sehr nahe am Rand.\nWir empfehlen bei Textelementen einen Abstand von 4mm bis zum Visitenkartenrand.");
	        return false;
		  }
		  var decision;
		  decision=confirm ("Ein Textelement ist sehr nahe am Rand.\nWir empfehlen bei Textelementen einen Abstand von 4mm bis zum Visitenkartenrand.\n\nOK: Trotzdem bestellen      Cancel: Design anpassen");
	      if (decision==true)
	      {  	        
		  }
		  else
		  {
		    lastpickedObject = textLayers[i];
            LD_setBorderActive();
		    LD_setTextLook(true);
      	    $('txtEditorField').value = lastpickedObject.getTXT();
      	    checkFailed = true;
		    return false; 		    
		  }  
		}				   
	  }
  }
  if (checkOnly)
  {
    if  (!checkFailed)
	{
	  confirm ("Text- und Grafikelemente:     OK.");
	}
	return false;   
  }
  return true;
}

function LD_objectsToXML()
{
    postData = "<?xml version='1.0' encoding='UTF-8'?>";
    postData += "<LDObject><layoutArea>";
    postData += "<width>";
    postData += layoutWidthSvr;
    //postData += 0;
    postData += "</width><height>";
    postData += layoutHeightSvr;
    //postData += 0;
    postData += "</height><dpi>";
    postData += currentDPI;
    postData += "</dpi></layoutArea>";
    
    var imageLayers = LD_getDraggableImageLayers();
    var textLayers = LD_getDraggableTextLayers();
   
    for(i=0;i<imageLayers.length;i++)
    {
      if (imageLayers[i].visible)
      {
       postData += "<imageLayer><id>";
       postData += LD_xmlEncode(imageLayers[i].name);
       postData += "</id><x>";
       postData += imageLayers[i].x - workplaceX;
       postData += "</x><y>";
       postData += imageLayers[i].y - workplaceY;
       postData += "</y><h>";
       postData += imageLayers[i].h;
       postData += "</h><w>";
       postData += imageLayers[i].w;
       postData += "</w><z>";
       postData += imageLayers[i].z;
       postData += "</z><dpi>";
       postData += imageLayers[i].getDpi();
       postData += "</dpi><locklevel>";
       postData += imageLayers[i].getLockLevel();
       postData += "</locklevel><srcpath>";
       postData += "</srcpath></imageLayer>";
       }
    }
    
    for(i=0;i<textLayers.length;i++)
    {
      if(textLayers[i].visible)
      {
       postData += "<textLayer><id>";
       postData += LD_xmlEncode(textLayers[i].name);
       postData += "</id><x>";
       postData += textLayers[i].x - workplaceX;
       postData += "</x><y>";
       postData += textLayers[i].y - workplaceY;
       postData += "</y><h>";
       postData += textLayers[i].h;
       postData += "</h><w>";
       postData += textLayers[i].w;
       postData += "</w><z>";
       postData += textLayers[i].z;
       postData += "</z><dpi>";
       postData += textLayers[i].getDpi();
       postData += "</dpi><locklevel>";
       postData += imageLayers[i].getLockLevel();
       postData += "</locklevel><size>";
       postData += textLayers[i].getSize();
       postData += "</size><text>";
       //postData += textLayers[i].getTXT();
       postData += LD_xmlEncode(textLayers[i].getTXT());
       postData += "</text><font>";
       postData += LD_xmlEncode(textLayers[i].getFont());
       postData += "</font><bold>";
       postData += textLayers[i].getBold();
       postData += "</bold><italic>";
       postData += textLayers[i].getItalic();
       postData += "</italic><underline>";
       postData += textLayers[i].getUnderline();
       postData += "</underline><align>";
       postData += textLayers[i].getAlign();
       postData += "</align><color>";
       postData += LD_xmlEncode(textLayers[i].getColor());
       postData += "</color></textLayer>";
       }
    }
    postData += "</LDObject>";
    postData = LD_urlEncode(postData);
  var targetURL = LD_path;
  targetURL += SaveTargetUrl;
  targetURL += '?sessionId=' + sessionID;
  
//  window.alert(targetURL);

	if ( $('action').value == 'callback' )
	  var myAjax = new Ajax.Request( targetURL, {method: 'post', postBody:"xmlObject=" + postData, onComplete: LD_executeShit} );
  else if(SaveAccomplishedFormID.length>0)
	  var myAjax = new Ajax.Request( targetURL, {method: 'post', postBody:"xmlObject=" + postData, onComplete: LD_saveAccomplished} );
  else
  	var myAjax = new Ajax.Request( targetURL, {method: 'post', postBody:"xmlObject=" + postData, onComplete: LD_forwardToPage} );
  return(false);
}

function LD_saveAccomplished()
{
  $(SaveAccomplishedFormID).submit();
}

function LD_alert(displayText)
{
  alert(displayText);
}

function LD_forwardToPage()
{
  window.location.replace(SaveAccomplishedUrl);
}

function LD_iframeFocusEvent(sizeInfo)
{
  var reply_Array=sizeInfo.split(";");
  if (reply_Array.length!=2)
  {
    if (lastpickedObject != null)
    {
     lastpickedObject.swapImage(lastpickedObject.defsrc);
     lastpickedObject.setTXT("Ihr Text");
     lastpickedObject.setDpi(defaultDPI);
     lastpickedObject.setAlign(0);
	lastpickedObject.setColor('000000');
	lastpickedObject.setUnderline(0);
	lastpickedObject.setItalic(0);
	lastpickedObject.setBold(0);
	lastpickedObject.setSize(12);
	lastpickedObject.setFont('Arial');

     lastpickedObject.resizeTo(0,0);
     lastpickedObject.hide();
     $('border').className='deselected';
     lastpickedObject = null;
     dd.elements.resizeElement.hide();
     alert("Ein Fehler beim Dateiupload ist aufgetreten!\n\r" + sizeInfo);
     $('btnUpload').disabled=false;
  uploadingProcess=false;
  var progressPath = LD_path;
  progressPath += "images/transparentpixel.gif";
  $('progressBar').src=progressPath;
    }
}
else
{
  $('btnUpload').disabled=false;
  uploadingProcess=false;
  var progressPath = LD_path;
  progressPath += "images/transparentpixel.gif";
  $('progressBar').src=progressPath;
  
  if (lastpickedObject != null)
  {
    if (LD_isDraggableDesignElement(lastpickedObject) && !LD_isDraggableTextElement(lastpickedObject))
    {
        //lastpickedObject.swapImage(path);
        //LD_refreshImage(lastpickedObject);
        lastpickedObject.defw = reply_Array[0];
        lastpickedObject.defh = reply_Array[1];
        LD_resizeImage(lastpickedObject,reply_Array[0],reply_Array[1]);
    }

  }
  }
}

function LD_resizeImage(obj, newWidth, newHeight)
{
  var imageLayers = LD_getDraggableImageLayers();

  for(i=0;i<imageLayers.length;i++)
  {
    if (obj==imageLayers[i])
    {
      var ratio = obj.defw/obj.defh;
      if (ratio>1)
      {
        ratio = obj.defh/obj.defw;
	    newHeight = Math.round(newWidth*ratio);
        obj.resizeTo(newWidth,newHeight);	    
	  }
	  else
	  {
	      newWidth = Math.round(newHeight*ratio);
	      obj.resizeTo(newWidth,newHeight);
	  }
      LD_setBorderActive();
      var newTooltip = "Masse (BxH): ";
      var heightPx=newHeight;
      var widthPx=newWidth;
      try
      {
         heightPx = (heightPx)/currentDPI*25.4;
         widthPx = (widthPx)/currentDPI*25.4;
         heightPx = Math.round(heightPx*10)/10;
         widthPx = Math.round(widthPx*10)/10;
         newTooltip += widthPx;
         newTooltip += "mm x ";
         newTooltip += heightPx;
         newTooltip += "mm";
         obj.nimg.title = newTooltip;
      }
        catch(e)
      {}
      
      //LD_setImageSource(obj);
      //var requestURL = "http://melbourne/graphicDesignerSvr/gettext.aspx?";
      var requestURL = LD_path;
      requestURL += "getImage.aspx?";
      requestURL += "dpi=";
      requestURL += obj.getDpi();
      requestURL += "&width=" + newWidth;
      requestURL += "&height=" + newHeight;
      requestURL += "&id=" + obj.name;
      requestURL += "&sizeonly=0";
      requestURL += "&sessionId=" + sessionID;
      obj.swapImage(requestURL);
    }
  }
}

function  LD_debugtext(debugtext)
{
  //$('debug').value = debugtext;
}

function LD_refreshTextZoom(obj)
	{
         //var requestURL = 'http://melbourne/graphicDesignerSvr/gettext.aspx';
         var requestURL = LD_path;
         requestURL += "getText.aspx";
         //var requestURL = "ajax.php";
         var pars = "dpi=" + obj.getDpi();
         pars += "&size=" + obj.getSize();
         pars += "&text=" + LD_urlEncode(obj.getTXT(),true);
         pars += "&font=" + obj.getFont();
         pars += "&bold=" + obj.getBold();
         pars += "&italic=" + obj.getItalic();
         pars += "&underline=" + obj.getUnderline();
         pars += "&align=" + obj.getAlign();
         pars += "&color=" + obj.getColor();
         pars += "&sizeonly=1";
         pars += "&id=" + obj.name;

var myAjax = new Ajax.Request( requestURL, {method: 'get', parameters: pars, onComplete: LD_resizeResponseZoom} );
	}

//Hidden update von Textelement... siehe LD_textChangedHidden()
function LD_refreshTextHidden(obj)
	{
         //var requestURL = 'http://melbourne/graphicDesignerSvr/gettext.aspx';
         var requestURL = LD_path;
         requestURL += "getText.aspx";
         //var requestURL = "ajax.php";
         var pars = "dpi=" + obj.getDpi();
         pars += "&size=" + obj.getSize();
         pars += "&text=" + LD_urlEncode(obj.getTXT(),true);
         pars += "&font=" + obj.getFont();
         pars += "&bold=" + obj.getBold();
         pars += "&italic=" + obj.getItalic();
         pars += "&underline=" + obj.getUnderline();
         pars += "&align=" + obj.getAlign();
         pars += "&color=" + obj.getColor();
         pars += "&sizeonly=1";
         pars += "&id=" + obj.name;

var myAjax = new Ajax.Request( requestURL, {method: 'get', parameters: pars, onComplete: LD_resizeResponseHidden} );
	}

function LD_refreshText(obj)
	{
         //var requestURL = 'http://melbourne/graphicDesignerSvr/gettext.aspx';
         var requestURL = LD_path;
         requestURL += "getText.aspx";
         //var requestURL = "ajax.php";
         var pars = "dpi=" + obj.getDpi();
         pars += "&size=" + obj.getSize();
         pars += "&text=" + LD_urlEncode(obj.getTXT(),true);
         pars += "&font=" + obj.getFont();
         pars += "&bold=" + obj.getBold();
         pars += "&italic=" + obj.getItalic();
         pars += "&underline=" + obj.getUnderline();
         pars += "&align=" + obj.getAlign();
         pars += "&color=" + obj.getColor();
         pars += "&sizeonly=1";
         pars += "&id=" + obj.name;

var myAjax = new Ajax.Request( requestURL, {method: 'get', parameters: pars, onComplete: LD_resizeResponse} );
	}

function LD_setBorderActive()
{
  if (lastpickedObject!=null)
  {
    if (lastpickedObject.visible && LD_isDraggableDesignElement(lastpickedObject))
    {
      
        dd.elements.border.moveTo(lastpickedObject.x-2,lastpickedObject.y-2);
        dd.elements.border.resizeTo(lastpickedObject.w+4, lastpickedObject.h+4);
        dd.elements.border.show();
        if (!LD_isDraggableTextElement(lastpickedObject))
        {
          dd.elements.resizeElement.moveTo(lastpickedObject.x + lastpickedObject.w -12, lastpickedObject.y + lastpickedObject.h -12);
          dd.elements.resizeElement.setZ(1);
          dd.elements.border.addChild(dd.elements.resizeElement);
          var newResizePicUrl = LD_path;
          newResizePicUrl += "images/scale.gif"
          dd.elements.resizeElement.swapImage(newResizePicUrl);
          if (lastpickedObject.getDragLocked()==0)
            dd.elements.resizeElement.show();
          else
            dd.elements.resizeElement.hide();
        }
        else
        {
          dd.elements.resizeElement.hide();
        }
        
          var zIndex = 0;
  var textLayers = LD_getDraggableTextLayers();
  for(j=0;j<textLayers.length;j++)
  {
    if (textLayers[j].z > zIndex)
    {
     zIndex = parseInt(textLayers[j].z);
    }
  }
  var imageLayers = LD_getDraggableImageLayers();
  for(k=0;k<imageLayers.length;k++)
  {
    if (imageLayers[k].z > zIndex)
    {
     zIndex = parseInt(imageLayers[k].z);
    }
  }
  dd.elements.border.setZ(parseInt(zIndex)+1);
        //dd.elements.border.setZ(1);
        //lastpickedObject.addChild(dd.elements.border);
        lastpickedObject.setZ(parseInt(dd.elements.border.z)+1);
        if (!LD_isDraggableTextElement(lastpickedObject))
        {
            dd.elements.resizeElement.setZ(parseInt(dd.elements.border.z)+2);
        }
        $('border').className='selected';
        dd.elements.hliner.setZ(parseInt(dd.elements.border.z)+3);
        dd.elements.vliner.setZ(parseInt(dd.elements.border.z)+3);
        dd.elements.hEdgeLiner.setZ(parseInt(dd.elements.border.z)+3);
        dd.elements.vEdgeLiner.setZ(parseInt(dd.elements.border.z)+3);
        dd.elements.vLeftLiner.setZ(parseInt(dd.elements.border.z)+3);
        dd.elements.hTopLiner.setZ(parseInt(dd.elements.border.z)+3);
        dd.elements.cutterUp.setZ(parseInt(dd.elements.border.z)+3);
        dd.elements.cutterLeft.setZ(parseInt(dd.elements.border.z)+3);
    }
    else
    {
      dd.elements.border.hide();
    }
  }
  else
  {
    dd.elements.border.hide();
  }
}

function LD_switchFontLayer()
{
  if (!fonttableLoaded)
  {
    var url = LD_path;
    url += "getExtendedElements.aspx";
    var pars = "type=fonttable";
    pars += "&fonts=";
    pars += fontsAllString;
    
    var myAjax = new Ajax.Updater('FontTable', url, {method: 'get', parameters: pars});
    fonttableLoaded=true;
  }
  if (dd.elements.FontTable.visible)
  {
    dd.elements.FontTable.hide();
  }
  else
  {
     //setze font table unter fontselector
     var fontTargetX = LD_findPosX($('imgFontSelector'));
     var fontTargetY = LD_findPosY($('imgFontSelector'));
     dd.elements.FontTable.moveTo(fontTargetX-1, fontTargetY+22);
     var zIndex = LD_getMaxZofElements()+3;
     dd.elements.FontTable.setZ(parseInt(zIndex)+1);
     dd.elements.FontTable.show();
  }
}


function LD_switchColorLayer()
{
  if (!colortableLoaded)
  {
    var url = LD_path;
    url += "getExtendedElements.aspx";
    var pars = "type=colortable";

    var myAjax = new Ajax.Updater('ColorTable', url, {method: 'get', parameters: pars});
    colortableLoaded=true;
  }
  
  if (dd.elements.ColorTable.visible)
  {
    dd.elements.ColorTable.hide();
  }
  else
  {
     //setze font table unter fontselector
     var colorTargetX = LD_findPosX($('ColorSelector'));
     var colorTargetY = LD_findPosY($('ColorSelector'));
     dd.elements.ColorTable.moveTo(colorTargetX-1, colorTargetY+22);
     var zIndex = LD_getMaxZofElements()+3;
     dd.elements.ColorTable.setZ(parseInt(zIndex)+1);
     dd.elements.ColorTable.show();
  }
}

function LD_manageZAxis()
{
  var zIndex = 0;
  var textLayers = LD_getDraggableTextLayers();
  for(j=0;j<textLayers.length;j++)
  {
    if (textLayers[j].z > zIndex)
    {
     zIndex = parseInt(textLayers[j].z);
    }
  }
  var imageLayers = LD_getDraggableImageLayers();
  for(k=0;k<imageLayers.length;k++)
  {
    if (imageLayers[k].z > zIndex)
    {
     zIndex = parseInt(imageLayers[k].z);
    }
  }
  dd.elements.hliner.setZ(parseInt(zIndex)+1);
  dd.elements.vliner.setZ(parseInt(zIndex)+1);
  dd.elements.hEdgeLiner.setZ(parseInt(zIndex)+1);
  dd.elements.vEdgeLiner.setZ(parseInt(zIndex)+1);
  dd.elements.vLeftLiner.setZ(parseInt(zIndex)+1);
  dd.elements.hTopLiner.setZ(parseInt(zIndex)+1);
  dd.elements.cutterUp.setZ(parseInt(zIndex)+1);
  dd.elements.cutterLeft.setZ(parseInt(zIndex)+1);
    if (dd.elements.ColorTable.visible)
    {
        dd.elements.ColorTable.setZ(parseInt(zIndex)+2);
    }
    if (dd.elements.FontTable.visible)
    {
        dd.elements.FontTable.setZ(parseInt(zIndex)+2);
    }
        
    if (dd.elements.TextEditor.visible)
    {
      dd.elements.TextEditor.setZ(parseInt(zIndex)+3);
      dd.elements.editorTitle.setZ(parseInt(zIndex)+3);
    }
    if (dd.elements.uploadHeader.visible)
    {
      dd.elements.TextEditor.setZ(parseInt(zIndex)+3);
      dd.elements.editorTitle.setZ(parseInt(zIndex)+3);
      dd.elements.uploadBody.setZ(parseInt(zIndex)+3);
      dd.elements.uploadHeader.setZ(parseInt(zIndex)+3);
    }
}

function LD_getMaxZofElements()
{
  var zIndex = 0;
  var textLayers = LD_getDraggableTextLayers();
  for(j=0;j<textLayers.length;j++)
  {
    if (textLayers[j].z > zIndex)
    {
     zIndex = parseInt(textLayers[j].z);
    }
  }
  var imageLayers = LD_getDraggableImageLayers();
  for(k=0;k<imageLayers.length;k++)
  {
    if (imageLayers[k].z > zIndex)
    {
     zIndex = parseInt(imageLayers[k].z);
    }
  }
  return(zIndex);
}

function LD_getMinZofTextElements()
{
  var zIndex = LD_getMaxZofElements();
  var textLayers = LD_getDraggableTextLayers();
  for(j=0;j<textLayers.length;j++)
  {
    if (textLayers[j].z < zIndex)
    {
     zIndex = parseInt(textLayers[j].z);
    }
  }
  return(zIndex);
}

function LD_getMinZofImageElements()
{
  var zIndex = LD_getMaxZofElements();
  var imageLayers = LD_getDraggableImageLayers();
  for(k=0;k<imageLayers.length;k++)
  {
    if (imageLayers[k].z < zIndex)
    {
     zIndex = parseInt(imageLayers[k].z);
    }
  }
  return(zIndex);
}

function LD_getMinZofElements()
{
  var zIndex = LD_getMaxZofElements();
  var textLayers = LD_getDraggableTextLayers();
  for(j=0;j<textLayers.length;j++)
  {
    if (textLayers[j].z < zIndex)
    {
     zIndex = parseInt(textLayers[j].z);
    }
  }
  var imageLayers = LD_getDraggableImageLayers();
  for(k=0;k<imageLayers.length;k++)
  {
    if (imageLayers[k].z < zIndex)
    {
     zIndex = parseInt(imageLayers[k].z);
    }
  }
  return(zIndex);
}

function LD_arrangeImagesBehindText()
{
  if (!LD_isDraggableTextElement(lastpickedObject) && lastpickedObject!=null)
      {
        var zValue = LD_getMinZofTextElements();
        var textLayers = LD_getDraggableTextLayers();
        while(zValue<15)
        {       
          for(j=0;j<textLayers.length;j++)
          {
            textLayers[j].setZ(textLayers[j].z+1);
          }
          zValue = LD_getMinZofTextElements();
        }

        var imageLayers = LD_getDraggableImageLayers();
        var zMaxImage=0;
        for(k=0;k<imageLayers.length;k++)
        {
          if (imageLayers[k]!=lastpickedObject && imageLayers[k].z>zMaxImage)
          zMaxImage = imageLayers[k].z;
        }

        while (zValue < (zMaxImage + 3))
        {
          for(l=0;l<textLayers.length;l++)
          {
              textLayers[l].setZ(textLayers[l].z+1);
          }
          zValue = LD_getMinZofTextElements();
        }
        lastpickedObject.setZ(zMaxImage+2);
        dd.elements.border.setZ(zMaxImage+1);
        dd.elements.resizeElement.setZ(zMaxImage+3);
      }
}

function LD_findPosX(obj)
{
	var curleft = 0;
	if (obj.offsetParent)
	{
		while (obj.offsetParent)
		{
			curleft += obj.offsetLeft
			obj = obj.offsetParent;
		}
	}
	else if (obj.x)
		curleft += obj.x;
	return curleft;
}

function LD_findPosY(obj)
{
	var curtop = 0;
	if (obj.offsetParent)
	{
		while (obj.offsetParent)
		{
			curtop += obj.offsetTop
			obj = obj.offsetParent;
		}
	}
	else if (obj.y)
		curtop += obj.y;
	return curtop;
}

function windowResized (Ereignis) {
  var deltaX = LD_findPosX($('hruler')) + 15 - workplaceX;
  var deltaY = LD_findPosY($('vruler')); - workplaceY;
  LD_setWorkplace(true);
  LD_resizeTimer();
}

function Ausgabe (Ereignis) {
  windowResized(Ereignis);
}

function LD_moveDesignObject(ToXCoord, ToYCoord, currentObject, forceMove, withBorder)
{

  if (forceMove)
  {
    currentObject.moveTo(ToXCoord, ToYCoord);
    if (withBorder)
        dd.elements.border.moveTo(currentObject.x-2,currentObject.y-2);
  }
  else if ( (currentObject.getDragLocked() == 0) && (currentObject.getLockLevel() == 0))
  {
    currentObject.moveTo(ToXCoord, ToYCoord);
    if (withBorder)
        dd.elements.border.moveTo(currentObject.x-2,currentObject.y-2);
  }
}

function LD_moveToCoord()
{
  if (lastpickedObject!=null)
  {
      try
      {
          var xValueMM = $('xCoordText').value;
          var yValueMM = $('yCoordText').value;
          var xValuePx = xValueMM / 25.4 * currentDPI;
          var yValuePx = yValueMM / 25.4 * currentDPI;
          if (xValuePx<1000 && xValuePx>-1000 && yValuePx<1000 && yValuePx>-1000)
          {
            xValuePx = Math.round(xValuePx) + workplaceX;
            yValuePx = Math.round(yValuePx) + workplaceY;
            if (LD_isDraggableDesignElement(lastpickedObject))
            {
              LD_moveDesignObject(xValuePx, yValuePx, lastpickedObject, false, true );
              LD_displayCoord();
            }
          }
      }
      catch (e)
      {
    }
  }
}

function LD_displayCoord()
{
  if (lastpickedObject!=null)
  {
    var xValueText = (lastpickedObject.x - workplaceX)/currentDPI*25.4;
    var yValueText = (lastpickedObject.y - workplaceY)/currentDPI*25.4;
    xValueText = Math.round(xValueText*10)/10;
    yValueText = Math.round(yValueText*10)/10;
    $('xCoordText').value = xValueText;
    $('yCoordText').value = yValueText;
  }
}

function LD_keyPressedIE(Ereignis)
{
  var LD_Keycode = event.keyCode;

  if (!focusOutsideLayout && lastpickedObject!=null)
  {
    if (LD_isDraggableDesignElement(lastpickedObject))
    {
      var suppressBrowser = false;
      switch(LD_Keycode)
         {
           case(46):
           LD_deleteLayer();
           break;
           case(37):
           lastpickedObject.moveBy(-cursorMoveStep,0);
           dd.elements.border.moveBy(-cursorMoveStep,0);
           LD_displayCoord();
           suppressBrowser = true;
           break;
           case(38):
           lastpickedObject.moveBy(0,-cursorMoveStep);
           dd.elements.border.moveBy(0,-cursorMoveStep);
           LD_displayCoord();
           suppressBrowser = true;
           break;
           case(39):
           lastpickedObject.moveBy(cursorMoveStep,0);
           dd.elements.border.moveBy(cursorMoveStep,0);
           LD_displayCoord();
           suppressBrowser = true;
           break;
           case(40):
           lastpickedObject.moveBy(0,cursorMoveStep);
           dd.elements.border.moveBy(0,cursorMoveStep);
           LD_displayCoord();
           suppressBrowser = true;
           break;
         }
         if (suppressBrowser)
           return false;
    }
  }
}

function LD_keyPressedN6(Ereignis)
{
  var LD_Keycode = Ereignis.keyCode;
  if (!focusOutsideLayout && lastpickedObject!=null)
  {
    if (LD_isDraggableDesignElement(lastpickedObject))
    {
        var suppressBrowser = false;
        switch(LD_Keycode)
        {
          case(46):
          LD_deleteLayer();
          break;
          case(37):
          lastpickedObject.moveBy(-cursorMoveStep,0);
          dd.elements.border.moveBy(-cursorMoveStep,0);
          LD_displayCoord();
          suppressBrowser = true;
          break;
          case(38):
          lastpickedObject.moveBy(0,-cursorMoveStep);
          dd.elements.border.moveBy(0,-cursorMoveStep);
          LD_displayCoord();
          suppressBrowser = true;
          break;
          case(39):
          lastpickedObject.moveBy(cursorMoveStep,0);
          dd.elements.border.moveBy(cursorMoveStep,0);
          LD_displayCoord();
          suppressBrowser = true;
          break;
          case(40):
          lastpickedObject.moveBy(0,cursorMoveStep);
          dd.elements.border.moveBy(0,cursorMoveStep);
          LD_displayCoord();
          suppressBrowser = true;
          break;
        }
        if (suppressBrowser)
           return false;
    }
  }
}

function init()
{
  if (dd.ie)
  {
    window.onresize = windowResized;
    document.onkeydown = LD_keyPressedIE;
  }
  else if (dd.n6)
  {
    //window.captureEvents(Event.Resize);
    window.onresize = windowResized;
    window.onkeypress = LD_keyPressedN6;
  }
  else if (dd.n4)
  {
  }
  else if (dd.n)
  {
  }
  else if (dd.op)
  {
    //gleich wie n6... NOCH NICHT GETESTET!!!!!!!!!
    window.onresize = windowResized;
    document.onkeydown = LD_keyPressedIE;
    //alert("opera Browser");
  }
  
}

////////////////////////////////////////////////////////////
// FUNCTIONS FOR TEXT EDITING
//
//

function LD_addTextLayer()
{
  var txtLayers = LD_getDraggableTextLayers();
  var count = txtLayers.length;
  var amountExceeded = true;

  var i = 0;
  while(i<count)
  {
    	if (!txtLayers[i].visible)
        {
            lastpickedObject = txtLayers[i];
            lastpickedObject.setTXT($('txtEditorField').value);
            //override attributes with last picked values
            txtLayers[i].setFont(pickedFont);
            txtLayers[i].setSize(pickedSize);
            txtLayers[i].setColor(pickedColor);

        	txtLayers[i].show();
        	txtLayers[i].moveTo(workplaceX,workplaceY);
        	txtLayers[i].setDpi(currentDPI);
        	LD_setImageSource(txtLayers[i]);
            LD_refreshText(txtLayers[i]);

            //set Border when adding a new Layer.
            LD_setBorderActive();
            LD_setFontSizeSelector();
            amountExceeded = false;
            LD_setTextLook(true);
        	break;
        }
        i++;
    }
    if (amountExceeded)
    {
      alert("Maximale Objektanzahl überschritten");
    }
}

function LD_setFontSizeSelector()
{
    if (lastpickedObject!=null)
  {
    if (LD_isDraggableTextElement(lastpickedObject))
    {
        $('FontSize').value = lastpickedObject.getSize();
    }
  }
}

function LD_setFontStyleSelector()
{
    if (lastpickedObject!=null)
  {
    if (LD_isDraggableTextElement(lastpickedObject))
    {
        var objFont = lastpickedObject.getFont();
        $('imgFontSelector').src = LD_path + "getText.aspx?dpi=92&size=10&text=" + objFont + "&font=" + objFont + "&bold=0&underline=0&italic=0&align=0&color=000000&sizeonly=0&id=txt1&definedWidth=138&definedHeight=17";
        //$('imgFontSelector').src = "images/Fonts/" + objFont + ".png";
    }
  }
}

function LD_colorChanged(color)
{
  if (lastpickedObject!=null)
  {
    if (LD_isDraggableDesignElement(lastpickedObject) && LD_isDraggableTextElement(lastpickedObject))
    {
      pickedColor = color;
      lastpickedObject.setColor(color);
      var newTooltip = "RGB (HEX): #";
      newTooltip += color;
      try
      {
        lastpickedObject.nimg.title = newTooltip;
      }
      catch(e)
      {}
      LD_setImageSource(lastpickedObject);
      LD_refreshText(lastpickedObject);
    }
  }
}

function LD_fontStyleChanged(newFont, srcPath)
{
    if (lastpickedObject!=null)
  {
    if (LD_isDraggableTextElement(lastpickedObject))
    {
      pickedFont = newFont;
      lastpickedObject.setFont(newFont);
      //$('imgFontSelector').src = LD_path + "images/Fonts/" +newFont + ".png";
      //$('imgFontSelector').src = "images/Fonts/" +newFont + ".png";
      $('imgFontSelector').src = srcPath;
      LD_setImageSource(lastpickedObject);
      LD_refreshText(lastpickedObject);
    }
  }
}

function LD_TextBoldChange()
{
  if (lastpickedObject!=null)
  {
    if (LD_isDraggableTextElement(lastpickedObject))
    {
      if (lastpickedObject.getBold()==1)
        {
          lastpickedObject.setBold(0);
        }
      else
        {
          lastpickedObject.setBold(1);
        }
        LD_setImageSource(lastpickedObject);
        LD_refreshText(lastpickedObject);
    }
  }
}

function LD_TextItalicChange()
{
  if (lastpickedObject!=null)
  {
    if (LD_isDraggableTextElement(lastpickedObject))
    {
      if (lastpickedObject.getItalic()==1)
        {
          lastpickedObject.setItalic(0);
        }
      else
        {
          lastpickedObject.setItalic(1);
        }
        LD_setImageSource(lastpickedObject);
        LD_refreshText(lastpickedObject);
    }
  }
}

function LD_TextUnderlineChange()
{
  if (lastpickedObject!=null)
  {
    if (LD_isDraggableTextElement(lastpickedObject))
    {
      if (lastpickedObject.getUnderline()==1)
        {
          lastpickedObject.setUnderline(0);
        }
      else
        {
          lastpickedObject.setUnderline(1);
        }
        LD_setImageSource(lastpickedObject);
        LD_refreshText(lastpickedObject);
    }
  }
}

function LD_TextAlignChanged(newAlign)
{
  if (lastpickedObject!=null)
  {
    if (LD_isDraggableTextElement(lastpickedObject))
    {
        lastpickedObject.setAlign(newAlign);
        LD_setImageSource(lastpickedObject);
        LD_refreshText(lastpickedObject);
    }
  }

}

//Funktion um im hintergrund einen Textelement zu updaten. Wird nur gebraucht, wenn ein Textfeld
//bearbeitet wird und dann ein anderes Element ausgewählt wird. Somit gibt es keine Konflikte beim
//asynchronen Ablauf des Updates.
function LD_textChangedHidden()
{
  if (lastpickedObject!=null)
  {
    if(LD_isDraggableTextElement(lastpickedObject))
    {
      lastpickedObject.setTXT($('txtEditorField').value);
      LD_setImageSource(lastpickedObject);
      LD_refreshTextHidden(lastpickedObject);
    }
  }
}

function LD_textChanged()
{
  if (lastpickedObject!=null)
  {
    if(LD_isDraggableTextElement(lastpickedObject))
    {
      lastpickedObject.setTXT($('txtEditorField').value);
      LD_setImageSource(lastpickedObject);
      LD_refreshText(lastpickedObject);
    }
    else
    {
      /*
      LD_addTextLayer();
      lastpickedObject.setTXT($('txtEditorField').value);
      LD_setImageSource(lastpickedObject);
      LD_refreshText(lastpickedObject);
      */
    }
  }
  else
  {
    LD_addTextLayer();
    lastpickedObject.setTXT($('txtEditorField').value);
    LD_setImageSource(lastpickedObject);
    LD_refreshText(lastpickedObject);
  }
}
  
function LD_FontSizeChanged()
{
  if (lastpickedObject!=null)
  {
    if(LD_isDraggableTextElement(lastpickedObject))
    {
        pickedSize = $('FontSize').value;
        lastpickedObject.setSize($('FontSize').value);
        LD_setImageSource(lastpickedObject);
        LD_refreshText(lastpickedObject);
    }
  }
}

function LD_setTextProperties()
{
  LD_setFontSizeSelector(); //setzen der Font Size auf Grösse des gewählten Objekts
  LD_setFontStyleSelector(); //setzen des Font Style auf Style des gewählten Objekts
  LD_showEditorLayer(); //anzeigen des Texteditors
}

//
// END TEXT EDITING FUNCTIONS
////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////
// FUNCTIONS FOR EXTENDED SCRIPTING
// Use these for your own extensions,
// or to call functions defined elsewhere



/* my_PickFunc IS AUTOMATICALLY CALLED WHEN AN ITEM STARTS TO BE DRAGGED.
The following objects/properties are accessible from here:

- dd.e: current mouseevent
- dd.e.property: access to a property of the current mouse event.
  Mostly requested properties:
  - dd.e.x: document-related x co-ordinate
  - dd.e.y: document-related y co-ord
  - dd.e.src: target of mouse event (not identical with the drag drop object itself).
  - dd.e.button: currently pressed mouse button. Left button: dd.e.button <= 1

- dd.obj: reference to currently dragged item.
- dd.obj.property: access to any property of that item.
- dd.obj.method(): for example dd.obj.resizeTo() or dd.obj.swapImage() .
  Mostly requested properties:
	- dd.obj.name: image name or layer ID passed to SET_DHTML();
	- dd.obj.x and dd.obj.y: co-ordinates;
	- dd.obj.w and dd.obj.h: size;
	- dd.obj.is_dragged: 1 while item is dragged, else 0;
	- dd.obj.is_resized: 1 while item is resized, i.e. if <ctrl> or <shift> is pressed, else 0

For more properties and details, visit the API documentation
at http://www.walterzorn.com/dragdrop/api_e.htm (english) or
http://www.walterzorn.de/dragdrop/api.htm (german)	*/
function my_PickFunc()
{
  //aktualiesiert den Text des vorher gewählten Textfeldes. Nur wenn Focus von einem Textfeld kommt...
  if (lastpickedObject!=null)
  {
    if (LD_isDraggableTextElement(lastpickedObject))
    {
      LD_textChangedHidden();
    }
  }
  if (dd.obj.name=="hliner" || dd.obj.name=="vliner" || dd.obj.name=="border" || dd.obj.name=="uploadHeader" || dd.obj.name=="editorTitle")
  {
  }
  else if (dd.obj.name=="resizeElement")
  {
    resizeObject=true;
    var newResizePicUrl = LD_path;
    newResizePicUrl += "images/scale_transparent.gif"
    dd.elements.resizeElement.swapImage(newResizePicUrl);
  }
  else
  {
    lastpickedObject = dd.obj;
    //dd.obj.setOpacity(1); //damit wird im IE der Border richtig gezeigt... deprecated
    LD_displayCoord();
    if (LD_isDraggableTextElement(lastpickedObject)) //ist ein Textelement
    {
      LD_setTextLook(true);
      $('txtEditorField').value = lastpickedObject.getTXT();
    }
    else //Ein Grafik-Element
    {
      LD_setTextLook(false);
      //$('newLayout').className = "disabledtoolButton";
    }
    LD_setBorderActive();
  }
}

/* my_DragFunc IS CALLED WHILE AN ITEM IS DRAGGED
See the description of my_PickFunc above for what's accessible from here. */
function my_DragFunc()
{
  if (dd.obj.name=="resizeElement" && lastpickedObject!=null)
  {   
    var elementRatio = lastpickedObject.defw/lastpickedObject.defh;
    var tempWidth = Math.round(dd.elements.resizeElement.x-dd.elements.border.x + 12);
    var tempHeight = Math.round(((dd.elements.resizeElement.x-dd.elements.border.x)/elementRatio)+12);
    
    dd.elements.border.resizeTo(tempWidth,tempHeight);
  }
  if (LD_isDraggableDesignElement(dd.obj))
  {
        LD_displayCoord();
        dd.elements.border.moveTo(dd.obj.x-2,dd.obj.y-2);
  }
	//window.status = 'dd.elements.' + dd.obj.name + '.x  = ' + dd.obj.x + '	 dd.elements.' + dd.obj.name + '.y = ' + dd.obj.y;
}
/* my_ResizeFunc IS CALLED WHILE AN ITEM IS RESIZED
See the description of my_PickFunc above for what's accessible from here. */
function my_ResizeFunc()
{

  dd.elements.border.resizeTo(dd.obj.w+2, dd.obj.h+2);
    resizeInProgress = true;

	//window.status = 'dd.elements.' + dd.obj.name + '.w  = ' + dd.obj.w + '	 dd.elements.' + dd.obj.name + '.h = ' + dd.obj.h;
}

/* THIS ONE IS CALLED ONCE AN ITEM IS DROPPED
See the description of my_PickFunc for what's accessible from here.
Here may be investigated, for example, what's the name (dd.obj.name)
of the dropped item, and where (dd.obj.x, dd.obj.y) it has been dropped... */
function my_DropFunc()
{
  if ((dd.obj == dd.elements.TextEditor) || (dd.obj == dd.elements.editorTitle) || (dd.obj == dd.elements.uploadHeader) || (dd.obj == dd.elements.uploadBody))
  {
  }
  else if (dd.obj.name=="resizeElement" && lastpickedObject!=null)
  {
    var newResizePicUrl = LD_path;
    newResizePicUrl += "images/scale.gif"
    dd.elements.resizeElement.swapImage(newResizePicUrl);
    LD_resizeImage(lastpickedObject, dd.elements.border.w-4, dd.elements.border.h-4);
    LD_arrangeImagesBehindText();
  }
  else
    {
      LD_arrangeImagesBehindText();
      if (dd.obj.x<workplaceX && (dd.obj != dd.elements.hliner))
      {
            //dd.obj.moveTo(workplaceX,dd.obj.y);
      }

      if (dd.obj.x>workplaceMaxX && LD_isDraggableDesignElement(dd.obj))
      {
        LD_moveDesignObject(workplaceMaxX-dd.obj.w, dd.obj.y, dd.obj, true, true );
        //dd.obj.moveTo(workplaceMaxX-dd.obj.w,dd.obj.y);
      }

      if (dd.obj.x>workplaceMaxX && (dd.obj != dd.elements.hliner))
      {
        if (LD_isDraggableDesignElement(dd.obj))
        {
            LD_moveDesignObject(workplaceMaxX-dd.obj.w,dd.obj.y, dd.obj, true, true );
            //dd.obj.moveTo(workplaceMaxX-dd.obj.w,dd.obj.y);
        }
        else
        {
            LD_moveDesignObject(workplaceMaxX-dd.obj.w,dd.obj.y, dd.obj, true, false );
          //dd.obj.moveTo(workplaceMaxX-dd.obj.w,dd.obj.y);
        }
      }

      if (dd.obj.y>workplaceMaxY && LD_isDraggableDesignElement(dd.obj))
      {
        LD_moveDesignObject(dd.obj.x,workplaceMaxY-dd.obj.h, dd.obj, true, true );
        //dd.obj.moveTo(dd.obj.x, workplaceMaxY-dd.obj.h);
      }

      if ((dd.obj.y>(workplaceMaxY)) && (dd.obj != dd.elements.vliner))
      {
          LD_moveDesignObject(dd.obj.x,workplaceMaxY-dd.obj.h, dd.obj, true, false );
          //dd.obj.moveTo(dd.obj.x,workplaceMaxY-dd.obj.h);
      }
      LD_manageZAxis();

      if (resizeInProgress)
      {
        LD_resizeImage(dd.obj, dd.obj.w, dd.obj.h)
      }
      resizeInProgress = false;
    }
}