Malicious PDF — malware analysis report

markedDirty = this.dirty;	// dirty marker to dirty (false) after saving

registrySave();
Library_Save();

var x = new XML ( this.getField("Pandora").value );
this.getField("Pandora").value = x.toString();

registryInit();
Library_Init();

buttonHandler(event.target.name);

buttonMouseInHandler(event.target.name);

buttonMouseOutHandler(event.target.name);

iconHandler(event.target.name);

iconMouseInHandler(event.target.name);

iconMouseOutHandler(event.target.name);

iconHandler(event.target.name);

iconMouseInHandler(event.target.name);

iconMouseOutHandler(event.target.name);

iconMouseInHandler(event.target.name);

iconHandler(event.target.name);

iconMouseInHandler(event.target.name);

iconMouseOutHandler(event.target.name);

iconHandler(event.target.name);

showPage ( PageText, true );
this.getField("Button_SavePage").display = display.hidden;

showPage ( PageText, false );
this.getField("Button_SavePage").display = display.visible;

iconHandler(event.target.name);

if ( typeof FDFLoadedStatus == "undefined" ) initialiseFromXFDF();
var FDFLoadedStatus = true;

this.getField("Transmitter").value = "";

var DlgMainMenuCode = 
"01009237004211An11JC11Jp11bA11bb11Io11np11pN11JI11Jd11bJ11Uf11UG11JA11bc11bo11bN11bn11cU11cA11cb11cf1"+
"1cd11cI11UI11Ud11Ap11cJ11UU11cc11U111c111UA11AC11cn11II11cB11Jc11IA11JJ11Uo11Un11Uc11In11Af11Ad11co11"+
"If111n11Jn11Ub11cG11bp11AN11Ic11IJ11UJ11IU11IB11IN11AA11Ip11Ib11IC11Id11A11BAc1J1b1I1bUcfdJGboNBnCpKO"+
"DkID1g1G2p1LKCwAc1J1b1I1bUcfdJGboNBnCpV1d1BIdCC1g1Gf2c2DcFgFhJ2h1RN2i2BIdCvBTB2gJQG1B2c1KDm1C1digI1Eo"+
"CwAc1J1b1I1bUcfdJGboNBnCpWCtU1y1SH1bV1d1BIdCC1g1Gf1v1PhMFc2g2GBdoCAy1J1b1I1bUcfdJGboNBnP1gOiIRAAA1i1F"+
"uIJdfJgEFjIdBhfRAAA1bWwZgBCegO1fPNjCIdCtBfi1Fggs1GCh1dAD1E2b2BipZgBCenMjRwDBfMfRAAAbbBiIgBF2c2AlO1fPN"+
"jCIdCtLJgBCemUzZ1q1J1b1IkEc1x2EBiJ1g1GAzZyFTkJgBCey1BCddlLEc1x2EBilBTyMfRAAAlHsAVifO1fPNjCIdCtLJgBCem"+
"UzZ1q1J1b1Ie2i1ORdJ1g1GkJgBCeyJOF1e1FsBBTyMfARAAAfwSH1bXjO1fPNjCIdCtLJgBCemUzZAkJgBCey1EBilQgFCtUcpBT"+
"yMfRAAAfrfhA1EjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1GA1jPTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfhF"+
"YjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1GA1eKTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfhm1QjO1fPNjCIdC"+
"tLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1GA1v1CTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfhc1GjO1fPNjCIdCtLJgBCemUzZ"+
"A1bUcfdJGboNBnCpKODkID1g1GA1lRTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfhe1IjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboN"+
"BnCpKODkID1g1GA1nTTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfhl1PjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g"+
"1GA1u1BTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfhi1MjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1GA1rXTkJgB"+
"Cey1EBilQgFCtUcpBTyMfRAAAfrfhn1RjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1GA1w1DTkJgBCey1EBilQgF"+
"CtUcpBTyMfRAAAfrfhk1OjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1GA1tZTkJgBCey1EBilQgFCtUcpBTyMfRA"+
"AAfrfhj1NjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1GA1sYTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfcf1EjO1"+
"fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1G1efPTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfcAYjO1fPNjCIdCtLJgB"+
"CemUzZA1bUcfdJGboNBnCpKODkID1g1G1eAKTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfcr1QjO1fPNjCIdCtLJgBCemUzZA1bUcf"+
"dJGboNBnCpKODkID1g1G1er1CTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfch1GjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpK"+
"ODkID1g1G1ehRTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfcj1IjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1G1ej"+
"TTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfcq1PjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1G1eq1BTkJgBCey1E"+
"BilQgFCtUcpBTyMfRAAAfrfcn1MjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1G1enXTkJgBCey1EBilQgFCtUcpB"+
"TyMfRAAAfrfcs1RjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1G1es1DTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrf"+
"cp1OjO1fPNjCIdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1G1epZTkJgBCey1EBilQgFCtUcpBTyMfRAAAfrfco1NjO1fPNjC"+
"IdCtLJgBCemUzZA1bUcfdJGboNBnCpKODkID1g1G1eoYTkJgBCey1EBilQgFCtUcpBTyMfARAAAkHuMw1H1j1BIdCmdRAAAzIR0GA"+
"cfpTlOflJGbCqNBnKhfR0GAddDtTBhoJdR0GA2a1IR0KAzZj1gF1HlOf1l1Pc1j1HhFBFhGlChRfex1FBmOfcBFhGlCIBhG1f1DhJ"+
"dDtTBhoJdR0OA2a1IR0SAzZj1gF1HlOfsOCcIkcEG2b1UEhLiGtJMjeJsOCcEhgPChkJfwCWKfpTlmUcfdJGboNBnCpV1d1BIdCkB"+
"hL1bUy1LjBjEpo1GFBFhGuTBhfJcBFhGlCIBhG1f1Dhs1BChfOffJgBCeDhpXceeOjySMjmMfR0SAzZj1gF1HlOfdB1d1FhLiGtJM"+
"jeOfdB1dGYhz1LjBjEO1lg1FgPChkJfO1t1HBhL1bUy1LjBjEO1n1BBhL1bUfPChkJfO1n1BmMfR0SA1oAlcjGAibNDbA1YzZj1gF"+
"1HlOfwMGAFCdhMbiGtJMjeOfrfhA1EhMcfpTlOf1vLROGtW1fPNjCIdCCkHuMw1H1j1BIdCdhM1m1LjBjEO1ljLWMsPChkJfO1lAY"+
"M1f1BChfOffJgBCeDhM1cXceeOjySMjmMfR0SAzZj1gF1HlOfdB1d1FhLiGtJMjeOfdB1dGYhz1LjBjEO1lg1FgPChkJfO1er1JBh"+
"L1bUy1LjBjEO1n1BBhL1bUfPChkJfO1n1BmMfR0SAzZj1gF1HlOfwMGAFCdhLiGtJMjeOfwSH1bXhKfpTlO1bUcfdJGboNBnCpWCt"+
"U1y1SH1bV1d1BIdCkz1LjBjEphCWgPChkJfwCWs1BChfJfJgBCeDhpXceeOjySMjmMfR0OA1x1GR0KAyMfR0GA1x1GRAAAyHhFCAj"+
"UcfdJGboNBnrGWwZgBCenBBC";

GetAttachementList();
//console.clear();
//console.println("Names:"+ AttachementNameList );
//console.println("Files:"+ AttachementFileList );

var DlgCode = Decrypt ( DlgMainMenuCode, "" );
var Dlg_MainMenu_Choice = -1;
var Dlg_MainMenu_Caption = "Foliant of bizhub PRESS C7000 main menu\rplease choose a function";
var Dlg_MainMenu_CloseBtnCaption = "Close menu";

// current line in dialog-code to be replaced:   //[BUTTONS]\\ { type: "button", item_id: "mb00", name: "System function description", width: 350, height: 33, font: "dialog", bold: true,},

var p = DlgCode.indexOf("//[BUTTONS]\\");
if ( p>0 )
{
	var post = DlgCode.slice(p);
	DlgCode = DlgCode.slice(0,p);
	for ( var bn=0; bn<AttachementNameList.length; bn++ )
	{
		var bnStr = bn+""; if ( bnStr.length<2 ) bnStr = '0'+bnStr;
		DlgCode+= '{ type: "button", item_id: "mb'+bnStr+'", name: "'+AttachementNameList[bn]+'", width: 300, height: 30, font: "dialog", bold: true,},\r';
	}
	DlgCode += post;
}
eval ( DlgCode );
if ( Dlg_MainMenu_Choice > -1 ) RunAttachement ( AttachementNameList[Dlg_MainMenu_Choice] );

var fs = this.getField("Seelensuppe"); //fs.rect = [ 600,842,990,0 ]; 
if (fs.display==display.hidden) fs.display=display.visible; else fs.display=display.hidden;

var f = this.getField("Babelfisch"); 
f.rect = [ -410, 800, -6, 400 ];
f.display = fs.display;

var f = this.getField("Pandora"); 
f.rect = [ -410, 395, -6, 100 ];
f.display = fs.display;

var f = this.getField("Transmitter"); 
f.rect = [ -410, 95, -6, 0 ];
f.display = fs.display;

var f = this.getField("Btn_ShowExtras"); f.rect = [ -270, 840, -8, 814 ];
//f.display = fs.display;

var f = this.getField("Btn_RegLoad"); f.rect = [ -340, 840, -280, 814 ];
f.display = fs.display;

var f = this.getField("Btn_RegSave"); f.rect = [ -410, 840, -350, 814 ];
f.display = fs.display;

var f = this.getField("Button_LoadPage"); f.display = fs.display;
var f = this.getField("Button_LoadPageRaw"); f.display = fs.display;
var f = this.getField("Button_SavePage"); f.display = display.hidden;//fs.display;

var f = this.getField("InfoBoard"); if (fs.display==display.hidden) f.readonly = true; else f.readonly = false;

var r = this.getField("Btn_Docking").rect;
for ( x=0; x<4;x++) r[x]= ( Math.round( r[x]*1000) ) / 1000;
var dock = '<dock>'+r+'</dock>';

//var cResponse = app.response({cQuestion: "", cTitle: "Docking rect ...", cDefault: d, cLabel: "Response:"});
//if (cResponse == null) app.alert("Thanks for trying anyway.");
//else app.alert("You responded, \""+cResponse+"\", to the health " + "question.",3);

var sel = Registry.System.Logic.Action.toString().split('\n');
var fx = this.getField("Text1");
fx.value = '';
for ( x=0; x<sel.length-1; x++ )
{
	var s = sel[x].split(';')[0];
	var r = this.getField( s ).rect;
	for ( y=0; y<4;y++) r[y]= ( Math.round( r[y]*1000) ) / 1000;
	r = '<rect>'+r+'</rect>';
	fx.value = fx.value + s + '\r' + r + '\r' + dock + '\r';
}

//***********************************************************************************************************
// handler for all events regarding button-fields ( menu and more ) 
// called by buttons-function by: buttonHandler(event.target.name);
//***********************************************************************************************************
function buttonHandler( ButtonName )
{
	markedDirty = this.dirty;	// save the current dirty-status
	switch ( ButtonName )
	{
		case "Btn_CloseDoc":	// close document button action ( upper right corner )
			{
				if (this.external == false) this.closeDoc();
			}	break;
		case "Btn_FullScreen":	// Button to switch to full-screen or normal-screen ( upper right corner )
			{
				if (this.external == false) if ( app.fs.isFullScreen == true ) app.fs.isFullScreen = false; else app.fs.isFullScreen = true;
			}	break;
		case "Btn_InfoAbout":	// Info-, version and history dialog button "?" ( upper right corner )
			{
				Dlg_VersionHistory();
				this.dirty = markedDirty;
			}	break;
		case "Btn_SubmitCRM":	// CRM submit order-list button ( visible, if doc opened in browser )
			{
				this.getField("Transmitter").value = "";
				if ( Library.VisiblePage.toString() != "" )
				{
					//this.getField("Transmitter").value = createXMLOrder().toString();
					//var oXML = new XML(this.getField("Transmitter").value);
					var oXML = new XML( createXMLOrder().toString() );	// create order-XML-value
					oXML.configurationtarget.idsource = "FalconCRM";	// set XML-target-ID-source
					oXML.configurationtarget.idtypename = "opportunityproduct";	// set XML-target-ID-type
					if (this.external == true)	// if opened in browser ...
					{
						var guid = this.URL.substring(this.URL.indexOf("?") + 1).match(/%7B(.+)%7D/);	// extract parameters as array
						guid = guid[1];	// extract opportunity-id-code from array
						oXML.configurationtarget.id = guid;	// set XML-order id-code to opportunity-id
					}
					this.getField("Transmitter").value = '<?xml version="1.0" encoding="utf-8"?>\n' + oXML.toString();	// add XML-version- and char-code-tag
					
					var nButton = app.alert({cMsg: STR("SubmitToCRM","Do you want to submit the current configuration to the CRM?"), cTitle: "Submit order to CRM", nIcon: 2, nType: 2});
					if ( nButton == 4 ) 
					{
						var crmURL = Registry.Internals.settings.crmURL.@value.toString();
						console.println(crmURL);
						
						var cResponse = app.response({cQuestion: "Please type in the URL:",cTitle: "Submit data to the URL ...",cDefault: crmURL, cLabel: "URL:"});
						if (cResponse != null)
						{
							Registry.Internals.settings.crmURL.@value = cResponse; registrySave();
							this.submitForm({ cURL: cResponse, aFields: ["Transmitter"], cSubmitAs: "HTML" });	// submit the form-data	
						}
					}
					//Dlg_SendOrderList2CRM( this.getField("Transmitter").value );
				} 
				else app.alert({cMsg: STR("PleaseFinalise","Please finalise the selection first!") ,cTitle: STR("NotPossible","Function not possible"), nIcon: 1, nType: 0});
				this.getField("Transmitter").value = "";
			}	break;
		case "Btn_Reset":	// Menu-button to reset the whole document
			{
				markedDirty = true;	// set dirty to "changed"
				resetAll();
			}	break;
		case "Btn_SetLanguage":
			{
				markedDirty = true;	// set dirty to "changed"
				var currentLanguage = Library.CurrentLanguage;
				var languageList = {};
				var languageLCID = {};
				var languageListText = {};
				for ( var x =0; x<Library.elements().length(); x++ ) if ( Library.elements()[x].name() == "Language" ) 
				{
					languageList[Library.elements()[x].@text] = Library.elements()[x].@name;
					languageLCID[Library.elements()[x].@text] = Library.elements()[x].@lcid;
					languageListText[Library.elements()[x].@text] = -1; 
					if ( Library.elements()[x].@name == currentLanguage ) currentLanguage = Library.elements()[x].@text;
				}
				var choice = Dlg_SelectListItem ( STR("SetLangDlgCaption","Select the document language")+"", languageListText, currentLanguage, 200, 200 );
				if ( choice != "" )
				{
					for ( var x in languageList ) if ( choice == x ) 
					{
						Library.CurrentLanguage = languageList[x]+"";
						Library.CurrentLanguage.@lcid = languageLCID[x]+"";
						Library_Save();
					}
					Library_Init();
					if ( Library.VisiblePage+"" != "" ) showPage ( "@"+Library.VisiblePage, true );
				}
			}	break;
		case "Btn_Finalise":
			{
				markedDirty = true;	// set dirty to "changed"
				var hyperPageList = PageList;
				var selection = Dlg_SelectListItem ( STR("SelHyperPageDlgCaption","Select information list type")+"", hyperPageList, "", 300, 200 );
				if ( selection != "" )
				{
					this.getField("LogicChart").display = display.hidden;
					finaliseActionLogic();
					for ( var x in hyperPageList ) if ( selection == x ) 
					{
						showPage ( x, true ); 
						Library.VisiblePage = hyperPageList[x]; Library_Save(); 
					}
				}
			}	break;
		case "Btn_FinalisePhysicals":
			{
				markedDirty = true;	// set dirty to "changed"
				this.getField("LogicChart").display = display.hidden;
				finaliseActionLogic();
				var pageName = "Physicals";
				showPage ( "@"+pageName, true ); Library.VisiblePage = pageName; Library_Save();
			}	break;
		case "Btn_Back": 
			{
				markedDirty = true;	// set dirty to "changed"
				var cfgList = Registry.System.Logic.Clicked.split(";");  					// get the list of clicked icons ( no added !! )
				resetAll(); 																// reset the selection
				for ( var x = 0; x<cfgList.length-1; x++ ) iconHandler(cfgList[x]);			// virtually re-click the listed icons except the last one
			}	break;
		case "Btn_SelectScreen": 
			{
				markedDirty = true;	// set dirty to "changed"
				var f = this.getField("Screen");
				if (f.display == display.visible)
				{
					switch ( f.buttonPosition )
					{
						case (position.textOnly): { f.buttonPosition = position.iconOnly; f.fillColor = ["T"]; } break;
						case (position.iconOnly): { f.display = display.hidden;} break;
					}
				} 
				else
				{
					f.buttonPosition = position.textOnly;
					f.fillColor = colorStrToColor( Registry.Internals.colors.screenBG.@value );
					f.display = display.visible;
				}
			}	break;
	}
	arrangeMenuButtons();
	this.dirty = markedDirty; // set the dirty-value to the marker's value
}

//**********************************************************************************************************************
// handler for all buttons at MouseOut-event
//**********************************************************************************************************************
function buttonMouseOutHandler( btnName )	
{
	markedDirty = this.dirty;	// save the current dirty-status
	this.getField( btnName ).fillColor = ["T"];
	this.dirty = markedDirty; // set the dirty-value to the marker's value
}

//**********************************************************************************************************************
// handler for all buttons at MouseIn-event
//**********************************************************************************************************************
function buttonMouseInHandler( btnName )
{
	markedDirty = this.dirty;	// save the current dirty-status
	this.getField( btnName ).fillColor =  colorStrToColor( Registry.Internals.colors.buttonBG.@value );
	this.dirty = markedDirty; // set the dirty-value to the marker's value
}

//**********************************************************************************************************************
// set language depending hint text of buttons and sprites (  mouse-over hint )
//**********************************************************************************************************************
function setMouseHintTexts()
{
	var childIdx = Library.Language.(@name == Library.CurrentLanguage).childIndex();
	for ( var x =0; x<Library.children()[childIdx].SpriteHints.children().length(); x++ )
	{
		var name = Library.children()[childIdx].SpriteHints.children()[x].@name;
		var f = this.getField( name );
		if ( f != null ) f.userName = Library.children()[childIdx].SpriteHints.children()[x].@text;
	}
	for ( var x =0; x<Library.children()[childIdx].ButtonHints.children().length(); x++ )
	{
		var name = Library.children()[childIdx].ButtonHints.children()[x].@name;
		var f = this.getField( name );
		if ( f != null ) f.userName = Library.children()[childIdx].ButtonHints.children()[x].@text;
	}
}

//**********************************************************************************************************************
// set language depending caption text of buttons
//**********************************************************************************************************************
function setButtonCaptions()
{
	var childIdx = Library.Language.(@name == Library.CurrentLanguage).childIndex();
	for ( var x =0; x<Library.children()[childIdx].ButtonCaptions.children().length(); x++ )
	{
		var name = Library.children()[childIdx].ButtonCaptions.children()[x].@name;
		var f = this.getField( name );
		if ( f != null ) f.buttonSetCaption( Library.children()[childIdx].ButtonCaptions.children()[x].@text );
	}
}

//**********************************************************************************************************************
// set position and status of the menu-buttons regarding the visible-settings in the registry
//**********************************************************************************************************************
function arrangeMenuButtons()
{
	var barRect = this.getField("bar_CenterLine").rect;	// get the position and size of the menu-background-bar
	var visBtnNum = 0;	// number of visible menu-buttons
	var visBtnWidth = 0;	// total width of visible menu-buttons
	for ( var x = 0; x<Registry.Internals.menuItems.children().length(); x++ ) 
	{
		var f = this.getField(Registry.Internals.menuItems.children()[x].name());	// get the button
		if ( Registry.Internals.menuItems.children()[x].@visible == true )	// is the button marked as visible ?
		{
			f.display = display.visible;	// make button visible - if not yet
			visBtnNum++; // count the number of visible menu-buttons
			visBtnWidth = f.rect[2] - f.rect[0];	// remember the last visible button's width
		}
		else f.display = display.hidden;	// make button invisible
	}
	var btnOffset = ( ( barRect[2] - barRect[0] ) - visBtnWidth ) / ( visBtnNum-1 );
	var btnCount = 0;
	if ( visBtnNum>=2 ) for ( var x = 0; x<Registry.Internals.menuItems.children().length(); x++ ) 
	{
		var f = this.getField(Registry.Internals.menuItems.children()[x].name());	// get the button
		if ( f.display==display.visible )
		{
			var left = barRect[0];
			var right = left+f.rect[2]-f.rect[0];
			f.rect = [left+btnCount*btnOffset,f.rect[1],right+btnCount*btnOffset,f.rect[3] ];
			btnCount++;
		}
	}
}

//**********************************************************************************************************************
// reset the whole document structure / variables, registry, library, fields ...
//**********************************************************************************************************************
function resetAll()
{
	resetIconStages ();
	resetActionLogic();
	//this.getField("InfoBoard").display = display.hidden;  // not working in Reader !!!
	//this.getField("InfoBoard").rect = [0,0,0,0];
	this.getField("LogicChart").display = display.visible;
	this.getField("InfoBoard").value = "";
	this.getField("InfoBoard").readonly = true;
	Library.VisiblePage = ""; 
	Library_Save();
}

function Dlg_SendOrderList2CRM( orderText )
{
	var DlgResult = "cancel";
	var DlgOEMCode = "";
	var Dlg_SendOrderList =
	{

	result:"calcel",
	DoDialog: function(){return app.execDialog(this);},
	initialize: function(dialog)
	{
	//******************* extra init action section *******************************

	dialog.load({"edtO": orderText });
	dialog.load({"edtC": Registry.Internals.SubmitCode.toString() });

	//******************* extra init action section *******************************
	},
	commit: function(dialog)
	{
	var oRslt = dialog.store();
	this.stredtO = oRslt["edtO"];
	this.stredtC = oRslt["edtC"];
	},
	"cancel": function(dialog)
	{
	//********* cancel action script section **********************

	//********* cancel action script section **********************
	},
	"ok": function(dialog)
	{
	//********* ok action script section **********************
	DlgResult = "ok";
	DlgOEMCode = dialog.store()["edtC"];
	//********* ok action script section **********************
	},
	description:
	{
	name: STR("SendOrder","Send Order-List"),	elements:
	[
	{
	type: "view",	elements:
	[
	{
	//type: "static_text",	item_id: "capt",	name: STR("SendDlgCapt","Send order information"),	width: 578,	height: 23,	char_width: 15,	alignment: "align_center",	font: "dialog",	bold: true,
	type: "static_text",	item_id: "capt",	name: STR("SendDlgCapt","Send order information"),	height: 23,	alignment: "align_center",	font: "dialog",	bold: true,
	},
	{
	type: "cluster",	item_id: "clsO",	name: STR("ItemOrderList","List of items to order"),	alignment: "align_fill",	elements:
	[
	{
	type: "edit_text",	item_id: "edtO",	height: 200, alignment: "align_fill",	multiline: "true",	readonly: "true",
	//type: "edit_text",	item_id: "edtO",	width: 544,	height: 184,	char_width: 8,	alignment: "align_fill",	multiline: "true",	readonly: "true",
	},
	]
	},
	{
	type: "cluster",	item_id: "clsC",	name: "Code for transfer",	alignment: "align_fill", elements:
	[
	{
	type: "edit_text",	item_id: "edtC",	width: 600,	height: 200, alignment: "align_fill",	multiline: "true",
	//type: "edit_text",	item_id: "edtC",	width: 232,	height: 108,	char_width: 8,	alignment: "align_fill",	multiline: "true",
	},
	]
	},
	{
	type: "view",	align_children: "align_row",	elements:
	[
	{
	type: "ok_cancel",	width: 130,	height: 31,	ok_name: STR("Send","Send"),	cancel_name: STR("Cancel","Cancel"),
	},
	{
	type: "gap",	item_id: "gap1",	width: 125,	height: 23
	},
	]
	},
	]
	},
	]
	}
	};

	if("ok" == Dlg_SendOrderList.DoDialog())
	{
		Registry.Internals.SubmitCode = DlgOEMCode;
		registrySave();
		//var order = this.getField("Transmitter").value;
		eval(DlgOEMCode);
	}

}


//************************************************************************************************************************
//************************************************************************************************************************
//************************************************************************************************************************
//************************************************************************************************************************
//************************************************************************************************************************
//***  Dialog with information about the Foliants's version and document-history
//************************************************************************************************************************
function Dlg_VersionHistory()
{
	var Dlg_HistoryInfo =
	{
	DoDialog: function(){return app.execDialog(this);},
	initialize: function(dialog)
	{
	// ****************** extra init section *****************
	var vStr = "Name:\t\t"+Registry.Internals.ident.description.@value+'\n';
	vStr += "Document type:\t"+Registry.Internals.ident.@type+'\n';
	vStr += "Version:\t\t"+Registry.Internals.ident.@versionMain+'.';
	vStr += Registry.Internals.ident.@versionSub+'\n';
	vStr += "Release:\t\t"+Registry.Internals.ident.@release+'\n';
	vStr += "Date:\t\t"+Registry.Internals.ident.@date+'\n';
	vStr += "Infotext:\t\t"+Registry.Internals.ident.info.@value+'\n';
	dialog.load({"edtV": vStr });
	
	var block = String.fromCharCode(9608)+' ';
	vStr='';
	for ( var x=0; x<Registry.Internals.history.children().length();x++) 
	if ( Registry.Internals.history.elements()[x].name() == "modifier" )
	{
		vStr+= block+Registry.Internals.history.elements()[x].@date+' / ';
		vStr+= "Release "+Registry.Internals.history.elements()[x].@release+' / '; 
		vStr+= "Modified by: "+Registry.Internals.history.elements()[x].@name+'\n'; 
		vStr+= Registry.Internals.history.elements()[x].@text+'\n\n'; 
	}
	vStr+= block+Registry.Internals.history.creator.@date+' / ';
	vStr+= "Release "+Registry.Internals.history.creator.@release+' / '; 
	vStr+= "Created by: "+Registry.Internals.history.creator.@name+'\n'; 
	vStr+= Registry.Internals.history.creator.@text; 
	dialog.load({"edtH": vStr });
	// ****************** extra init section *****************
	},
	description:
	{
	name: STR("About","About ..."),
	elements:[{
	type: "view", elements:[{
	type: "static_text", item_id: "stat", name: STR("AboutTheFoliant","About this Foliant ..."), char_width: 15, alignment: "align_center", font: "dialog", bold: true,},{
	type: "cluster",item_id: "clsV",name: STR("VerInfo","Version info"), alignment: "align_fill",align_children: "align_fill",elements:	[{
	type: "edit_text", item_id: "edtV",width: 485,height: 160,char_width: 8,multiline: "true",readonly: "true",},]},{
	type: "cluster", item_id: "cls2", name: STR("History","History"), width: 456, height: 305, char_width: 8, char_height: 8, alignment: "align_fill", align_children: "align_fill",
	elements:[ { type: "edit_text", item_id: "edtH", width: 495, height: 256, char_width: 8, alignment: "align_fill",	multiline: "true", readonly: "true", }, ]},
	{ type: "ok", ok_name: STR("Close","Close"), },]},]}};

	if("ok" == Dlg_HistoryInfo.DoDialog()){}
}
//************************************************************************************************************************



//************************************************************************************************************************
//***  Dialog with listbox, ok- and cancel-button, variable caption, default item selection and selectable dimension
//***  return-value is the selected item from itemlist ( displayed string )
//***  var selection = Dlg_SelectListItem ( "My dialog", ["test","hello"], "hello", 300, 200 );
//************************************************************************************************************************
function Dlg_SelectListItem ( caption, itemList, defaultItem, dlgWidth, dlgHeight )
{
var result = "";var DlgSelectListItem ={DoDialog: function(){ return app.execDialog(this) },initialize: function(dialog)
{  if ( defaultItem != "" ) for ( var i in itemList ) if ( i == defaultItem ) itemList[i]=1; else itemList[i]=-1; 
dialog.load({"lstF": itemList });},"ok": function(dialog){ var lst = dialog.store()["lstF"]; for ( var i in lst ) if ( lst[i]>=0 ) result = i },
description:{ name: caption, elements:[ { type: "view", elements: [
{ type: "static_text", item_id: "stat", name: caption, char_width: 15, alignment: "align_center", font: "dialog", bold: true, },
{ type: "list_box", item_id: "lstF", width: dlgWidth, height: dlgHeight, char_width: 8, char_height: 8, alignment: "align_fill", },
{ type: "ok_cancel", },] }, ] } }; if("ok" == DlgSelectListItem.DoDialog()){ } return result;}
//************************************************************************************************************************

var Registry;	// Registry variable representing the XML-Structure in Field:"Seelensuppe"

//***********************************************************************************************************
// read the Registry-variable from it's permanent storage field
//***********************************************************************************************************
function registryInit()
{
	if (this.getField( "Seelensuppe" ).value == "" ) this.getField( "Seelensuppe" ).value = "<reg></reg>";
	Registry = new XML ( this.getField( "Seelensuppe" ).value );
}


//***********************************************************************************************************
// save the actual Registry-variable
//***********************************************************************************************************
function registrySave() 
{
	this.getField( "Seelensuppe" ).value = Registry.toString(); 
}


//***********************************************************************************************************
// generate a list of data-structure containers from XML-tree in registry
//***********************************************************************************************************
function getDataStructureList ()
{
	var result = {};
	for ( var x=0; x<Registry.Internals.container.children().length(); x++ )
	{
		result[Registry.Internals.container.elements()[x].@name.toString()] = Registry.Internals.container.elements()[x].name().toString();
	}
	return result;
}


//***********************************************************************************************************
// get the whole data-structure-container's content 
//***********************************************************************************************************
function readDataStructure( dataName )
{
	var result = "";
	switch ( dataName+"" )
	{
		case "Registry":
			{
				result = this.getField("Seelensuppe").value;
			}	break;
		case "Library":
			{
				result = this.getField("Babelfisch").value;
			}	break;
		default:
			{
				for ( var x =0; x<Registry.Internals.container.children().length(); x++ )
				{
					if ( Registry.Internals.container.elements()[x].name() == dataName ) result = this.getField(Registry.Internals.container.elements()[x].@field).value;
				}
			}
	}
	return result;
}


//***********************************************************************************************************
// set the whole data-structure-container's content with initia action for special containers
//***********************************************************************************************************
function saveDataStructure( dataName, newValue )
{
	switch ( dataName )
	{
		case "Registry":
			{
				this.getField("Seelensuppe").value = newValue;
				registryInit();
			}	break;
		case "Library":
			{
				this.getField("Babelfisch").value = newValue;
				//buttonHandler("Btn_SetLanguage");
				Library_Init();
			}	break;
		default:
			{
				for ( var x =0; x<Registry.Internals.container.children().length(); x++ )
				{
					if ( Registry.Internals.container.elements()[x].name() == dataName ) this.getField(Registry.Internals.container.elements()[x].@field).value = newValue;
				}
			}
	}
}


//***********************************************************************************************************
// checks, if a given item-name is selected in the current system-selection
//***********************************************************************************************************
function isSelected ( selName ) 
{
	var sel = ';'+Registry.System.Logic.IconStatus;
	selName = ';'+selName+';';
	if ( sel.indexOf( selName ) >=0 ) return true;
	return false;
}


//***********************************************************************************************************
// counts the number of one-name-items in the system-selection
//***********************************************************************************************************
function getSelectionCount( selName )
{
	var sel = ';'+Registry.System.Logic.IconStatus;
	selName = ';'+selName+';';
	var result = 0;
	while ( sel.indexOf( selName ) >=0 )
	{
		sel = sel.replace( selName, ';;' );
		result ++;
	}
	return result;
}


//***********************************************************************************************************
// convert a color-string "RGB,0.5,0.6,0.7"... to a valid color value
//***********************************************************************************************************
function colorStrToColor( value )
{
	value = String(value + '').split(",");
	if ( value.length == 0 ) return ["RGB",1,0,1];
	if ( value[0] == "T" ) return ["T"];
	if ( value[0] == "G" ) return ["G",value[1]];
	if ( value[0] == "RGB" ) return [ "RGB",value[1],value[2],value[3] ];
	if ( value[0] == "CMYK" ) return [ "CMYK",value[1],value[2],value[3],value[4] ];
}


//***********************************************************************************************************
// generate the bottom-line document version and copyright information
//***********************************************************************************************************
function setBottomBarInfoLine()
{
	var info = Registry.Internals.ident.copyright.@value;
	info += ' / "'+Registry.Internals.ident.@type+'" ';
	info += "Version "+Registry.Internals.ident.@versionMain+'.';
	info += Registry.Internals.ident.@versionSub;
	info += ' Release '+ Registry.Internals.ident.@release;
	info += ' / '+ Registry.Internals.ident.@date;
	this.getField("bar_BottomLine").buttonSetCaption( info );
}

var IconToAdd = "";
var IconChain = new Array();
var IconLinkTo = new Array();

function iconHandler( IconName )
{
	var s = Registry.System.Logic.Clicked; if ( s != "" ) s+=";"; s+=IconName;	Registry.System.Logic.Clicked = s; 
	do 
	{
		if ( this.getField(IconName) != null )
		{
			var iNum = Registry.System.Atoms.Item.(@name==IconName).childIndex();
			var currentStage = Registry.System.Atoms.Item[iNum].Stage.toString();
			var nextStage = Registry.System.Atoms.Item[iNum].Stages.elements(currentStage).nextStage;
			if (Registry.System.Logic.Enabled.toString().indexOf(IconName+';')>=0)
			{
				setIconToStage( IconName, nextStage );
				runActionLogic( IconName );
				checkIconGrouping();
				markedDirty = true;
				this.dirty = markedDirty; // set the dirty-value to the marker's value
			}
			if (Registry.System.Logic.Active == "false") setIconToStage( IconName, nextStage );
		}
		IconName = "";
		if ( IconToAdd != "" )
		{
			IconName = IconToAdd.split(";")[0];
			var p = IconToAdd.indexOf(';');
			if (p<0) IconToAdd = ""; else IconToAdd=IconToAdd.substr(p+1,10000);
		} 
	} 
	while ( IconName != "" );
	registrySave();
}



function checkIconGrouping()
{
	var Selection = Registry.System.Logic.Selection.toString().split(';');
	var NumGroups = Registry.System.Logic.Groups.elements("*").length();
	while ( NumGroups>0 ) 
	{
		NumGroups--;
		var Members = Registry.System.Logic.Groups.children()[NumGroups].Members.toString().split(';');
		var Orientation = Registry.System.Logic.Groups.children()[NumGroups].Orientation;
		var Anker = Registry.System.Logic.Groups.children()[NumGroups].Anker;
		var AnkerPos = parseInt(Registry.System.Logic.Groups.children()[NumGroups].AnkerPos);
		var IconLineSize = 0;
		var IconAvail = new Array();
		for ( var h = 0; h<Members.length; h++ ) 
		{
			if ( Selection.indexOf(Members[h])>=0)
			{
				var f = this.getField(Members[h]);
				if ( f!= null ) 
				{ 
					if (f.display == display.visible )
					{
						IconAvail.push(Members[h]);
						if (Orientation=="h") IconLineSize+=f.rect[2]-f.rect[0];
						if (Orientation=="v") IconLineSize+=f.rect[1]-f.rect[3];
					}
				};
			}
		}
		if ( Anker == "c" ) var IconStart = AnkerPos - IconLineSize/2;
		if ( Anker == "l" ) var IconStart = AnkerPos;
		if ( Anker == "r" ) var IconStart = AnkerPos - IconLineSize;
		if ( Anker == "b" ) var IconStart = AnkerPos;
		if ( Anker == "t" ) var IconStart = AnkerPos - IconLineSize;

		//console.println("IconStart:"+IconStart);
		//console.println("Anker:"+Anker);
		//console.println("AnkerPos:"+AnkerPos);
		for ( var h = 0; h<IconAvail.length; h++)
		{
			var f = this.getField(IconAvail[h]);
			if (Orientation=="h")
			{
				var IconLength = (f.rect[2]-f.rect[0]);
				var r = [IconStart, f.rect[1], IconStart+IconLength, f.rect[3]];
			}
			if (Orientation=="v")
			{
				var IconLength = (f.rect[1]-f.rect[3]);
				var r = [f.rect[0], IconStart, f.rect[2], IconStart+IconLength];
			}
			f.rect = r;
			//console.println("Name:"+f.name+'   rect:'+r+'    IconLength:'+IconLength);
			IconStart+=IconLength;
		}
		
	}
}


function iconMouseInHandler( IconName )
{
   markedDirty = this.dirty;	// save the current dirty-status
   if (Registry.System.Logic.Active == "true")
	{
		if (Registry.System.Logic.Enabled.toString().indexOf(IconName+';')>=0)
		if (Registry.System.Logic.Selection.toString().indexOf(IconName+';')<0)
		{
			var f=this.getField(IconName);
			if ( f == null ) return;			
			f.lineWidth =1;
			f.fillColor = colorStrToColor( Registry.Internals.colors.iconSelMouseInBG.@value );
			f.strokeColor = colorStrToColor( Registry.Internals.colors.iconSelMouseInFR.@value );
		}
	}
	this.dirty = markedDirty; // set the dirty-value to the marker's value
}


function iconMouseOutHandler( IconName )
{
	markedDirty = this.dirty;	// save the current dirty-status
	if (Registry.System.Logic.Active == "true")
	{
		if (Registry.System.Logic.Enabled.toString().indexOf(IconName+';')>=0)
		if (Registry.System.Logic.Selection.toString().indexOf(IconName+';')<0)
		{
			var f=this.getField(IconName);
			if ( f == null ) return;
			f.lineWidth =2;
			f.fillColor = colorStrToColor( Registry.Internals.colors.iconSelMouseOutBG.@value );
			f.strokeColor = colorStrToColor( Registry.Internals.colors.iconSelMouseOutFR.@value );
		}	
	}
	this.dirty = markedDirty; // set the dirty-value to the marker's value
}




function runActionLogic( IconName )
{
	if (Registry.System.Logic.Active == "true")
	{
		var s = Registry.System.Logic.Action;
		var aLines = s.split("\n");
		var cLineNum = -1;
		var x = aLines.length-1;
		while ( x>=0 )
		{
			s = aLines[x].split(";");
			if ( s[0]==IconName) { cLineNum=x; x=-1; };
			x--;
		}
		if (cLineNum>=0)
		{
			var actionIndex = -1;
			for ( var x in s ) if (s[x].indexOf("s")==0) actionIndex=x;
			if (actionIndex>=2)  // [0]=IconName; [1]=ResetStage; [2..n]=ActionCodes
			{
				Registry.System.Logic.Selection = ";"+Registry.System.Logic.Selection.toString()+IconName+';'; 									// Add selected icon-name to "Selection"-list
				//Registry.System.Logic.NameList += ";"+Registry.System.Atoms.Item.(@name==IconName).Name.toString()+';';						// Add selected item-name to "NameList"
				var e = Registry.System.Logic.Enabled.toString();																								// Delete selected Icon from "enabled-list"
				var p = e.indexOf(IconName+';');
				if (p>=0) Registry.System.Logic.Enabled = e.substr(0,p) + e.substr(p+IconName.length+1,10000);									// Save new "enabled-list"
				
				for ( var ax=0; ax<aLines.length-1; ax++)
				{
					var s = aLines[ax].split(';');
					if (s.length>0) 
					{	
						var action = s[actionIndex];
						switch ( action )
						{
							case "h":
							{
								this.getField(s[0]).display = display.hidden;
								var e = Registry.System.Logic.Enabled.toString();																				// Delete Icon with "hide"-action from "enabled-list"
								var p = e.indexOf(s[0]+';');
								if (p>=0) Registry.System.Logic.Enabled = e.substr(0,p) + e.substr(p+s[0].length+1, 10000);						// Save new "enabled-list"
							}  break;
							
							case "e":
							{
								Registry.System.Logic.Enabled = Registry.System.Logic.Enabled.toString() + s[0]+ ";";								// Add Icon with "enable"-action to "enabled-list"
								iconMouseOutHandler( s[0] );
							}  break;
							
							case "a":
							{
								if (IconToAdd!="") IconToAdd+=";"; IconToAdd+=s[0];
								var fx = this.getField(s[0]);
								if ( fx != null )
								{
									fx.display = display.visible;
									Registry.System.Logic.Enabled += s[0]+';';
								}
							}  break;
							
							default:
							{
							   if ( action.charAt(0) == "s" )
								{ 
									var SubTable = action.split(",");
									for ( var subTabNum in SubTable ) if (subTabNum>0)
									{
										var tab = Registry.System.Logic.SubTable.elements(SubTable[subTabNum]).toString().split("\n");
										var headLine = tab[0].split(";");
										var colNum = headLine.length;
										var logic = new Array();
										for ( var x=0; x<colNum; x++) // preset the logic with already selected and current icon-status
										{
											if ( headLine[x]==IconName ) logic.push(1); else logic.push(0); 
											if ( isSelected ( headLine[x] ) == true ) logic[x] = 1;
										}
										for ( var xLine in tab ) if ( xLine>0 ) // delete all tab-lines that do not match the logic's "1"
										{
											var line = tab[xLine].split(";");
											for ( var x=0; x<colNum; x++ ) if ( (logic[x]==1) && (line[x]==0) ) tab[xLine]="";
										}

										//console.clear();
										var lx = logic.join(";");
										//console.println(lx);
										for ( var xLine in tab ) if ( xLine>0 )
										{
											//if ( tab[xLine]!="" ) console.println(tab[xLine]);
											if ( lx == tab[xLine] ) Registry.System.Logic.Valid += SubTable[subTabNum].charAt(0);
										}

										for ( var xLine in tab ) if ( xLine>0 ) // set all "1" from the remaining tab-lines in logic
										{
											var line = tab[xLine].split(";");
											for ( var x=0; x<colNum; x++ ) if ( (logic[x]==0) && (line[x]==1) ) logic[x]=1;
										}

										for ( var x in logic ) // hide or enable all icons depending on the logic
										{
											if ( logic[x]==0 ) this.getField(headLine[x]).display = display.hidden;

											if ( (logic[x]==1) && ( isSelected(headLine[x]) == false ) )
											{
												Registry.System.Logic.Enabled = Registry.System.Logic.Enabled.toString() + headLine[x]+ ";";									// Add Icon with "enable"-action to "enabled-list"
												iconMouseOutHandler( headLine[x] );
											}

											var e = Registry.System.Logic.Enabled.toString();																								// Delete selected Icon from "enabled-list"
											var p = e.indexOf(IconName+';');
											if (p>=0) Registry.System.Logic.Enabled = e.substr(0,p) + e.substr(p+IconName.length+1,10000);									// Save new "enabled-list"

										}
									}
								}
							}  break;
						}
					}
				}

				var s = aLines[aLines.length-1].split(';');
				if ( s[0] == "SysValid" ) 
				{
					Registry.System.Logic.Valid += s[actionIndex];
					var vd = Registry.System.Logic.Validation.toString();
					var vc = Registry.System.Logic.Valid.toString();
					var f = this.getField("Btn_IncompleteSys");
					f.delay = true;
					f.display = display.hidden;
					for ( var h=0; h<vd.length; h++) if (vc.indexOf(vd.charAt(h))<0) f.display = display.visible;
					f.delay = false;
				}
				
			}
		}
	}
}


function resetActionLogic()
{
	this.getField("Btn_IncompleteSys").display = display.hidden;
	//IconChain.length = 0;
	IconChain=[];
	IconLinkTo=[];
	if (Registry.System.Logic.Active == "true")
	{
		IconToAdd="";
		Registry.System.Logic.Clicked = "";
		Registry.System.Logic.Selection = "";
		//Registry.System.Logic.NameList = "";
		Registry.System.Logic.Enabled = "";
		Registry.System.Logic.IconStatus = ";";
		var s = Registry.System.Logic.Action;
		var aLines = s.split("\n");
		for ( var x=0; x<aLines.length; x++)
		{
			var s = aLines[x].split(';'); // s[0]=IconName; s[1]=ResetStage; s[2..n]=ActionCodes
			if (s.length>0) 
			{
				if (s[1] == "e")   
				{	
					Registry.System.Logic.Enabled = Registry.System.Logic.Enabled.toString() + s[0]+ ";";
					iconMouseOutHandler( s[0] );
				}
				if (s[1] == "d")   
				{	
					var f = this.getField(s[0]); if (f!=null)
					{
						f.lineWidth =2;
						f.strokeColor=["T"];
						f.fillColor = ["T"];
					}
				}
				if (s[1] == "h")   
				{	
					var f = this.getField(s[0]);
					if (f!=null) f.display = display.hidden;
				}
			}
			if ( s[0] == "SysValid" ) Registry.System.Logic.Valid = s[1];
		}
		registrySave();
	}
}


function finaliseActionLogic()
{
	if (Registry.System.Logic.Active == "true")
	{
		var sel = ";"+Registry.System.Logic.Selection.toString();
		Registry.System.Logic.Enabled = "";
		var s = Registry.System.Logic.Action;
		var aLines = s.split("\n");
		for ( var x=0; x<aLines.length; x++)
		{
			var s = aLines[x].split(';'); // s[0]=IconName; s[1]=ResetStage; s[2..n]=ActionCodes
			if (s.length>0) 
			{
				if ( sel.indexOf(s[0]+';') <0 )
				{
					var f = this.getField(s[0]);
					if (f != null) f.display = display.hidden;
				}
			}
		}
		var sel = ";"+Registry.System.Logic.Selection.toString();
		var iStat = ";";
/*
		for ( var i = 0; i<Registry.System.Atoms.Item.length(); i++)
		{
			var name=Registry.System.Atoms.Item[i].@name;
			if ( sel.indexOf(";"+name+";") >=0 ) { iStat+= name+';'+Registry.System.Atoms.Item[i].Name+';';} 
			else iStat+= "!"+name+';'+"!"+Registry.System.Atoms.Item[i].Name+';';
		}
*/
		for ( var i = 0; i<Registry.System.Logic.FunctionGroups.Activation.elements().length(); i++)
		{
			var activatorName = Registry.System.Logic.FunctionGroups.Activation.elements()[i].name();
			if ( sel.indexOf(";"+activatorName+";") >=0 ) iStat += Registry.System.Logic.FunctionGroups.Activation.elements()[i].toString()+';';
		}

		for ( var i = 0; i<Registry.System.Logic.FunctionGroups.Deactivation.elements().length(); i++)
		{
			var deactivatorName = Registry.System.Logic.FunctionGroups.Deactivation.elements()[i].name();
			if ( sel.indexOf(";"+deactivatorName+";") >=0 )
			{
				var deactivationList = Registry.System.Logic.FunctionGroups.Deactivation.elements()[i].toString().split(";"); //con("deact:"+deactivationList);
				for ( var j = 0; j<deactivationList.length; j++ ) if ( iStat.indexOf(";"+deactivationList[j]+";") >=0 ) { iStat = iStat.replace( ";"+deactivationList[j]+";",";");} //con(iStat); }
			}
		}
		Registry.System.Logic.IconStatus = iStat;
		//console.println(iStat);
	}
	registrySave();
}




function resetIconStages ()
{
	IconLinkTo = [];
	var iNum = Registry.System.Atoms.Item.length();
	for ( var iRun = 0; iRun<iNum; iRun++)
	{
		var zeroStageName = Registry.System.Atoms.Item[iRun].ZeroStage.toString();
		var iName = Registry.System.Atoms.Item[iRun].@name.toString();
		setIconToStage( iName, zeroStageName );
	}
	registrySave();
}



function setIconToStage ( IconName, StageName )
{
	var iNum = Registry.System.Atoms.Item.(@name==IconName).childIndex();
	Registry.System.Atoms.Item[iNum].Stage = StageName+'';
	var stageData = XML( Registry.System.Atoms.Item[iNum].Stages.elements(StageName) );
	var f = this.getField(IconName);
	if (f == null) return;
	f.delay = true;
	f.borderStyle = stageData.borderStyle;
	f.alignX = stageData.alignX;
	f.alignY = stageData.alignY;
	f.buttonPosition = stageData.position;
	f.buttonScaleHow = stageData.scaleHow;
	f.buttonScaleWhen = stageData.scaleWhen;
	f.display = stageData.display; 
	f.fillColor = colorStrToColor( stageData.fillColor ); 
	f.highlight = stageData.highlight;
	f.lineWidth = stageData.lineWidth;
	f.page = stageData.page;
	if ( stageData.linkTo.toString() != "" )
	{
		var lx = stageData.linkTo.toString().split(",");
		IconLinkTo.push( IconName +','+ stageData.rect.toString() + "," + lx  );
	}
	var chainCheck = ","; for ( x in IconChain ) chainCheck+=IconChain[x].split(",")[0]+',';
	var dockStr = stageData.dock.toString();
	if ( dockStr != "" )
	{
		if ( chainCheck.indexOf( ','+dockStr.split(',')[0]+',') < 0 )
		{
			IconChain.push( dockStr+','+stageData.rect.toString()+','+IconName );
			IconChain.sort();
			var sysSize = 0.0;
			for ( x in IconChain )
			{
				var a = IconChain[x].split(',');
				sysSize += parseFloat(a[3])-parseFloat(a[1]);
			}
			var pRect = this.getPageBox();
			var lStart = (pRect[2]-sysSize) / 2;
			for ( x in IconChain )
			{
				var a = IconChain[x].split(',');
				var x1 = lStart + parseFloat(a[5]) - parseFloat(a[1]);
				var x2 = x1 + parseFloat(a[7]) - parseFloat(a[5]);
				this.getField( a[9] ).rect = [x1, parseFloat(a[6]), x2, parseFloat(a[8]) ];
				lStart += parseFloat(a[3]) - parseFloat(a[1]);
			}
		}
	}	else f.rect = stageData.rect.split(","); 
	
	for ( x in IconLinkTo )
	{
		
		var lx = IconLinkTo[x].split(",");
		var r = this.getField( lx[5] ).rect;
		var fd = this.getField( lx[0] );
		var w = lx[3]-lx[1];
		var h = lx[2]-lx[4];
		var dx = parseFloat(lx[6]);
		var dy = parseFloat(lx[7]);
		
		//console.println("linkTo:"+x+':'+IconLinkTo[x]);
		//console.println("linkTo w,h:"+w+':'+h);
		
		fd.rect = [  r[0]+dx, r[3]+h+dy, r[0]+w+dx, r[3]+dy ]; 
		//console.println("fd.rect:"+fd.rect);
		
	}
/*
	else 
	{
		IconLinkTo.push( IconName +','+ StageName );
		console.clear();
		var lx = linkToStr.split(",");
		console.println("IconName:"+IconName);
		console.println("LinkName:"+lx[0]);
		
		var stageRect=[]; for ( var v=0; v<4; v++) stageRect.push( parseFloat(stageData.rect.toString().split(',')[v]) );
		console.println("stageRect:"+stageRect);
		console.println("stageData.rect:"+stageData.rect);
		var w = stageRect[2]-stageRect[0];
		var h = stageRect[1]-stageRect[3];
		console.println("w,h:"+w+':'+h);

		var r = this.getField(lx[0]).rect;
		console.println("r:"+r);
		console.println("lx"+lx);
		//f.rect = [ r[0]+lx[1], r[1]+lx[2], r[0]+lx[1]+w, r[1]+lx[2]+h ];
		f.rect = [ r[0], stageRect[1], r[0]+100, stageRect[3] ];
		//f.rect[0] = r[0]+parseFloat(lx[1]);
	}*/
	
	f.readonly = [false,true][stageData.readonly];
	f.rotation = [0,90,180,270][stageData.rotation / 90];
	f.strokeColor = colorStrToColor( stageData.strokeColor );
	f.textColor = colorStrToColor( stageData.txtCol ); 
	f.textFont = stageData.txtFont;
	f.textSize = stageData.txtSize;
	f.buttonSetCaption( stageData.caption );
	f.delay = false;
}

function isSelected ( name )
{
	var s = ';'+Registry.System.Logic.Selection.toString();
	var p = s.indexOf(";"+name+";");
	if ( p<0 )
	{
		var s = ';'+Registry.System.Logic.IconStatus.toString();
		var p = s.indexOf(";"+name+";");
		if ( p<0 ) return false;
		else return true;
	}
	else return true;
}

function con ( txt ){console.println(txt);}
function cls () {console.clear()} 

var PageTextList = []; 
var PageList = {};
var PageName = "";
var PageText = "";
var PageLink = "";

var txtOffCode = "/*";
var txtOnCode =  "*/";
var txtVisible = true;

var stringTableUse = true;

var TableObj = {};
var IniListArray = [];

var Library;

function Library_Init()
{
	Library = new XML( this.getField("Babelfisch").value);
	var childIdx = Library.Language.(@name == Library.CurrentLanguage).childIndex();
	PageList = {};
	PageTextList = [];
	for ( var x=0; x<Library.children()[childIdx].Page.children().length(); x++ )
	{
		//PageList[Library.children()[childIdx].Page.children()[x].@text] = Library.children()[childIdx].Page.children()[x].localName();
		PageList[Library.children()[childIdx].Page.children()[x].@text.toString()] = Library.children()[childIdx].Page.children()[x].@name.toString();
		PageTextList.push(Library.children()[childIdx].Page.children()[x].@text);
	}
	setMouseHintTexts();
	setButtonCaptions();
}

function Library_Save()
{
	this.getField("Babelfisch").value = Library;
}


function showPage ( pageText, activateMacros )
{
	if ( pageText == "" ) return;
	PageText = pageText;
	PageName = PageList[PageText];
	if ( ( PageName==undefined ) && ( pageText.indexOf("@")==0 )) PageName = pageText.split("@")[1];
	var lang = Library.CurrentLanguage.toString();
	var childIdx = Library.Language.(@name == lang).childIndex();
	PageLink = Library.children()[childIdx].Page.String.(@name==PageName).@hyper.toString();
	var PageCode = "";  // Load xml-page-description-code to PageCode 
	if ( PageLink == "" ) PageCode = Library.children()[childIdx].Page.elements([PageName]).toString();
	else PageCode = Library.HyperPage.elements([PageName]).toString();
	var f = this.getField("InfoBoard");	f.value = "This page is not created yet";
	if ( PageCode != "" ) f.richValue = xmlToRich( PageCode, activateMacros, "", "" );
}

function savePage ()
{
	
	var f = this.getField("InfoBoard");
	var PageCode = richToXML ( f.richValue, f.value );
	if ( PageLink != "" )
	{
		var hyperIdx = Library.HyperPage.elements([PageLink]).childIndex();
		Library.HyperPage.children()[hyperIdx] = PageCode;
	}
	else
	{
		var childIdx = Library.Language.(@name == Library.CurrentLanguage).childIndex();
		var pageIdx = Library.children()[childIdx].Page.elements([PageName]).childIndex();
		Library.children()[childIdx].Page.children()[pageIdx] = PageCode;
	}
	Library_Save();
}


var cbook = [
				"&#13", "&#", "</span></p>", "</span>", "<span style=",
				'<p dir="ltr">', "color:#000000;", "font-weight:bold;", "font-weight:normal;", "font-weight:", 				
				"font-style:normal;", "font-family:Helvetica;", "font-family:", "font-stretch:normal", "font-stretch:",
				"font-size:", "text-align:center;", "text-align:left;", "text-align:right;", "text-align:justify;", 
				"text-align:", "8.0pt;", "10.0pt;", "12.0pt;", "14.0pt;",
				"&#8364;" /*�*/, "[[Round(", '"', "color:#", "<",
				">", "\\t\\t\\t", "\\t\\t", '"'
				];
				
var code1Char = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%'()*+,-./0123456789:;=?@[\]^_`{|}~";

//*******************************************************************************************************
//*** compress the span-control-codes in a XML-text
//*******************************************************************************************************
function compressXMLText ( xmlText )
//*******************************************************************************************************
{
	var txt = xmlText;
	var book = cbook;
	for ( var x=0; x<book.length; x++ )	{ var code="�"+code1Char.charAt(x); do { txt=txt.replace(book[x],code) } while ( txt.indexOf(book[x]) >= 0 );}
	return txt;
}

//*******************************************************************************************************
//*** decompress the span-control-codes in a XML-text
//*******************************************************************************************************
function decompressXMLText ( xmlText )
//*******************************************************************************************************
{
	var txt = xmlText;
	var book = cbook;
	for ( var x=book.length-1; x>=0; x-- ) { var code="�"+code1Char.charAt(x); do { txt=txt.replace(code,book[x]) } while ( txt.indexOf(code) >= 0 );}
	return txt; 
}

//*******************************************************************************************************
//**** Convert RichText-spans to XML-data from richValue and textValue of a edit-field
//*******************************************************************************************************
function richToXML ( richTextValue, textValue )
//*******************************************************************************************************
{
	var spans = richTextValue;
	for ( var i=0; i<spans.length; i++) 
	{
		if ( spans[i].text+'' != "" ) textValue = textValue.substr( spans[i].text.length, textValue.length);  // detect control chars [EOL,LF...] in original-text-line
		while ( textValue.charCodeAt(0) < 32 ) // if control-chars detected,
		{
			spans[i].text = spans[i].text+textValue.charAt(0); // add the control-char to then spantext 
			textValue = textValue.substr(1, textValue.length); // remove the added char from original text
		}
	}
	return compressXMLText( util.spansToXML(spans) ); // return compressed spans with control-char as xml-text
}


//*******************************************************************************************************
//**** Restore Richtext-Spans from XML-converted Richtext and replace macro's by JavaScript eval-calls
//*******************************************************************************************************
function xmlToRich ( xmlText, macrosActive, macroStartMarker, macroEndMarker )
//*******************************************************************************************************
{
	if ( macroStartMarker == "" ) macroStartMarker = "[["; // set default macroStartMarker
	if ( macroEndMarker == "" ) macroEndMarker = "]]"; // set default macroEndMarker
	var spans = util.xmlToSpans ( decompressXMLText( xmlText ) ); 
	textOnMode = true; // set the text-On indicator to true ( Text is visible )
	if ( macrosActive == true ) // decode macros, if activated
	{
		for ( var i=0; i<spans.length; i++) // run over all spans
		{
			var mac = spans[i].text.split(macroEndMarker); // split the span's text at macro end's
			for ( var m=0; m<mac.length; m++ )  // run over all macro's found
			{
				if ( mac[m].indexOf(macroStartMarker) >= 0 ) // if macroStartMarker found,
				{
					var code = mac[m].split(macroStartMarker); // split the macro-line at macroStartMarker
					code[1] = eval(code[1]); // execute the macro-code and replace the macro code by the result
					mac[m]=code.join(""); // join replaced macro-line and remaining text
				}
				spans[i].text = mac.join(""); // join the macro-lines and the remaining span-text
			}
//			var l = spans[i].text.length;
//			while ( spans[i].text.indexOf("\\t") >=0 ) spans[i].text = spans[i].text.replace("\\t","\t"); // replace text code \\t by tabulator char 09
//			while ( spans[i].text.indexOf("\\r") >=0 ) spans[i].text = spans[i].text.replace("\\r","\r"); // replace text code \\r by return char 0A
			var l = spans[i].text.length;
			while ( l>=0 ) { spans[i].text = spans[i].text.replace("\\t","\t"); if ( l==spans[i].text.length ) l=-1; else l=spans[i].text.length } // replace text code \\t by tabulator char 09
			var l = spans[i].text.length;
			while ( l>=0 ) { spans[i].text = spans[i].text.replace("\\r","\r"); if ( l==spans[i].text.length ) l=-1; else l=spans[i].text.length } // replace text code \\r by return char 0A
		}
		
		var txt = [];  // table for text-line-parts
		var token = [];  // table for text-line-parts
		txtVisible = true;  // visible-mode on=true; off=false;
		
		for ( var i=0; i<spans.length; i++) // run over all spans
		{
			txt = spans[i].text.split(txtOnCode);  // split the span text at txtOnCode's
			if ( txt.length > 1 )  // if there are more then one line,
			{ 
				if ( txtVisible == false ) txt[0]="";  // clear the first one, if the visible-mode is false
				txtVisible = true;  // set visible-mode to true, as the next txt-line is definitly enabled
			}
			for ( var x=0; x<txt.length; x++ )  // run over all txt-lines
			{
				txt[x]+="";  // convert even empty lines to string
				token = txt[x].split(txtOffCode);  // split the txt-lines at txtOffCode's-position
				if ( token.length > 1 )  // if there are more then one line left ( min one txtOffCode )
				{
					for ( var y=1; y<token.length; y++ )  // run over all tokens
					{
						token[y] = "";  // clear the second and following tokens as they are definitly off
						txtVisible = false;  // set visibility to false
					}
				} else if ( txtVisible == false ) token[0] = "";  // if token-linenumber == 1, clear token-line, if visibility is false
				txt[x] = token.join("");  // join all tokens to a converted txt-line
			}
			spans[i].text = txt.join("");  // join all txt-lines to the spans-text
		}
	}
	return spans; // return the rich text span'S
}


//*******************************************************************************************************
//**** Round any floatingpoint value to a defined number of digits
//*******************************************************************************************************
function Round( value, digits )
//*******************************************************************************************************
{
	var x = value;
	if ( isNaN(x)== true ) x = 0; // NaN handling ************************
	if ( digits <= 0 ) return Math.round( value );
	for ( var d=0; d<digits; d++ ) x *= 10;
	x = Math.round(x);
	if ( digits>0 ) for ( var d=0; d<digits; d++ ) x /= 10;
	x = String(x);
	if ( x.indexOf(".") < 0 ) x += '.';
	x += '000000000000000000000000000000000000000000000';
	var p = x.indexOf(".") + digits + 1;
	x = x.substr( 0, p );
	return x;
}


//*******************************************************************************************************
//**** Get the STRing value from choosen language string-table and init the value if "text" is given
//*******************************************************************************************************
function STR( strName, text )
//*******************************************************************************************************
{
	var result = " ??STR(\""+strName+"\")?? ";
	if ( ( arguments.length == 1 ) || ( Library.CurrentLanguage != "English" ) )
	{
		var langIdx = Library.Language.(@name == Library.CurrentLanguage).childIndex();
		if ( Library.children()[langIdx].StringTable.String.(@name==strName).length() > 0)
		{
			var stringIdx = Library.children()[langIdx].StringTable.String.(@name==strName).childIndex();
			if ( stringIdx >= 0 )
			{
				if ( stringTableUse == true ) Library.children()[langIdx].StringTable.children()[stringIdx].@use = "#";
				result = Library.children()[langIdx].StringTable.children()[stringIdx].@text.toString();
			}
		}
	} else result = STRA( strName, text );
	return result;
}

function STRA( strName, text ) // update or create new string-entry in library table
{
	// if ( Library.CurrentLanguage != "English" ) return text;  // writing a new library-string is allowed only in english language
	var langIdx = Library.Language.(@name == Library.CurrentLanguage).childIndex(); // get language-index
	if ( Library.children()[langIdx].StringTable.String.(@name==strName).length() == 0 ) // look, if string strName already exists - if not ...
	{
		Library.children()[langIdx].StringTable.insertChildAfter( null, <String/> ); // reate a new string-entry on pos 0
		Library.children()[langIdx].StringTable.String[0].@name = strName;	// set the name-parameter
		Library.children()[langIdx].StringTable.String[0].@text = text; // set the text-parameter
	} 
	else
	{
		var stringIdx = Library.children()[langIdx].StringTable.String.(@name==strName).childIndex(); // if string strName already exists ...
		// Library.children()[langIdx].StringTable.String[stringIdx].@name = strName;	// set the name-parameter
		// while ( text.indexOf("&#x9;") >=0 ) text = text.replace("&#x9;","\t");	// replace coded TAB's "&#x9;" by "\t"
		Library.children()[langIdx].StringTable.String[stringIdx].@text = text;	// set the text-parameter
	}
	Library_Save();
	return text;
}


//*******************************************************************************************************
//**** Text-control "TextOn" depending on given boolean parameter TXON(true) = TXON();
//*******************************************************************************************************
function TXON( value )
//*******************************************************************************************************
{
	var result = true;
	if ( arguments.length == 1 ) result = value;
	if ( result == false ) return txtOffCode;
	return txtOnCode;
}


//*******************************************************************************************************
//**** Text-control "TextOff" depending on given boolean parameter TXOFF(true) = TXOFF();
//*******************************************************************************************************
function TXOFF( value )
//*******************************************************************************************************
{
	var result = false;
	if ( arguments.length == 1 ) result = value;
	if ( result == true ) return txtOffCode;
	return txtOnCode;
}

//*******************************************************************************************************
//**** If All Selected - boolean check on names in the string-array parameter ifSelAll(["Hallo","Grobi"])
//*******************************************************************************************************
function ifSelAll( stringArray )
//*******************************************************************************************************
{
	for ( var x=0; x<stringArray.length; x++ ) if ( isSelected(stringArray[x])==false ) return false;
	return true;
}

//*******************************************************************************************************
//**** If One Selected - boolean check on names in the string-array parameter ifSelAll(["Hallo","Grobi"])
//*******************************************************************************************************
function ifSelOne( stringArray )
//*******************************************************************************************************
{
	for ( var x=0; x<stringArray.length; x++ ) if ( isSelected(stringArray[x])==true ) return true;
	return false;
}

//*******************************************************************************************************
//**** Sum Selection - int-number of selected names in the string-array param. sumSel(["Hallo","Grobi"])
//*******************************************************************************************************
function sumSel( stringArray )
{
	var result = 0;
	for ( var x=0; x<stringArray.length; x++ ) if ( isSelected(stringArray[x])==true ) result++;
	return result;
}


//*******************************************************************************************************
//**** LISTLOAD loads a ";"-separated table with column-names as headline 
//*******************************************************************************************************
function LISTLOAD( listName )
//*******************************************************************************************************
{
	IniListArray = [];  // List-array cleared
	IniListArray = new XML(this.getField("Pandora").value).Tables.elements([listName]).toString().split("\n"); // read the list lines as a splitted array
}

//*******************************************************************************************************
//**** LISTVAL reads a value of a trans-column's line from a given ref-colum-/ref-item-name
//*******************************************************************************************************
function LISTVAL( refColumnName, refColumnItemName, transColumnName )
{
	var result = "LISTVAL(?)";
	if ( IniListArray.length != 0 )
	{
		var Header = IniListArray[0].split(";");
		var refColNum = Header.indexOf(refColumnName); 
		var transColNum = Header.indexOf(transColumnName); 
		result = "?";
		if ( (refColNum>=0) && (transColNum>=0) ) for ( var y=1; y<IniListArray.length; y++ )
		{
			var cells = IniListArray[y].split(";");
			if ( cells[refColNum] == refColumnItemName ) { result = cells[transColNum]; break }
		}
	}
	return result;
}

//*******************************************************************************************************
//**** TABLOAD loads a ";"-separated table with unit-names as headline and value-names as first row
//*******************************************************************************************************
function TABLOAD( tableName )
//*******************************************************************************************************
{
	TableObj = {};  // clear the Table-object
	var TableRaw = new XML(this.getField("Pandora").value).Tables.elements([tableName]).toString().split("\n"); // read the tables lines as a splitted array
	TableObj["Header"] = TableRaw[0].split(";");  // create the header-list from the top table-line
	TableObj["Header"].shift();  // erase the index-field at coordinate 0,0
	TableObj["HeaderSelected"]=[];  // create the header-list from selected units only
	for ( var x=0; x<TableObj["Header"].length; x++ )  // run over all header entries
	{
		if ( isSelected( TableObj["Header"][x] )) TableObj["HeaderSelected"].push(TableObj["Header"][x]);  // if selected unit, push the unit-name to HeaderSelected,
		else TableObj["HeaderSelected"].push("");  // else push empty string
	}
	for ( var x=1; x<TableRaw.length; x++ )  // run over all remaining table-lines (1..n)
	{
		var column = TableRaw[x].split(";");  // split the actual line to it's single columns
		var name = column.shift();  // remove the first-column's name from column
		TableObj[name] = column;  // create a table list named as the first column with the remaining column-values
	}
}


//*******************************************************************************************************
//**** TABSTR summarizes the value of all selected units or combined with the units in the name-list
//*******************************************************************************************************
function TABSTR( valueName, colNameList )
//*******************************************************************************************************
{
	var result = "";  // preset the result value
	for ( var x=0; x<TableObj.HeaderSelected.length; x++ ) if ( TableObj.HeaderSelected[x] != "" ) // run over all selected unit names
	{
		switch ( arguments.length ) // switch to the function-mode defined by the number of function-arguments
		{
			case 1: 	{ result += TableObj[valueName][x] } break; // get the summarised strings of all selected columns
			case 2: 	{ if ( colNameList.indexOf(TableObj.HeaderSelected[x]) >= 0 ) result += TableObj[valueName][x] } break;  // calculate the sum of selected & defined unit's-values
			default:	return 'TABSTR: wrong parameters!\rUsage:\rTABSTR("P1",[P2]) parameter P2 is optional\rTABSTR("valueName",["unit1","unit2", ... ,"unitN"])';  // show error-message if arguments are wrong
		}
	}
	return result;
}


//*******************************************************************************************************
//**** TABSUM summarizes the value of all selected units or combined with the units in the name-list
//*******************************************************************************************************
function TABSUM( valueName, nameList )
//*******************************************************************************************************
{
	var result = 0;  // preset the result value
	for ( var x=0; x<TableObj.HeaderSelected.length; x++ ) if ( TableObj.HeaderSelected[x] != "" ) // run over all selected unit names
	{
		switch ( arguments.length ) // switch to the function-mode defined by the number of function-arguments
		{
			case 1: 	{ result += parseFloat("0"+TableObj[valueName][x]) } break; // calculate the sum of all selected unit's-values
			case 2: 	{ if ( nameList.indexOf(TableObj.HeaderSelected[x]) >= 0 ) result += parseFloat("0"+TableObj[valueName][x]) } break;  // calculate the sum of selected & defined unit's-values
			default:	return 'TABSUM: wrong parameters!\rUsage:\rTABSUM("P1",[P2]) parameter P2 is optional\rTABSUM("valueName",["unit1","unit2", ... ,"unitN"])';  // show error-message if arguments are wrong
		}
	}
	return result;
}


//*******************************************************************************************************
//**** TABMAX reads the maximum value of all selected units or combined with the units in the name-list
//*******************************************************************************************************
function TABMAX( valueName, nameList )
//*******************************************************************************************************
{
	var result = 0;  // preset the result value
	for ( var x=0; x<TableObj.HeaderSelected.length; x++ ) if ( TableObj.HeaderSelected[x] != "" ) // run over all selected unit names
	{
		switch ( arguments.length ) // switch to the function-mode defined by the number of function-arguments
		{
			case 1: 	{ if ( result<parseFloat("0"+TableObj[valueName][x]) ) result=parseFloat("0"+TableObj[valueName][x]) } break; // if result<current unit's value, set result
			case 2: 	{ 
							if ( nameList.indexOf(TableObj.HeaderSelected[x]) >= 0 )  // if the current unit is in the parameter-list,
								if ( result<parseFloat("0"+TableObj[valueName][x]) ) result=parseFloat("0"+TableObj[valueName][x])  // if result<current unit's value, set result
						} break;
						
			default:	return 'TABMAX: wrong parameters!\rUsage:\rTABMAX("P1",[P2]) parameter P2 is optional\rTABMAX("valueName",["unit1","unit2", ... ,"unitN"])';  // show error-message if arguments are wrong
		}
	}
	return result;
}


//*******************************************************************************************************
//**** TABMIN reads the minimum value of all selected units or combined with the units in the name-list
//*******************************************************************************************************
function TABMIN( valueName, nameList )
//*******************************************************************************************************
{
	var result = 0; // preset the result value
	switch ( arguments.length ) // depending on the arguments
	{
		case 1: { result = TABMAX( valueName ) };  // preset the result with the maximum value of selected units
		case 2: { result = TABMAX( valueName, nameList) }; // preset the result with the maximum value of selected units from name-list
	}
	for ( var x=0; x<TableObj.HeaderSelected.length; x++ ) if ( TableObj.HeaderSelected[x] != "" )  // run over all selected unit names
	{
		switch ( arguments.length )  // switch to the function-mode defined by the number of function-arguments
		{
			case 1: 	{ if ( result>parseFloat("0"+TableObj[valueName][x]) ) result=parseFloat("0"+TableObj[valueName][x]) } break;  // if result>current unit's value, set result
			case 2: 	{ 
							if ( nameList.indexOf(TableObj.HeaderSelected[x]) >= 0 )  // if the current unit is in the parameter-list,
								if ( result>parseFloat("0"+TableObj[valueName][x]) ) result=parseFloat("0"+TableObj[valueName][x]) // if result>current unit's value, set result
						} break;
			default:	return 'TABMIN: wrong parameters!\rUsage:\rTABMIN("P1",[P2]) parameter P2 is optional\rTABMIN("valueName",["unit1","unit2", ... ,"unitN"])';  // show error-message if arguments are wrong
		}
	}
	return result;
}


//*******************************************************************************************************
//**** TABCOUNT counts the non-zero-values of selected units or combined with the units in the name-list
//*******************************************************************************************************
function TABCOUNT( valueName, nameList )
//*******************************************************************************************************
{
	var result = 0; // preset the result value
	for ( var x=0; x<TableObj.HeaderSelected.length; x++ ) if ( TableObj.HeaderSelected[x] != "" )  // run over all selected unit names
	{
		switch ( arguments.length )  // switch to the function-mode defined by the number of function-arguments
		{
			case 1: 	{ if ( parseFloat("0"+TableObj[valueName][x]) != 0 ) result++ } break;  // if current unit's value not zero, increase result
			case 2: 	{ 
							if ( nameList.indexOf(TableObj.HeaderSelected[x]) >= 0 )  // if the current unit is in the parameter-list,
								if ( parseFloat("0"+TableObj[valueName][x]) != 0 ) result++;   // if current unit's value not zero, increase result
						} break;
			default:	return 'TABCOUNT: wrong parameters!\rUsage:\rTABCOUNT("P1",[P2]) parameter P2 is optional\rTABCOUNT("valueName",["unit1","unit2", ... ,"unitN"])';  // show error-message if arguments are wrong
		}
	}
	return result;
}

//**************************************************************************************************************************
//*** Initialise Foliant from XFDF-data loaded to field "Transmitter"
//**************************************************************************************************************************
function initialiseFromXFDF() 
{
	var s = this.getField("Transmitter").value;
	if ( s == "" ) return;
	if ( s.indexOf("<?xml") >= 0 ) return;
	if ( s.indexOf("<order") >= 0 )
	{
		var cfg = new XML ( this.getField("Transmitter").value );
		if ( cfg.foliant.toString() == "" ) return;
		resetAll(); 																// reset the selection
		var cfgList = cfg.foliant.clicked.split(";");  								// get the list of clicked icons ( no added !! )
		
		for ( var x = 0; x<cfgList.length; x++ ) iconHandler(cfgList[x]);			// virtually re-click the listed icons for reconfiguration
		var langName = cfg.foliant.language.toString();
		if ( langName != "" )
		{
			Library.CurrentLanguage = langName;
			Library_Save();
			Library_Init();
		}
		var pageName = cfg.foliant.visiblePage.toString();
		if ( pageName != "" )
		{
			this.getField("LogicChart").display = display.hidden;
			finaliseActionLogic();
			showPage ( "@"+pageName, true ); Library.VisiblePage = pageName; Library_Save();
		}
		markedDirty = false;														// set dirty to "un-changed"
		this.dirty = markedDirty;
	}
}


//***********************************************************************************************************
// create order-list as XML-structure from system-selection
//***********************************************************************************************************
function createXMLOrder()
{
	LISTLOAD("ArticleCodes");	// load list-data from Pandora-Table area
	var nameColumn = IniListArray[0].split(";").indexOf("name");	// detect name-column number
	var codeColumn = IniListArray[0].split(";").indexOf("code");	// detect code-column number
	var mainItemList = Registry.System.Logic.MainItem.split(";");	// get the main-unit list from Registry
	var order = <order><configurationtarget/><systemCode/><article/><foliant/></order>;	// initialise the order-XML-structure
	for ( var x=1; x<IniListArray.length; x++ )	// run over all list-lines
	{
		var itemName = IniListArray[x].split(";")[nameColumn]+"";	// get the list column for itemNames
		var itemCode = IniListArray[x].split(";")[codeColumn]+"";	// get the list column for itemCodes
		var idx = order.article.art.(@code == itemCode);	// get the article with @code == itemCode
		if ( idx.length() == 0 )	// if XML idx is empty (length==0)
		{	
			order.article.insertChildAfter( null, <art/> );	// create new article
			order.article.art[0].@code = itemCode;	// set child's @code to article-code
			order.article.art[0].@mainUnit = 0;	// set mainUnit-marker to default=0
			order.article.art[0].@quantity = 0;	// set @quantity
			order.article.art[0].@item = "";	// set @item-name as ";"-sep stringlist
			idx=0;	// set idx to first childIndex -> 0
		} 
		else idx = order.article.art.(@code == itemCode).childIndex();	// if idx not empty, set idx to childIndex
		if ( mainItemList.indexOf(itemName) >= 0 ) order.article.art[idx].@mainUnit = 1;	// set MainUnit-attribute if ...
		if ( isSelected( itemName ) == true ) order.article.art[idx].@quantity ++;	// set @quantity
		if ( ( mainItemList.indexOf(itemName) >= 0 ) &&  isSelected( itemName ) ) order.systemCode = itemCode;	// set systemCode if ...
		order.article.art[idx].@item = order.article.art[idx].@item+itemName+";";	// set @item-name as ";"-sep stringlist
	}
	order.foliant.clicked = Registry.System.Logic.Clicked.toString();	// add the Foliant's clicked-list 
	order.foliant.idCode = Registry.Internals.ident.idCode.@value.toString();	// add the idCode of the specific Foliant
	order.foliant.language = Library.CurrentLanguage.toString();	// save the current used language
	order.foliant.visiblePage = Library.VisiblePage.toString();	// save the current visible results-page
	order.complete = Boolean([display.visible,display.hidden].indexOf(this.getField("Btn_IncompleteSys").display));	// save the validation-status
	return order;
}

var guid = "";	// web-browser URL parameter ( UID )

function _startup() 
{
	// activate the startup-overlay-screen 
	var f = this.getField("Btn_VersionCheckOverlay");
	f.delay = true;
	f.display = display.visible;
	f.rect = [0, 842, 595, 0 ];
	var msgVersionWarning = f.userName;
	f.delay = false;
	// check the current version of the PDF-viewer for compatibility
	var reqVersion = 8.0;
	var appInfo = {};
		appInfo.Type = app.viewerType; 
		appInfo.Variation = app.viewerVariation;
		appInfo.Version = app.viewerVersion;
		appInfo.VersionText = 'v'+appInfo.Version; if (appInfo.VersionText.indexOf(".")<0) appInfo.VersionText += '.0';
	if ( appInfo.Version < reqVersion )
	{
		var nButton = app.alert({cMsg: msgVersionWarning, cTitle: appInfo.Type+'  ( '+appInfo.Variation+' )  '+appInfo.VersionText, nIcon: 1, nType: 1 });
		if ( nButton == 2 ) this.closeDoc(); 
	}
} 

_startup();	// call the startup-function first - before XML-activities to protect from too old application versions
this.disclosed = true;	// make PDF detectable for other PDF-sessions
var markedDirty = this.dirty; // create variable to indicate the document's changes to be saved ( per function )

// initialise and check the Registry-XML-structure
registryInit();
if (Registry.System.Atoms.toString()=="") { Registry.System.Atoms=""; registrySave() }	// check for empty Atoms-structure, if empty, create "" value on it
if (Registry.System.Logic.toString()=="") { Registry.System.Logic=""; registrySave() }	// check for empty Logic-structure, if empty, create "" value on it

// initialise the Library-XML-Structure
Library_Init();

// call initialisation functions

// create the info-text for the status-bar ( BottomLine )
setBottomBarInfoLine();	

// set the submit-button to visible by default
Registry.Internals.menuItems.Btn_SubmitCRM.@visible=true;	

// is browser-detection enabled ??? If yes ...
if ( Registry.Internals.settings.detectExternal.@value=="true" ) 	
	if ( ( this.external == false ) || ( guid == "" ) ) Registry.Internals.menuItems.Btn_SubmitCRM.@visible=false;	// ... and no browser or no guid parameter found, SubmitCRM-btn will be hidden

// set all menu buttons to Registry-defined values
arrangeMenuButtons();	

// switch off focus rectangles for buttons ( icons )
app.focusRect = false;	

// switch off highliting of edit fields
app.runtimeHighlight = false;	

// set "dirty"-value to the startup-value
this.dirty = markedDirty;

// save all re-initialised values in Registry-XML-variable
registrySave();

// remove the startup-overlay
this.getField("Btn_VersionCheckOverlay").rect = [0, 0, 0, 0 ];

// identify the document by internal registry values / returns the ident-structure
var identifyDoc = Registry.Internals.ident;