/****************************************************************************
 * Stellt ein Objekt bereit, welches einen WYSIWY(N)G-Editor bereit stellt  *
 * ------------------------------------------------------------------------ *
 *                                                                          *
 * @author jw                                                               *                                                               
 * @version 0.3                                                             *
 * @copyright GPL                                                           *
 *                                                                          *
 ****************************************************************************/
function InnoEdi(CoreDOM, data, debug) {
  this.data = data;
  this.enableDebug = 0 || debug;
  this.maxLines = 0 || this.data.maxLines;
  this.maxColors = 0 || this.data.maxColors;
  this.CoreDOM = CoreDOM;
  this.cColorTable = this.data.colorTable || {"color00": {"name": "undef", "code": "undef"}};
  this.cFontTable = this.data.fontTable || {"font00": {"name": "Arial", "code": "Arial"}};
  this.doUpdate = 0 || this.data.update;
  this.previewBox = null; // DOM ELEMENT
  this.addMoreLines = 0;
  this.oAddMoreLines;
  this.linesContainer;
  this.lastLine = 0;
  this.oTranslation = this.data.translation;
  this.oModules = this.data.modules;
  this.form = dojo.create("form", {action: this.data.action, method: this.data.method});
  this.isSubmitting = false;
  this.preloadData = this.data.preloadData;
  this.ChangeAction = this.data.ChangeAction || 'ICSave';
  this.usedColors = {};
  this.initContainer;
  this.event = new Array();
  this.somethingChanged = 0;
    
    window['My' + this.CoreDOM] = this;
    MyObj = window['My'+this.CoreDOM];
  
  ___ = function (string) {
    if (typeof (data.translation) == 'object' && typeof (data.translation[string]) != 'undefined') {
      return data.translation[string];
    }
    return string;
  }
  
  this.debug = function (debugname, debugdata) {
    /**
     * -------------------------------------------------------------------
     *
     * Diese Funktion erstellt debugausgaben, wenn this.enableDebug==1
     * verhält sich nahezu analog zu LogDebug aus Perl
     * -------------------------------------------------------------------
     *
     * @author jw
     * @param string debugname Bezeichner
     * @param string debugdata Wert
     * @return boolean true
     */
    if (this.enableDebug == 1) {
      console.log(debugname, debugdata);
    }
  }
  
  this.preloadFonts = function () {
	/*var divInfo = dojo.position(MyObj.CoreDOM.parentNode.parentNode.parentNode, true);
	var ani = dojo.byId('LoaderAniNode');
	var aniInfo = dojo.position(ani, true);

	var lastX = divInfo.x + (divInfo.w - aniInfo.w) / 2;
	var lastY = divInfo.y + (divInfo.h - aniInfo.h) / 2;
		dojo.style(ani, {
		left: lastX + "px",
		top: lastY + "px",
		display: "block",
		zIndex: 9999
	});
	*/
    for (font in this.cFontTable) {
      if (typeof (this.cFontTable[font].source) != 'undefined') {
        dojo.xhrGet({
          url: this.cFontTable[font].source,
          handleAs: 'javascript',
          load: function (data) { /* TODO? */ }
        });
      }
    }
	//dojo.style(ani, {display: 'none', zIndex: '1', left: '-9999px', top: '-9999px'});
  }
  
  
  this.init = function () {
    dojo.require("dijit.Tooltip");
    dojo.require('dojox.html.entities');
    /**
     * -------------------------------------------------------------------
     *
     * Diese Funktion initialisiert das Objekt
     *
     * -------------------------------------------------------------------
     *
     * @author jw
     * @return undefinded
     */
    this.CoreDOM = dojo.byId(this.CoreDOM);
    
	console.log("Hello, i am ",MyObj.CoreDOM.id);
	if(typeof(MyObj.preloadData) != "undefined")
	{
		if(typeof(MyObj.preloadData.File) == 'undefined' && MyObj.CoreDOM.id == "LogoEdi")
		{
			MyObj.preloadData = undefined;
		}
	}
	
    if (this.data.savedData)
    {
      
		var myNewContainer = dojo.create('div',{className:"FloatLeft"},this.CoreDOM);
		var tContainer = dojo.create("div",{className:"FloatLeft"},myNewContainer);
		var myInput = dojo.create('input',{type:"radio",id:"ICSavedDataNew",checked:"checked",name:"ICSavedData",value:"new"},tContainer);
		var myLabel = dojo.create('label',{htmlFor:"ICSavedDataNew",innerHTML:___("newText")},tContainer);
		dojo.attr(myInput,"checked","checked");
		var mySavedContainer = dojo.create('div',{className:"FloatLeft MarginLeft"},this.CoreDOM);
		for (savedData=0;savedData<countObjects(this.data.savedData);savedData++)
		{
			if (typeof(this.data.savedData[savedData]) != 'undefined')
			{
				if (typeof(this.data.savedData[savedData].File) == 'undefined' && this.data.savedData[savedData].Lines[0].Text != undefined)
				{ 
					var tContainer = dojo.create("div",{className:"FloatLeft"},mySavedContainer);
					dojo.style(tContainer,"width","125px");
					myInput = dojo.create('input',{type:"radio",id:"ICSavedData"+savedData,name:"ICSavedData",value:savedData},tContainer);
					myLabel = dojo.create('label',{htmlFor:"ICSavedData"+savedData},tContainer);

					var tSavedData = dojo.toJson(this.data.savedData[savedData]);

					tSavedData = dojo.fromJson(tSavedData);

					for (jwtline in tSavedData.Lines)
					{
						tString = dojox.html.entities.decode(tSavedData.Lines[jwtline].Text);
						tString = tString.replace(/\\\'/g,"'");
						tSavedData.Lines[jwtline].Text = tString;
					}

					console.log(tSavedData);
					if (compare(tSavedData, this.preloadData))
					{
						dojo.attr(myInput,'checked','checked');
						MyObj.somethingChanged = 1;
					}
					var text = this.data.savedData[savedData].Lines[0].Text;
					text = text.replace(/\\\'/g,"'");

					if (text.length > 15)
					{
						text = text.substr(0,12)+"...";
					}
					var myToolTipText = dojo.create("span");
					dojo.attr(myLabel,"innerHTML",text);
					var ToolTipNode = dojo.create('span',{className:"ToolTipCursor"},myLabel);
					//			dojo.attr(myLabel,"innerHTML",text);
					//var StoreRoot = "/WebRoot/StoreTypes/6.10.4/";
					var StoreRoot = epages.vars.StoreRoot;
					var BubbleImg = StoreRoot + "/BO/icons/ico_s_bubblehelp.png";
					var ToolTipImg = dojo.create('img',{src:BubbleImg,className:"BubbleHelp"},ToolTipNode);


					/*this.data.savedData[savedData].Lines.forEach(
						function(singleLine)
						{
							myToolTipText += singleLine.Text + "<br />";
						}
					);*/
					/**
					HOTFIX for IE: forEach is not a function for this object in IE
					*/
					console.log(this.data.savedData[savedData]);
					for ( var sIndex in this.data.savedData[savedData].Lines)
					{
						textWrapper = dojo.create("div",null,myToolTipText);
						dojo.style(textWrapper,"minWidth","200px");
						textNode = dojo.create("font",null,textWrapper);
						lastNode = textNode;
						if (this.data.savedData[savedData].Lines[sIndex].Bold == "1")
						{
							lastNode = dojo.create("b",null,lastNode);
						}
						if (this.data.savedData[savedData].Lines[sIndex].Italic == "1")
						{
							lastNode = dojo.create("i",null,lastNode);
						}
						/*if (this.data.savedData[savedData].Lines[sIndex].UnderLine == "1")

						{
						lastNode = dojo.create("u",null,lastNode);
						}
						*/					  
						if (typeof(this.data.savedData[savedData].Lines[sIndex].Color) != "undefined")
						{
							
							var oColor = MyObj.findColor(dojox.html.entities.decode(this.data.savedData[savedData].Lines[sIndex].Color));
							var sColorCode = "#000000";

							if (countObjects(oColor) == 1) { 
								for (tC in oColor) {
									sColorCode = oColor[tC].code;
								}
							}
							if (sColorCode == "#FFFFFF")
							{
								sColorCode = "#000000"; 
							}
							dojo.attr(textNode, "color", sColorCode);
						}

						if (typeof(this.data.savedData[savedData].Lines[sIndex].Align) != "undefined")
						{
							dojo.style(textWrapper,"textAlign",this.data.savedData[savedData].Lines[sIndex].Align);
						}

						// nCurNodeColor = dojo.style(nCurNode,"backgroundColor");
						tNodeText = this.data.savedData[savedData].Lines[sIndex].Text;
						tNodeText = tNodeText.replace(/\\\'/g,"'");
						lastNode.innerHTML = tNodeText + "<br />";
					}

					//dojo.place(myLabel,mySavedContainer,"last");

					new dijit.Tooltip({
						connectId: [ToolTipNode],
						label: myToolTipText.innerHTML
					});
					//dojo.place(dojo.create('br'),mySavedContainer,"last");        
				}
			}
		}
      dojo.create('div',{className:"ClearBoth ICSeparator"},this.CoreDOM);
      
      dojo.query('input[id^="ICSavedData"]',MyObj.CoreDOM).onclick(
        function(e)
        {
          var Elem = e.currentTarget;
          if (typeof (Elem) == 'undefined')
          {
            Elem = e.srvElement;
          }
          if (typeof(MyObj.data.savedData[Elem.value]) != 'undefined')
          {
            if(MyObj.data.savedData[Elem.value] == 'new')
            {
          		MyObj.data.preloadData = undefined;
          		MyObj.preloadData = undefined;
          		MyObj.maxLines = MyObj.data.maxLines;
          	}
          	else
          	{
	            if (dojo.byId(MyObj.CoreDOM.id+"InitContainer") != null)
	            {
	              var initContainer = dojo.byId(MyObj.CoreDOM.id+"InitContainer");
	              initContainer.parentNode.removeChild(initContainer);
	              MyObj.form = dojo.create("form", {action: MyObj.data.action, method: MyObj.data.method});
	              initContainer = null;
	            }
	            
				
				MyObj.data.preloadData = MyObj.data.savedData[Elem.value];
				
				// demaskiere hochkommanta
				for ( var sIndex in MyObj.data.preloadData.Lines)
				{
					tNodeText = MyObj.data.preloadData.Lines[sIndex].Text;
					tNodeText = tNodeText.replace(/\\\'/g,"'");
					MyObj.data.preloadData.Lines[sIndex].Text = tNodeText;
				}
				MyObj.preloadData = MyObj.data.preloadData;
			}
          }
          else
          {
            if (dojo.byId(MyObj.CoreDOM.id+"InitContainer") != null)
            {
              var initContainer = dojo.byId(MyObj.CoreDOM.id+"InitContainer");
              initContainer.parentNode.removeChild(initContainer);
              MyObj.form = dojo.create("form", {action: MyObj.data.action, method: MyObj.data.method});
              initContainer = undefined;
              MyObj.data.preloadData=undefined;
              MyObj.preloadData=undefined;
              MyObj.maxLines = MyObj.data.maxLines;
            }
          }
          MyObj.somethingChanged = 1;
          MyObj.previewBox = undefined;
          MyObj.initContainer = dojo.create("div",{id:MyObj.CoreDOM.id + "InitContainer"}, MyObj.CoreDOM);
          MyObj.loadElements();
        }
      );
    }
    this.initContainer = dojo.create("div",{id:this.CoreDOM.id + "InitContainer"}, this.CoreDOM);
    this.loadElements();
  }
  
  /**
  * TODO
  */
  this.loadElements = function()
  {  
    MyObj.linesContainer = dojo.create("div", {className: "InnoEdiLineContainer"}, MyObj.initContainer);
    
    if (MyObj.maxLines > 1 && typeof(MyObj.preloadData) == "undefined" && MyObj.CoreDOM.id != "LogoEdi" && MyObj.CoreDOM.id != "InnoAfterLogo")
    {
      MyObj.addMoreLines = 1;
      
	  // JW 20100511: was soll das hier? warum wird maxLines auf 1 gesetzt? 
	  //              maxLines wird hier für die beim initalisieren maximal anzuzeigenden Zeilen benutzt!
	  MyObj.maxLines = 1;
    }
    else if ((typeof(MyObj.preloadData) == "object") && (countObjects(MyObj.preloadData.Lines)>0))
    {
		if (MyObj.data.maxLines > countObjects(MyObj.preloadData.Lines))
		{
			MyObj.maxLines = countObjects(MyObj.preloadData.Lines);
			MyObj.addMoreLines = 1;
		}
		else
		{
			MyObj.maxLines = MyObj.data.maxLines;
			//MyObj.maxLines = 0;
			MyObj.addMoreLines = 0;
		}
    }
    /** erstelle elemente **/
    for (i = 0; i < MyObj.maxLines; i++) {
      MyObj.createElems(i);
    }
    
    if (MyObj.maxLines == 0)
    {
        MyObj.somethingChanged = 1;     
    }
    
    MyObj.preloadFonts();
    
    if (MyObj.addMoreLines == 1) {
      var aML = dojo.create("a", {id: MyObj.CoreDOM.id + "AddMoreLines", className: "AddMoreIconSmall", innerHTML: ___("ActionAddMore")}, MyObj.initContainer);
      //MyObj = this;
      MyObj.oAddMoreLines = aML;
      dojo.query(aML, MyObj.coreDOM).onclick(
        function (e) {
          dojo.stopEvent(e);
          MyObj.createElems(MyObj.lastLine + 1);
          MyObj.createEvents();
          MyObj.rebrushPreview();
          
          // blende beim erreichen der Maximalen anzahl der Zeilen, den addmore button aus.
          var LinesCounter = dojo.query('.InnoEdiLine',MyObj.CoreDOM).length;
          if (LinesCounter >= parseInt(MyObj.data.maxLines) || LinesCounter <= 1)
          {
            dojo.style(dojo.byId(MyObj.CoreDOM.id + "AddMoreLines"),'display','none');
          }
        }
      );
    }
    
    MyObj.rebrushPreview();
    MyObj.createCustomerComment();
    MyObj.createEvents();
    MyObj.createSubmitButton();
	//MyObj.rebrushPreview();
  }
  
  /**
   * -------------------------------------------------------------------
   *
   * Diese Funktion initialisiert zeilenweise die eingabeelemente
   *
   * -------------------------------------------------------------------
   *
   * @author jw
   * @return undefinded
   */
	this.createElems = function (line) {

		var lineWrapper = dojo.create("div",{id:this.CoreDOM.id + "LineWrapper_"+line,className:this.CoreDOM.id + "LineWrapper_"+line},this.linesContainer);
		var lineNumber = dojo.create("div",{className:"FloatLeft"},lineWrapper);
		lineNumber.innerHTML = '<div class="ICPaddingRight16">'+___("CurrentLine")+"<br />"+'<span class="LineNumber" style="font-size: 20px;padding-left: 10px;"></span></div>';
		
		var lineContainer = dojo.create("div", {id: this.CoreDOM.id + "Line_" + line, className: "FloatLeft InnoEdiLine"}, lineWrapper);
		dojo.style(lineContainer,"width",dojo.style(this.linesContainer,"width") - dojo.style(lineNumber,"width") - 2 + "px");
		dojo.create("div",{className:"ClearBoth MinimizeHeight"},lineWrapper);
		
		if (typeof (this.oModules['ColorSwitcher']) != 'undefined' && this.oModules['ColorSwitcher'] == 1) {
		  /** color switcher **/
		  var CS = this.createColorSwitcher(line);
		  this.initColorSwitcher(CS, "");
		  dojo.place(CS, lineContainer, "last");
		}
		
		if (typeof (this.oModules['FontSwitcher']) != 'undefined' && this.oModules['FontSwitcher'] == 1) {
		  /** font selector **/
		  var FS = this.createFontSelector(line);
		  dojo.place(FS, lineContainer, "last");
		  dojo.create("div", {className:"ClearBoth MinimizeHeight"}, lineContainer);
		}
		
		if (typeof (this.oModules['ElementText']) != 'undefined' && this.oModules['ElementText'] == 1)
		{
			/** input node **/
			var TE = this.createTextElem(line);
			dojo.place(TE, lineContainer, "last");
		 
			if (typeof (this.oModules['FontSwitcher']) != 'undefined' && this.oModules['FontSwitcher'] == 1)
			{
				var curFontNode = dojo.byId(this.CoreDOM.id + 'FontSwitcherValue_' + line);
				console.log("FontSwitcher",curFontNode.value);
				
				curFont = MyObj.findFont(curFontNode.value);
				for (oFont in curFont) {

					var canBold = MyObj.cFontTable[oFont].bold;
					//                  var canUnderline = MyObj.cFontTable[oFont].underline;
					var canItalic = MyObj.cFontTable[oFont].italic;
					if (canBold == 0)
					{
						var boldValue = dojo.byId(MyObj.CoreDOM.id + "isBold_"+line);
						boldValue.value = 0;
						var boldButton = dojo.byId(MyObj.CoreDOM.id + "Bold_"+line);
						dojo.style(boldButton, "borderStyle", "outset");
						dojo.attr(boldButton,"disabled","disabled");
						dojo.addClass(boldButton,"Disabled");
					}
					else
					{
						var boldButton = dojo.byId(MyObj.CoreDOM.id + "Bold_"+line);
						dojo.removeAttr(boldButton,"disabled");
						dojo.removeClass(boldButton,"Disabled");
					}

					if (canItalic == 0)
					{
						var ItalicValue = dojo.byId(MyObj.CoreDOM.id + "isItalic_"+line);
						ItalicValue.value = 0;
						var ItalicButton = dojo.byId(MyObj.CoreDOM.id + "Italic_"+line);
						dojo.style(ItalicButton, "borderStyle", "outset");
						dojo.attr(ItalicButton,"disabled","disabled");
						dojo.addClass(ItalicButton,"Disabled");
					}
					else
					{
						var ItalicButton = dojo.byId(MyObj.CoreDOM.id + "Italic_"+line);
						dojo.removeAttr(ItalicButton,"disabled");
						dojo.removeClass(ItalicButton,"Disabled");
					}
				}
				
			}
		  
		}
		
		
		if((typeof (this.oModules['ColorSwitcher']) == 'undefined' || this.oModules['ColorSwitcher'] == 0) &&
		   (typeof (this.oModules['FontSwitcher'])  == 'undefined' || this.oModules['FontSwitcher'] == 0) &&
		   (typeof (this.oModules['ElementText'])   == 'undefined' || this.oModules['ElementText'] == 0))
		{
			MyObj.somethingChanged = 1; 
		}
		
		
		if (MyObj.oModules.deleteLine == 1)
		{
			if (dojo.query('.InnoEdiLine',MyObj.CoreDOM).length > 1)
			{
				deleteLine = dojo.create("div",{className:"InnoEdiDeleteLine MarginTop FloatRight",id: this.CoreDOM.id + "DeleteLine_" + line});
				dojo.style(deleteLine,"marginRight","5px");
				var deleteLineIcon = dojo.create("i",{className:"InnoEdiDeleteIcon"},deleteLine);
		  
				dojo.query(deleteLine,MyObj.CoreDOM).onclick(
					function(e)
					{
						var Elem = e.currentTarget;
						if (typeof (Elem) == 'undefined') {
							Elem = e.srvElement;
						}
				  
					 var tLine = Elem.id;
					 tLine = tLine.split("_")[1];
				  
					var deleteMe = dojo.byId(MyObj.CoreDOM.id + "LineWrapper_" + tLine);
					deleteMe.parentNode.removeChild(deleteMe);
					MyObj.renumberLines();
					MyObj.rebrushPreview();
				  
					LinesCounter = dojo.query('.InnoEdiLine',MyObj.CoreDOM).length;
					// blende beim unterschreiten der Maximalen anzahl der Zeilen, den addmore button ein.
					if (LinesCounter < parseInt(MyObj.data.maxLines) || LinesCounter <= 1)
					{
						dojo.style(dojo.byId(MyObj.CoreDOM.id + "AddMoreLines"),'display','block');
					}
					}
				);
			  dojo.place(deleteLine,lineContainer,"last");
			}
		}
		dojo.create("div", {className: "ClearBoth MinimizeHeight"}, lineContainer);
		/** PLATZHALTER **/
		dojo.create("div",{className:"ICSeparator"},lineWrapper);
		MyObj.renumberLines();
		this.lastLine = line;
	}
  
    this.renumberLines = function()
    {
        var counter = 1;
        dojo.query("span.LineNumber",MyObj.CoreDOM).forEach(
            function(node)
            {
                node.innerHTML = counter++; 
            }
        );
        
    }
  
  this.createFontSelector = function (line) {
    /**
     * -------------------------------------------------------------------
     * erzeugt ein Element zum Schriftartenwechsel
     * -------------------------------------------------------------------
     * @input line = eindeutige ID
     * @author jw
     * @return nCS = DOM Object des erzeugten Schriftartenwechsels
     */
    var nFS = dojo.create("div", {id: this.CoreDOM.id + "FontSwitcher_" + line, className: "FontSwitcher FloatLeft OneThird"});
    dojo.create("label",{htmlFor:this.CoreDOM.id + "FontSwitcher_" + line,innerHTML:___("SelectYourFont")},nFS);
    dojo.create("br",null,nFS);
    if(typeof (MyObj.oModules['ColorSwitcher']) == 'undefined' || MyObj.oModules['ColorSwitcher'] == 0)
    {
        dojo.addClass(nFS,"ICPaddingLeft19");
    }
    
    var nFSSelectableElems = dojo.create("select", {name: "FontSwitcher_" + line, id: this.CoreDOM.id + "FontSwitcherValue_" + line}, nFS);
    var preloadedFont = "";
    if (typeof(this.preloadData) != 'undefined')
    {
      if (typeof(this.preloadData.Lines) != 'undefined' && typeof(this.preloadData.Lines[line])!= 'undefined')
      {
        preloadedFont = this.preloadData.Lines[line].Font;
      }
    }
    
    for (oFont in this.cFontTable) {
      tOption = dojo.create("option", {value: this.cFontTable[oFont].code, innerHTML: this.cFontTable[oFont].name}, nFSSelectableElems);
      if (this.cFontTable[oFont].code == preloadedFont)
      {
        dojo.attr(tOption,'selected','selected');
      }
    }
    // old and buggy: nfs
    dojo.query(nFSSelectableElems,MyObj.CoreDOM).onchange(
      function (e) {
      
            var Elem = e.currentTarget;
            if (Elem == 'undefined') {
              Elem = e.srcElement;
            }
//            Elem = dojo.query("select",Elem)[0];
			curFont = MyObj.findFont(Elem.value);
			for (oFont in curFont) {

				var canBold = MyObj.cFontTable[oFont].bold;
				//                  var canUnderline = MyObj.cFontTable[oFont].underline;
				var canItalic = MyObj.cFontTable[oFont].italic;
				if (canBold == 0)
				{
					var boldValue = dojo.byId(MyObj.CoreDOM.id + "isBold_"+line);
					boldValue.value = 0;
					var boldButton = dojo.byId(MyObj.CoreDOM.id + "Bold_"+line);
					dojo.style(boldButton, "borderStyle", "outset");
					dojo.attr(boldButton,"disabled","disabled");
					dojo.addClass(boldButton,"Disabled");
				}
				else
				{
					var boldButton = dojo.byId(MyObj.CoreDOM.id + "Bold_"+line);
					dojo.removeAttr(boldButton,"disabled");
					dojo.removeClass(boldButton,"Disabled");
				}

				/*if (canUnderline == 0)
				{
				var UnderlineValue = dojo.byId(MyObj.CoreDOM.id + "isUnderline_"+line);
				UnderlineValue.value = 0;
				var UnderlineButton = dojo.byId(MyObj.CoreDOM.id + "Underline_"+line);
				dojo.style(UnderlineButton, "borderStyle", "outset");
				dojo.attr(UnderlineButton,"disabled","disabled");
				dojo.addClass(UnderlineButton,"Disabled");
				}
				else
				{
				var UnderlineButton = dojo.byId(MyObj.CoreDOM.id + "Underline_"+line);
				dojo.removeAttr(UnderlineButton,"disabled");
				dojo.removeClass(UnderlineButton,"Disabled");
				}
				*/ 
				if (canItalic == 0)
				{
					var ItalicValue = dojo.byId(MyObj.CoreDOM.id + "isItalic_"+line);
					ItalicValue.value = 0;
					var ItalicButton = dojo.byId(MyObj.CoreDOM.id + "Italic_"+line);
					dojo.style(ItalicButton, "borderStyle", "outset");
					dojo.attr(ItalicButton,"disabled","disabled");
					dojo.addClass(ItalicButton,"Disabled");
				}
				else
				{
					var ItalicButton = dojo.byId(MyObj.CoreDOM.id + "Italic_"+line);
					dojo.removeAttr(ItalicButton,"disabled");
					dojo.removeClass(ItalicButton,"Disabled");
				}
			}
			MyObj.somethingChanged = 1;
                
        MyObj.rebrushPreview();
      }
    );

    return nFS;
  }
  
  this.createTextElem = function (line) {
    
    var nTE = dojo.create("div", {id: this.CoreDOM.id + "TextElement_" + line, className: "TextElement FloatLeft ICPaddingLeft19 MarginTop"});
    /* Eingabezeile */
    var newTextElementInput = dojo.create("input", {type: "text", name: "TextElement_" + line, value: ___("TextSample"), id: this.CoreDOM.id + "TextElementValue_" + line}, nTE);
    
    /* Formatierungsknöpfe */
    var boldValue = dojo.create("input", {type: "hidden", value: "0", id: this.CoreDOM.id + "isBold_" + line}, nTE);
    var boldButton = dojo.create("button", {id: this.CoreDOM.id + "Bold_" + line, innerHTML: "F", style: "font-weight: bold", className: "InnoEdiButton ICFormat"}, nTE);
    //var underlineValue = dojo.create("input", {type: "hidden", value: "0", id: this.CoreDOM.id + "isUnderline_" + line}, nTE);
    //var underlineButton = dojo.create("button", {id: this.CoreDOM.id + "Underline_" + line, innerHTML: "U", style: "text-decoration: underline", className: "InnoEdiButton ICFormat"}, nTE);
    var italicValue = dojo.create("input", {type: "hidden", value: "0", id: this.CoreDOM.id + "isItalic_" + line}, nTE);
    var italicButton = dojo.create("button", {id: this.CoreDOM.id + "Italic_" + line, innerHTML: "I", style: "font-style: italic", className: "InnoEdiButton ICFormat"}, nTE);
    
    
    /* align */

    var leftButton = dojo.create("button", {id: this.CoreDOM.id + "left_" + line, innerHTML: "&nbsp;", style: "", className: "InnoEdiButton ICAlign BtnAlignLeft"}, nTE);
    var centerButton = dojo.create("button", {id: this.CoreDOM.id + "center_" + line, innerHTML: "&nbsp;", style: "", className: "InnoEdiButton ICAlign BtnAlignCenter"}, nTE);
    var rightButton = dojo.create("button", {id: this.CoreDOM.id + "right_" + line, innerHTML: "&nbsp;", style: "", className: "InnoEdiButton ICAlign BtnAlignRight"}, nTE);
    var alignValue = dojo.create("input", {type: "hidden", value: "left", name: this.CoreDOM.id + "align_" + line,id: this.CoreDOM.id + "align_" + line, className:"HideElement"}, nTE);
    
    if (typeof(this.preloadData) != 'undefined')
    {
      if (typeof(this.preloadData.Lines) != 'undefined' && this.preloadData.Lines[line])
      {
        newTextElementInput.value = dojox.html.entities.decode(this.preloadData.Lines[line].Text);
        
        if(typeof(this.preloadData.Lines[line].Align) != 'undefined')
        {
            alignValue.value = this.preloadData.Lines[line].Align;
        }
        
        
        if (this.preloadData.Lines[line].Bold == 1)
        {
          dojo.style(boldButton, "borderStyle", "inset");
          boldValue.value=1
        }
        
       /* if (this.preloadData.Lines[line].Underline == 1)
        {
          dojo.style(underlineButton, "borderStyle", "inset");
          underlineValue.value=1;  
        }*/
        if (this.preloadData.Lines[line].Italic == 1)
        {
          dojo.style(italicButton, "borderStyle", "inset");
          italicValue.value=1;  
        }
      }
    }

    /* EVENTS für die Ausrichtungsbuttons */
    dojo.query("button.ICAlign",nTE).forEach(
        function(tAlignNode)
        {
            
            var ttLine = tAlignNode.id.split("_")[1];
            var ttName = tAlignNode.id.split("_")[0];
            ttName = ttName.replace(MyObj.CoreDOM.id, "");
            if(ttName == alignValue.value)
            {
                dojo.style(tAlignNode, "borderStyle", "inset");
            }
            else
            {
                dojo.style(tAlignNode, "borderStyle", "outset");
            }
        }
    );
    
    /* EVENTS für die Ausrichtungsbuttons */
    dojo.query("button.ICAlign", nTE).onclick(function (e) {
      dojo.stopEvent(e);
      
      MyObj.somethingChanged = 1;
      
      var Elem = e.currentTarget;
      if (Elem == 'undefined') {
        Elem = e.srcElement;
      }
      var tLine = Elem.id.split("_")[1];
      var tName = Elem.id.split("_")[0];
      tName = tName.replace(MyObj.CoreDOM.id, "");
      var vTemp = dojo.byId(MyObj.CoreDOM.id + "align_" + tLine);
      vTemp.value = tName;
      dojo.query("button.ICAlign",MyObj.CoreDOM).forEach(
        function(tAlignNode)
        {
            var ttLine = tAlignNode.id.split("_")[1];
            var ttName = tAlignNode.id.split("_")[0];
            ttName = ttName.replace(MyObj.CoreDOM.id, "");
            if(ttLine == tLine)
            {
                if(ttName == tName)
                {
                    dojo.style(tAlignNode, "borderStyle", "inset");
                }
                else
                {
                    dojo.style(tAlignNode, "borderStyle", "outset");
                }
            }
        }
      );
      MyObj.rebrushPreview();
    });
    
    /* EVENTS für die Formatierungsknöpfe */
    dojo.query("button.ICFormat", nTE).onclick(function (e) {
      dojo.stopEvent(e);
      var Elem = e.currentTarget;
      if (Elem == 'undefined') {
        Elem = e.srcElement;
      }
      var tLine = Elem.id.split("_")[1];
      var tName = Elem.id.split("_")[0];
      tName = tName.replace(MyObj.CoreDOM.id, "");
      vTemp = dojo.byId(MyObj.CoreDOM.id + "is" + tName + "_" + tLine);
      if (vTemp.value == "0") {
        vTemp.value = "1";
        dojo.style(Elem, "borderStyle", "inset");
      }
      else {
        vTemp.value = "0";
        dojo.style(Elem, "borderStyle", "outset");
      }
      
      MyObj.somethingChanged = 1;
      
      MyObj.rebrushPreview();
    });
    return nTE;
  }
  
  this.createEvents = function () {
    /**
     * -------------------------------------------------------------------
     *
     * verankert auf die erstellten elemente alle notwendigen events
     *
     * -------------------------------------------------------------------
     *
     * @author jw
     * @return undefinded
     */
    /** TODO **/
    var myObj = this;
    
    dojo.forEach(myObj.event, function(evt)
    {
      dojo.disconnect(evt);
    });
    
    dojo.query('input', this.CoreDOM).forEach(
      function(node)
      {
        newEvt = dojo.connect(node,"onclick",null,function(e)
        {
          myObj.rebrushPreview();
        });
        myObj.event.push(newEvt);
      }
    );  
 
		dojo.query('input[type="radio"]',this.CoreDOM.parentNode).forEach(
			function(node)
			{
				MyObj.somethingChanged = 1;
			}
		); 
 
    dojo.query('input[type="radio"]',this.CoreDOM).forEach(
        function(node)
        {
           newEvt = dojo.connect(node,"onclick",null,function(e)
           {
              var Elem = e.currentTarget;
		          if (Elem == 'undefined') {
		            Elem = e.srcElement;
		          }
		          var tLine = Elem.id;
		          tLine = tLine.split("_")[1];
		          if (typeof (MyObj.oModules['ColorSwitcher']) != 'undefined' && MyObj.oModules['ColorSwitcher'] == 1)
		          {
              if(Elem.value == "userdefined")
              {
                dojo.query('#'+MyObj.CoreDOM.id + 'ColorSwitcherUL_' + tLine,MyObj.CoreDOM).forEach(
                    function(tnode)
                    {
                        dojo.attr(tnode,'disabled','disabled');
                    }
                );
                dojo.query('#'+MyObj.CoreDOM.id + 'ColorSwitcherValue_' + tLine,MyObj.CoreDOM).forEach(
                    function(tnode)
                    {
                        dojo.removeAttr(tnode,'disabled');
                    }
                );
              }
              else /* predefined */
                {
                    dojo.query('#'+MyObj.CoreDOM.id + 'ColorSwitcherUL_' + tLine,MyObj.CoreDOM).forEach(
                    function(tnode)
                    {
                        dojo.removeAttr(tnode,'disabled');
                    }
                );
                dojo.query('#'+MyObj.CoreDOM.id + 'ColorSwitcherValue_' + tLine,MyObj.CoreDOM).forEach(
                    function(tnode)
                    {
                        dojo.attr(tnode,'disabled','disabled');
                    }
                );
                }
            }
            console.log(Elem,"wurde geklickt");
						MyObj.somethingChanged = 1;
            myObj.rebrushPreview();
            });
            myObj.event.push(newEvt);   
        }
    );
    
    dojo.query('input[id^="' + this.CoreDOM.id + 'TextElementValue_"]', this.CoreDOM).forEach(function(node)
    {
      newEvt = dojo.connect(node,"onkeyup",null,function(e)
      {
        MyObj.somethingChanged = 1;
        myObj.rebrushPreview();
      });
      myObj.event.push(newEvt);
    });
    
    
    
    dojo.query('select[id^="' + this.CoreDOM.id + 'ColorSwitcherUL_"]', this.CoreDOM).onchange(
        function (e)
      {
          var Elem = e.currentTarget;
          if (Elem == 'undefined') {
            Elem = e.srcElement;
          }
          var tLine = Elem.parentNode.id;
          tLine = tLine.split("_")[1];
          
          MyObj.somethingChanged = 1;
          
          myObj.rebrushPreview();
    });

  }
  
  this.createColorSwitcher = function (line) {
    /**
     * -------------------------------------------------------------------
     * erzeugt ein Element zum Farbwechsel
     * -------------------------------------------------------------------
     * @input line = eindeutige ID
     * @author jw
     * @return nCS = DOM Object des erzeugten Farbwechslers
     */
    var nCS = dojo.create("div", {id: this.CoreDOM.id + "ColorSwitcher_" + line, className: "ColorSwitcher"});
    /* Vordefinierter Farbauswähler */
    var tempContainer = dojo.create("div",{className: "FloatLeft OneThird"},nCS);
    dojo.create("label",{className:"ICPaddingLeft19",htmlFor:this.CoreDOM.id + "ColorModelpredefined_" + line,innerHTML:___("PredefinedColorTable")},tempContainer);
    dojo.create("br",null,tempContainer);
    var precolorinput = dojo.create("input",{type:"radio",checked:"checked",id:this.CoreDOM.id + "ColorModelpredefined_" + line,name:this.CoreDOM.id + "ColorModel_" + line, value:"predefined"},tempContainer);
    var nCSSelectableElems = dojo.create("select", {className: "Switcher predefined", id: this.CoreDOM.id + "ColorSwitcherUL_" + line}, tempContainer);
    dojo.attr(precolorinput,"checked","checked");
    /* Vordefinierter Farbauswähler ENDE*/
    
    /* Manueller Container START */
    var tempContainer = dojo.create("div",{className: "FloatLeft OneThird"},nCS);
    
    dojo.create("label",{className:"ICPaddingLeft19",htmlFor:this.CoreDOM.id + "ColorModeluserdefined_" + line,innerHTML:___("UserdefinedColorTable")},tempContainer);
    dojo.create("br",null,tempContainer);
    var userdefinedinput = dojo.create("input",{type:"radio",id:this.CoreDOM.id + "ColorModeluserdefined_" + line,name:this.CoreDOM.id + "ColorModel_" + line, value:"userdefined"},tempContainer);
    var ColorValue = dojo.create("input", {className: "userdefined", type: "text", name: this.CoreDOM.id + "ColorSwitcher_" + line, value: ___("ColorDefaultValue"), id: this.CoreDOM.id + "ColorSwitcherValue_" + line}, tempContainer);
    
    dojo.attr(ColorValue,'disabled','disabled');
    if (typeof(this.preloadData) != 'undefined')
    {
		if (typeof(this.preloadData.Lines) != 'undefined')
		{
			if (typeof(this.preloadData.Lines[line]) != 'undefined')
			{
				if (typeof(this.preloadData.Lines[line].Color) != 'undefined')
				{
					var oColor = MyObj.findColor(dojox.html.entities.decode(this.preloadData.Lines[line].Color));        
					if (countObjects(oColor) == 0) {
						ColorValue.value = dojox.html.entities.decode(this.preloadData.Lines[line].Color);
						dojo.attr(nCSSelectableElems,'disabled','disabled');
						dojo.removeAttr(ColorValue,"disabled");
						dojo.attr(userdefinedinput,"checked","checked");
					}
				}
			}
		}
    }
    /* Manueller Container ENDE */
    //dojo.create("div",{className: "ClearBoth MinimizeHeight"},nCS);
    
    return nCS;
  }
  
  this.initColorSwitcher = function (Elem, sString) {
    /**
     * -------------------------------------------------------------------
     * initalisiert die Farbtabelle des Farbwechslers
     * -------------------------------------------------------------------
     * @input Elem = Node Element des Farbwechselers, sString = Suchstring
     * @author jw
     * @return CSSelectableElems = DOM Object der veränderten Farbwerte
     */
    if (typeof (MyObj.oModules['ColorSwitcher']) != 'undefined' && MyObj.oModules['ColorSwitcher'] == 0) {
        return;
    }
    var ColorTable = this.findColor(sString);
    var tLine = Elem.id;
    tLine = tLine.split("_")[1];
    var CSSelectableElems = dojo.query('select[id^="' + this.CoreDOM.id + 'ColorSwitcherUL_"]', Elem)[0];
    Elem = CSSelectableElems.parentNode;
    
    if (CSSelectableElems.parentNode.hasChildNodes())
    {
        CSSelectableElems.parentNode.removeChild(CSSelectableElems);
    }
    CSSelectableElems = dojo.create("select", {className: "Switcher predefined",id: this.CoreDOM.id + "ColorSwitcherUL_" + tLine}, Elem);

    var ColorTable = this.cColorTable;
    
    // Wenn die maximalzahl der möglichen wählbaren Farben erreicht ist, dann setze die bereits
    // gewählten farben als ergebnismenge ein
    var disableme = false;
    var colorfound = false;

	for (color in ColorTable) {
		nLI = dojo.create("option", {value: ColorTable[color].name, data: ColorTable[color].name, innerHTML: ColorTable[color].name}, CSSelectableElems);
		dojo.style(nLI,"backgroundColor",ColorTable[color].code);
		if (typeof(MyObj.preloadData) != 'undefined')
		{
			if (typeof(MyObj.preloadData.Lines) != 'undefined')
			{
				if(typeof(MyObj.preloadData.Lines[tLine]) != 'undefined')
				{
					disableme = true;
					if(ColorTable[color].name == dojox.html.entities.decode(MyObj.preloadData.Lines[tLine].Color))
					{
						dojo.attr(nLI,"selected","selected");
						colorfound = true;
					}
				}
			}
		}
	}
	
	/** wenn keine farbe gefunden wurde, weil keine an preloaddata steht, dann darf die box nicht disabled werden */
	if(MyObj.preloadData != undefined)
	{
		if (typeof(MyObj.preloadData.Lines[tLine]) != 'undefined')
		{
			if (MyObj.preloadData.Lines[tLine].Color == undefined)
			{
				disableme = false;
			}
		}
	}
    if(disableme == true && colorfound == false)
    {
        dojo.attr(CSSelectableElems,"disabled","disabled");
    }

    return CSSelectableElems;
  }
  
  this.findFont = function (input) {
    /**
     * -------------------------------------------------------------------
     * Hilfsfunktion zum suchen einer bestimmten Schriftart in this.cFontTable
     * -------------------------------------------------------------------
     * @input input = suchstring
     * @author jw
     * @return oReturn = Object mit gefundenen Schriftart (analog zu this.cFontTable)
     */
    //var rx = new RegExp(toRegEx(input), "i");
    var oReturn = new Object;
    for (font in this.cFontTable) {
      //var result = rx.exec(this.cFontTable[font].name)
      if (input == this.cFontTable[font].name) {
        oReturn[font] = this.cFontTable[font];
      }
    }
    return oReturn;
  }
  
  this.findColor = function (input) {
    /**
     * -------------------------------------------------------------------
     * Hilfsfunktion zum suchen einer bestimmten Farbe in this.cColorTable
     * -------------------------------------------------------------------
     * @input input = suchstring
     * @author jw
     * @return oReturn = Object mit gefundenen Farben (analog zu this.cColorTable)
     */
     
    //return this.cColorTable;
    var rx = new RegExp(toRegEx(input), "i");
    var oReturn = new Object;
    for (color in this.cColorTable) {
      var result = rx.exec(this.cColorTable[color].name)
      if (result) {
        oReturn[color] = this.cColorTable[color];
      }
    }
    return oReturn;
  }
  
  var toRegEx = function (input) {
    return input.replace(/([\^\$\.\*\+\?\=\!\:\|\\\/\(\)\[\]\{\}])/g, "\\$1");
  };
  
  var countObjects = function (obj) {
    /**
     * -------------------------------------------------------------------
     * Hilfsfunktion zum zählen aller SubObjects eines Objektes
     * -------------------------------------------------------------------
     * @input obj = Objekt, welches durchgezählt werden soll
     * @author jw
     * @return integer
     */
    var i = 0;
    for (var p in obj) i++;
    return i;
  }
  
  this.rebrushPreview = function () {
    MyObj.usedColors = new Object();
    
    if (typeof (MyObj.oModules['PreviewBox']) == 'undefined' || MyObj.oModules['PreviewBox'] == 0) {
      return;
    }
    if (!MyObj.previewBox) {
      MyObj.createPreview();
    }
    MyObj.previewBox.innerHTML = "";
   
    dojo.query('input[id^="' + MyObj.CoreDOM.id + 'TextElementValue_"]', this.CoreDOM).forEach(
      function (node) {
        var tLine = node.id;
        tLine = tLine.split("_")[1];
        var lastNode;
        
        if(MyObj.checkData(node) == false)
		{
			dojo.attr(node,"texterror","true");
			dojo.addClass(node,"DialogError");
		}
		else
		{
			dojo.removeAttr(node,"texterror");
			dojo.removeClass(node,"DialogError");   
		}
        
        var nCurNode = dojo.create("div", {id: MyObj.CoreDOM.id + "_" + tLine}, MyObj.previewBox);
        var lastNode = nCurNode;
        
        var isBold = dojo.byId(MyObj.CoreDOM.id + "isBold_" + tLine);
        if (isBold.value == "1") {
          var nBoldNode = dojo.create("b", null, lastNode);
          lastNode = nBoldNode;
        }
        
        var isItalic = dojo.byId(MyObj.CoreDOM.id + "isItalic_" + tLine);
        if (isItalic.value == "1") {
          var nItalicNode = dojo.create("i", null, lastNode);
          lastNode = nItalicNode;
        }
        
        //var isUnderline = dojo.byId(MyObj.CoreDOM.id + "isUnderline_" + tLine);
        /*if (isUnderline.value == "1") {
          var nUnderlineNode = dojo.create("u", null, lastNode);
          lastNode = nUnderlineNode;
        }*/
        
        var sAlign = dojo.byId(MyObj.CoreDOM.id + "align_" + tLine).value;
        
        /* encode der HTML elemente */
		var tText = dojox.html.entities.encode(node.value);
		
		var nFontNode = dojo.create("font", {innerHTML: tText}, lastNode);
        var oColorNode = dojo.byId(MyObj.CoreDOM.id + "ColorSwitcherUL_" + tLine);
        dojo.style(nCurNode,'textAlign',sAlign);
        if (oColorNode != undefined)
        {
            if (dojo.attr(oColorNode,'disabled'))
            {
                oColorNode = dojo.byId(MyObj.CoreDOM.id + "ColorSwitcherValue_" + tLine);
            }
        
            var oColor = MyObj.findColor(oColorNode.value);
//            dojo.style(nCurNode,'textAlign',sAlign);
            var sColorCode = "#000000";
    
            MyObj.usedColors[oColorNode.value] = 1;
    
            if (countObjects(oColor) == 1) {
              for (tC in oColor) {
                sColorCode = oColor[tC].code;
                // MyObj.usedColors[tC] = oColor[tC];
              }
            }
            if (sColorCode == "#FFFFFF")
            {
                sColorCode = "#000000"; 
            }
            dojo.attr(nFontNode, "color", sColorCode);
            nCurNodeColor = dojo.style(nCurNode,"backgroundColor");
        
            /*
             * Berechnung der Hintergrundfarbe, wenn TextFarbe nicht lesbar
            if (brightness(sColorCode, nCurNodeColor))
            {
                dojo.style(nCurNode,"backgroundColor","#FFFFFF");
            }
            else
            {
                dojo.style(nCurNode,"backgroundColor","#000000");
            }
            */
        }
        oFontNode = dojo.byId(MyObj.CoreDOM.id + "FontSwitcherValue_" + tLine);
        sFontCode = "Arial";
        var oFont = MyObj.findFont(oFontNode.value);
        var sFontHasTTF = 0;
        if (countObjects(oFont) == 1) {
          for (tF in oFont) {
            sFontCode = oFont[tF].code;
            if (typeof (oFont[tF].source) != "undefined") {
              sFontHasTTF = 1;
            }
          }
        }
        dojo.attr(nFontNode, "face", sFontCode);
        if (sFontHasTTF == 1) {
          Cufon.replace(nFontNode, {fontFamily: sFontCode});
        }

		
      }
    );
    
       
    if(dojo.query('input[texterror="true"]',MyObj.CoreDOM).length > 0)
    {
        dojo.query('[type="submit"]',MyObj.CoreDOM).forEach(
            function (sNode)
            {
                //dojo.attr(sNode,"disabled","disabled");
                //dojo.addClass(sNode,"Disabled");
                    MyObj.globalError = 1;
            }
        );
    }
    else
    {
        dojo.query('[type="submit"]',MyObj.CoreDOM).forEach(
            function (sNode)
            {
                MyObj.globalError = 0;
                    //dojo.removeAttr(sNode,"disabled");
                //dojo.removeClass(sNode,"Disabled");
            }
        );  
    }
    
  }
  
  this.createPreview = function () {
    /**
     * -------------------------------------------------------------------
     * TODO
     * -------------------------------------------------------------------
     * TODO
     * @author jw
     * @return integer
     */
    var PW = dojo.create("div", {className: "PreviewWrapper"}, this.initContainer);
    dojo.create("div", {className: "ICSeparator"}, PW);
    dojo.create("div", {className: "FloatLeft ColorOrange", innerHTML: "<strong>" + ___("HeadLinePreview") + "</strong>"}, PW);
    this.previewBox = dojo.create("div", {className: "FloatRight PreviewBox"}, PW);
    dojo.style(this.previewBox,"border","1px solid #cccccc");
    dojo.style(this.previewBox,"width","400px");
    dojo.style(this.previewBox,"height","auto");
    dojo.style(this.previewBox,"padding","10px");
    
    
    dojo.create("div", {className: "ClearBoth MinimizeHeight"}, PW);
  }
  
  this.createCustomerComment = function () {
    var CCDiv = dojo.create("div", {className: "CustomerComment"}, this.initContainer);
    var CCLabel = dojo.create("label", {htmlFor: "CustomerComment"}, CCDiv);
    CCLabel.innerHTML = '<strong class="ColorOrange">' + ___("YourComment") + "</strong>";
    var CC = dojo.create("textarea", {name: "CustomerComment", row: 10, className: 'FullSize'}, CCDiv);

    if (typeof(this.preloadData) != 'undefined')
    {
      if(this.preloadData.Comment)
      {
        CC.value = this.preloadData.Comment;
      }
    }
  }
  
  this.checkData = function(node)
  {
    if (node.value.length > 0)
    {
        return true;
    }
    return false;
  }
  
  this.createConfigData = function()
  {
    var aLines = dojo.query('[id^="'+MyObj.CoreDOM.id+'Line_"]',MyObj.CoreDOM);
    var outputData = new Object;
    var aLineObject = new Array;
   
    outputData.Comment = dojox.html.entities.encode(dojo.query('div.CustomerComment textarea',MyObj.CoreDOM)[0].value);
    if (typeof (MyObj.data.addDataFields) == 'object' && MyObj.data.addDataFields.ffile) {
      dojo.query('[id^="ffile"]').forEach(function(node){
          if (node.checked)
          {
            outputData.File = dojox.html.entities.encode(node.value);
          }
        }
      );
    }
   
    // check if there is a AfterLogo Upload option
    if (MyObj.CoreDOM.id == "InnoAfterLogo")
    {
    	outputData.File = 'NoFile';	
    }
   
    aLines.forEach(function(line){
      var tLine = line.id.split("_")[1];
      var tObj = new Object();
      tObj.Line = tLine;
      if (typeof (MyObj.oModules['ColorSwitcher']) != 'undefined' && MyObj.oModules['ColorSwitcher'] == 1) {
        
        var colorSwitcherLine = dojo.query('#'+MyObj.CoreDOM.id+'ColorSwitcher_'+tLine)[0];
        
        var availColorModes = dojo.query('input[type="radio"]',colorSwitcherLine);
        var colorMode;
        availColorModes.forEach(
            function(tNode)
            {
                if (dojo.attr(tNode,"checked"))
                {
                    colorMode = tNode;  
                }
            }
        );
        
        var color = dojo.query('.ColorSwitcher .'+colorMode.value,line)[0];
        tObj.Color = dojox.html.entities.encode(addslashes(color.value));
      }
      
      if (typeof (MyObj.oModules['FontSwitcher']) != 'undefined' && MyObj.oModules['FontSwitcher'] == 1) {
        var font = dojo.query('.FontSwitcher select',line)[0];
        if (font != undefined)
        {
        	tObj.Font = dojox.html.entities.encode(font.value);
        }
      }
      
      if (typeof (MyObj.oModules['ElementText']) != 'undefined' && MyObj.oModules['ElementText'] == 1) {

        var isBold = dojo.byId(MyObj.CoreDOM.id + "isBold_" + tLine);
        if (isBold != undefined)
        {
        	tObj.Bold = dojox.html.entities.encode(isBold.value);
        }
        
        var isItalic = dojo.byId(MyObj.CoreDOM.id + "isItalic_" + tLine);
        if (isItalic != undefined)
        {
        	tObj.Italic = dojox.html.entities.encode(isItalic.value);
        }
        
        /*var isUnderline = dojo.byId(MyObj.CoreDOM.id + "isUnderline_" + tLine);
        if (isUnderline != undefined)
        {
        	tObj.Underline = dojox.html.entities.encode(isUnderline.value);
        }*/
                
        var oAlign = dojo.byId(MyObj.CoreDOM.id + "align_" + tLine);
        if (oAlign != undefined)
        {
        	tObj.Align = dojox.html.entities.encode(oAlign.value);
        }
                
        var printingText = dojo.byId(MyObj.CoreDOM.id + "TextElementValue_" + tLine);
        if (printingText != undefined)
        {
        	tText = dojox.html.entities.encode(printingText.value);
/**			tText = tText.replace(/\'/g,"\\'"); */
			tText = addslashes(tText);
			tObj.Text = tText;
        }
      }
      
      aLineObject.push(tObj);
    });
    outputData.Lines = aLineObject;
    return dojo.toJson(outputData);  
  }
  
  this.createSubmitButton = function () {
    btnSubmitDiv = dojo.create("div", {className: "AlignRight ICMarginTop10"});
    dojo.place(this.form, btnSubmitDiv);
	
    var btnSubmit = dojo.create("input", {type: "submit", value: ___("submitData"), className: "ICButton FloatRight"}, this.form);
    
	var btnAbort  = dojo.create("span",{className:"MarginRight FloatRight ICButton Close"},this.form);
	
	
	
	dojo.style(btnAbort,"position","relative");
	dojo.style(btnAbort,"top","0");
	dojo.style(btnAbort,"right","0");
	btnAbort.innerHTML = ___("Abort");
	dojo.create("div",{className:"ClearBoth MinimizeHeight"},this.form);
    dojo.place(btnSubmitDiv, this.initContainer, "last");
    window.createCloseMediaData();
    dojo.query("input[type=submit]", btnSubmitDiv).onclick(
      function (e) {
        dojo.stopEvent(e);
        if (MyObj.somethingChanged == 0)
        {
            alert(___("GlobalWarning_Code3"));  
        }
          else if (countObjects(MyObj.usedColors) > MyObj.maxColors)
          {
              alert(___("GlobalWarning_Code2"));
          }
          else if (MyObj.globalError == 1)
          {
              alert(___("GlobalWarning_Code1"));
              return false;
          }
          else
          {
	        if (MyObj.isSubmitting == false)
	        {
	          MyObj.isSubmitting = true;
	          document.body.style.cursor = 'wait !important';
	          var divInfo = dojo.position(MyObj.CoreDOM.parentNode.parentNode.parentNode, true);
	          var ani = dojo.byId('LoaderAniNode');
	          var aniInfo = dojo.position(ani, true);
	          
	          var lastX = divInfo.x + (divInfo.w - aniInfo.w) / 2;
	          var lastY = divInfo.y + (divInfo.h - aniInfo.h) / 2;
	          dojo.style(ani, {
	            left: lastX + "px",
	            top: lastY + "px",
	            display: "block",
	            zIndex: 9999
	          });
	          
	          dojo.query('input[type=hidden]', MyObj.form).forEach(
	            function (node) {
	              node.parentNode.removeChild(node);
	            }
	          );
	          
	          
	          dojo.create('input', {type: 'hidden', value: MyObj.enableDebug, name: 'Debug'}, MyObj.form);
	          dojo.create('input', {type: 'hidden', value: MyObj.ChangeAction, name: 'ChangeAction'}, MyObj.form);
	          if (typeof(MyObj.preloadData) == 'undefined' && MyObj.doUpdate == 0)
	          {
	            dojo.create('input', {type: 'hidden', value: dojo.attr(dojo.byId('ICMainObject'), "value"), name: 'ViewObjectID'}, MyObj.form);
	            dojo.create('input', {type: 'hidden', value: dojo.attr(dojo.byId('ICMainObject'), "value"), name: 'ChangeObjectID'}, MyObj.form);
	            dojo.create('input', {type: 'hidden', value: dojo.attr(dojo.byId('ICSubObject'), "value"), name: 'ChangeObjectID'}, MyObj.form);
	          }
	          else
	          {
	            if (typeof(MyObj.data.ChangeObject) != 'undefined')
	            {
	              dojo.create('input', {type: 'hidden', value: MyObj.data.ChangeObject, name: 'ChangeObjectID'}, MyObj.form);
	            }
	            else
	            {
	              dojo.create('input', {type: 'hidden', value: dojo.attr(dojo.byId('ICMainObject'), "value"), name: 'ChangeObjectID'}, MyObj.form);
	              dojo.create('input', {type: 'hidden', value: dojo.attr(dojo.byId('ICSubObject'), "value"), name: 'ChangeObjectID'}, MyObj.form);  
	            }
	            
	            if (typeof(MyObj.data.BasketObject) != 'undefined')
	            {
	              dojo.create('input', {type: 'hidden', value: MyObj.data.BasketObject, name: 'ViewObjectID'}, MyObj.form);
	            }
	            else
	            {
	              dojo.create('input', {type: 'hidden', value: dojo.attr(dojo.byId('ICMainObject'), "value"), name: 'ViewObjectID'}, MyObj.form);
	            }
	          }
	          dojo.create('input', {type: 'hidden', value: MyObj.createConfigData(), name: 'IC_ConfigData'}, MyObj.form);
	          if (typeof (MyObj.data.addDataFields) == 'object' && countObjects(MyObj.data.addDataFields) > 0) {
	            for (node in MyObj.data.addDataFields) {
	              var tmpNode = dojo.query('[id^="' + node + '"]');
	              if (typeof (tmpNode[0]) != 'undefined' && node != 'ICSubObject' && node != 'ICMainObject') {
	                tmpValue = dojo.attr(tmpNode[0], MyObj.data.addDataFields[node]);
	                if (node == "ICQuantity")
	                {
	                	tmpValue = parseNumber(tmpValue);	
	                }
	                dojo.create('input', {type: 'hidden', value: tmpValue, name: node}, MyObj.form);
	              }
	            }
	          }
				dojo.query('[id^="ICSavedData"]',MyObj.CoreDOM).forEach(
					function(node)
					{
						if(node.checked)
						{
							dojo.create('input', {type: 'hidden', value: dojo.attr(node, "value"), name: 'ICSavedTextKey'}, MyObj.form);
						}
					}
				);
			 
			 
	          // now, ready to send data to basket, it could be funny
            dojo.xhrPost({
                form: MyObj.form,
                handleAs: "text",
                load: function (data) {
                    MyObj.isSubmitting = false;
              	    dojo.style(ani, {display: 'none', zIndex: '1', left: '-9999px', top: '-9999px'});
                    document.body.style.cursor = '';
                    window.location.href = epages.vars.BaseUrl + "?ObjectID="+epages.vars.ObjectID;
                },
                error: function (error) {
                    MyObj.isSubmitting = false;
                    dojo.style(ani, {display: 'none', zIndex: '1', left: '-9999px', top: '-9999px'});
                    document.body.style.cursor = '';
                }
            });
	        }
				}
      }
    );
  }
}