//v0.5.7 - o3/2o16
//- fix for version compare to handle versions without "."
//- internal fix for scriptwizards own forum thread url handling
//- support for native url property (OnInit.Url since DO v12.0.8b)

//v0.5.6 - o1/2o16
//- https url support
//v0.5.5 - o7/2o15
//- ConfigHelper updated to v1.2
//- column "enabled" separated, not included in cache anmymore
//- fix for basename-preserve not removing *.txt extension
//- FILE option defaults to "script addins" now (no need to pass full path anymore)
//v0.5.4 - o2/2o15
//- merged with colcache devbranch
//- german translations added by kundal
//- error fix for unknown language in translator
//- colcache fix for expired items
//- updating script to package or reverse does not change basename
//- new script config items to disable keeping of basenames
//- new script config items to disable log output for columns
//- self update options (silently updates itself by default)
//- log file size limited to 2-3mb
//v0.5.2 - o2/2o15
//- major ColumnCache fixes and enhancements
//v0.5.1 - o2/2o15
//- merged released v0.4.5 with dev branch v0.5
//v0.5 - 12/2o14
//- multi-language support (en, de)
//- ul/li tags filtered to prevent thread-parsing error
//- column cache activated by default
//- winXP error-dialog fix on initialization
//- about-dialog error fix for multiple or no listers present
//- fetching enabled-status and dopus id of script packages fixed
//- about dialog confirmation texts equalized
//- error handling enhancements
//- remove wrong utf8/16 bom, when saving out to utf16
//- version string comparison enhanced
//v0.4.5 - o2/2o15
//- fix for unescaped ampersand in faq links
//- fix for emergency download not working (damn it! o)
//v0.4.4 - 01/2o15
//- fix for updated board-software on resource.dopus.com
//- fix for script packages not extractable error
//v0.4.3 - 11/2o14
//- MD5 hash creation bugfix
//- german forum download bugfix
//- upload prepared files will be automatically converted to unicode (utf16)
//- downloads always treated binary
//v0.4.2 - 11/2o14
//- added resource center urls for some commands
//- added support for german h&p directory opus forum
//- added experimental caching of column data (do not enable for regular use)
//v0.4.1 - 11/2o14
//- min version added
//- lots of new stuff

//todo
//- clear cache entry for uploaded/prepared items (modifications are already handled)
//- enhance progress dialog handling
//- max age to auto remove items on compact()
//- columnshash
//- optional clear on columnhash mismatch
//- support type, sort, group for columns
//- item metadata storage
//- handle bom removal/encoding conversion in every prepareupload step


///////////////////////////////////////////////////////////////////////////////
function OnInit(data){
	///////////////////////////////////////////////////////////////////////////
	Translator.
		AddT("en", {
			"command.scriptwizard.description"	:	"Helps to maintain, handle and update scripting resources.",
			"command.scriptabout.description"	:	"Multifunctional 'about'-dailog for scripting resources.",

			"script.config.archive.path"		:	"Folder path where to store archived scripts.",
			"script.config.log.toconsole"		:	"Enable output to the script console.",
			"script.config.log.level"			:	"Log level, 'normal' is the recommended setting. Use 'trace' or 'dump' for extended troubleshooting.",
			"script.config.log.tofile"			:	"Enable output to log file.",
			"script.config.log.tofile.path"		:	"Log file path.",
			"script.config.onstartup.update.sw"	:	"Settings for automatic updating of scriptwizard.",
				"update.sw.ask"					:	"Confirm before updating",
				"update.sw.silent"				:	"Silently update",
				"update.sw.disabled"			:	"disabled",

			"script.config.preservename.singlescript":	"Keep the name of a local script file when updating.",
			"script.config.preservename.package":	"Keep the name of a local package when updating.",
			"script.config.preservename.typemismatch":	"Keep the name of a local script or package if the update is of a different kind. A script file will keep it's name if the update comes as package e.g.",


			"script.config.columns.cache.enabled"		: "Enable caching of script detail columns.",
			"script.config.columns.cache.expiration"	: "Expiration duration in days for each item in the script detail column data."
		}).
		AddT("de", {
			"command.scriptwizard.description"	:	"Hilft bei der Verwaltung, Handhabung und dem Aktualisieren von Script-Addins.",
			"command.scriptabout.description"	:	"Multifunktioneller 'Über'-Dialog für Script-Addins.",

			"script.config.archive.path"		:	"Pfad zur Ablage von archivierten Script-Addins.",
			"script.config.log.toconsole"		:	"Log-Ausgaben in der Scriptkonsole aktivieren.",
			"script.config.log.level"			:	"Log-Level, 'normal' ist der empfohlene Wert. Benutzen Sie 'trace' oder 'dump' für die Fehlersuche.",
			"script.config.log.tofile"			:	"Log-Ausgaben in Datei aktivieren.",
			"script.config.log.tofile.path"		:	"Pfad zur Log-Datei.",
			"script.config.onstartup.update.sw"	:	"Einstellungen für die automatische Aktualisierung von ScriptWizard.",
				"update.sw.ask"					:	"Auf Nachfrage aktualisieren",
				"update.sw.silent"				:	"Ohne Nachfrage aktualisieren",
				"update.sw.disabled"			:	"deaktiviert",

			"script.config.preservename.singlescript":	"Den Namen der lokalen Scriptdatei bei einer Aktualisierung beibehalten.",
			"script.config.preservename.package":	"Den Namen des lokalen Scriptpaketes bei einer Aktualisierung beibehalten.",
			"script.config.preservename.typemismatch":	"Den Namen einer lokalen Scriptresource auch bei unterschiedlichen Typen beibehalten. Ein Script kann somit bspw. zu einem Scriptpaket mit gleichem Namen aktualisiert werden.",

			"script.config.columns.cache.enabled": "Caching der ScriptDetail-Spaltenwerte aktivieren.",
			"script.config.columns.cache.expiration": "Ablaufzeit in Tagen für zwischengespeicherte Spaltenwerte."
		});
	///////////////////////////////////////////////////////////////////////////
	var uid = "D4072BDA-B049-4A11-8B40-266E083D6F2D";
	var url = "http://resource.dopus.com/viewtopic.php?f=35&t=23179";
	if (DOpus.Version.AtLeast("12.0.8"))
		data.url = "http://resource.dopus.com/viewtopic.php?f=35&t=23179";

	data.name = "Command.Generic: ScriptWizard";
	data.desc = "Helps to maintain, handle and update scripting resources";
	data.desc = t("command.scriptwizard.description");
	data.copyright = "tbone";
	data.version = "0.5.7";
	data.default_enable = true;
	data.min_version = "11.7.1";
	if (DOpus.Version.AtLeast("11.8.2"))
		data.log_prefix = "SW";

	var cmd = data.AddCommand();
	cmd.name = "ScriptAbout"
	cmd.method = "Command_ScriptAbout";
	cmd.desc = t("command.scriptabout.description");
	cmd.template = "FILE/K,WIN/K";

	var cmd = data.AddCommand();
	cmd.name = "ScriptWizard"
	cmd.method = "Command_ScriptWizard";
	cmd.desc = data.desc;
	cmd.template = "ABOUT/S,UPDATE/S,ARCHIVE/S,VISIT/S,OPENLOG/S,ALL/S,FILE/K,FOLDER/K,CHECK/S,FORCE/S,INTERACTIVE/S,SILENT/S,SHOWRESULTS/S,UPDATEOFFER/S,PREPAREUPLOAD/S,UPDATEHASH/S,PROGRESS/S,CLEARCOLS/S,WIN/K";
	///////////////////////////////////////////////////////////////////////////
	function ConfigHelper(data){ //v1.2
		var th=this; th.d=data; th.c=data.config; th.cd=DOpus.Create.Map();
		th.add=function(name, val, des){ th.l={n:name,ln:name.
			toLowerCase()}; return th.val(val).des(des);}
		th.des=function(des){ if (!des) return th; if (th.cd.empty)
			th.d.config_desc=th.cd; th.cd(th.l.n)=des; return th;}
		th.val=function(val){ var l=th.l; if (l.v!==l.x&&typeof l.v=="object")
			l.v.push_back(val);else l.v=th.c[l.n]=val;return th;}
		th.trn=function(){ return th.des( t("script.config."+th.l.ln));}}
	///////////////////////////////////////////////////////////////////////////
	var cfg = new ConfigHelper(data);
	cfg.add("Archive.Path",					"/dopusdata\\Script Addins\\archive").trn();
	cfg.add("Log.ToConsole",				true).trn();
	cfg.add("Log.Level",					DOpus.Create.Vector()).trn().
		val(4).val("Exceptions").val("Errors").val("Warning").val("Info").val("Normal").val("Trace").val("Dump");
	cfg.add("Log.ToFile",					true).trn();
	cfg.add("Log.ToFile.Path",				"/dopusdata\\logs\\ScriptWizard.log.txt").trn();
	cfg.add("Log.What.Columns",				false).trn();
	cfg.add("Log.What.KeepTmpFiles",		false).trn();
	cfg.add("Log.What.Other",				true).trn();
	cfg.add("Columns.Cache.Enabled",		true).trn();
	cfg.add("Columns.Cache.Expiration",		14).trn();
	cfg.add("PreserveName.SingleScript",	true).trn();
	cfg.add("PreserveName.Package",			true).trn();
	cfg.add("PreserveName.TypeMismatch",	true).trn();
	cfg.add("OnStartup.Update.SW",				DOpus.Create.Vector()).trn().
		val(0).val(t("update.sw.ask")).val(t("update.sw.silent")).val(t("update.sw.disabled"));

	RemoveDeprecatedVersions();
	out.mute(false).level(6);
	new ColumnCache("ScriptDetails", false).Compact();
}
///////////////////////////////////////////////////////////////////////////////
var COMMAND_ABORTED = true;
var COMMAND_SUCCEEDED = false;
new Translator(this);
var FSMagic = new FSMagic();
var ResParser = new DOResourceParser();
///////////////////////////////////////////////////////////////////////////////
Date.prototype.formatTime = function (){
	var hour = this.getHours();
	if (hour<10) hour="0"+hour;
	var min = this.getMinutes();
	if (min<10) min="0"+min;
	var secs = this.getSeconds();
	if (secs<10) secs="0"+secs;
	return hour+":"+min+":"+secs;
}
///////////////////////////////////////////////////////////////////////////////
Date.prototype.formatDate = function (){
	var day = this.getDate();
	if (day<10) day="0"+day;
	var month = this.getMonth()+1;
	if (month<10) month="0"+month;
	var year = this.getFullYear();
	return year+"."+month+"."+day;
}
///////////////////////////////////////////////////////////////////////////////
String.prototype.lTrim = function(chr){chr=chr||"\\s";return new String(this.replace(new RegExp("^"+chr+"*","i"),''));}
String.prototype.rTrim = function(chr){chr=chr||"\\s";return new String(this.replace(new RegExp(chr+"*$","i"),''));}
String.prototype.trim = function(chr){return this.lTrim(chr).rTrim(chr);}
String.prototype.left = function(chrs){return this.substring(0,chrs);}
String.prototype.right = function(chrs){return this.substring(this.length-chrs);}
///////////////////////////////////////////////////////////////////////////////
try {
	var out = new DebugOutput();

	if (Script); //will fail here on script (re)load once
	out.level(Script.Config["Log.Level"]).
		console(Script.Config["Log.ToConsole"]).
		buffer(true); //out._keepInds = true;

	if (Script.Config["Log.ToFile"] && Script.Config["Log.ToFile.Path"])
		out.max(1024*1024*2).
			tolerance(50).
			append(DOpus.FSUtil.Resolve(Script.Config["Log.ToFile.Path"]));

	var ColCache = new ColumnCache("ScriptDetails",
		/* enabled      */ Script.Config["Columns.Cache.Enabled"],
		/* expire after */ Script.Config["Columns.Cache.Expiration"]*86400000 /*(ms of a day)*/,
		/* persistent   */ true,
		/* column names */ ["Name","Description","Copyright","Enabled","Version","MinVersion","Status","Modified","Url","Info"]);
	ColCache.log = Script.Config["Log.What.Columns"];
	out.mute();

} catch(e){
	DOpus.Output("Loaded successfully.");
	//throw e;
}
var gThis = this;
///////////////////////////////////////////////////////////////////////////////
function Command_ScriptAbout(data){
	//deprecated, do not use!
	out.mute(false);
	data.func.command.ClearFiles();
	out.trc("ScriptAbout():",1);
	var p = {
		file	: GetParameter(data, "FILE", null, ""),
		win		: GetParameter(data, "WIN", null, "")
	}
	var ad = new AboutDialog( p.file, p.win);
	ad.Init();
	ad.Show();
	out.reset();
}
///////////////////////////////////////////////////////////////////////////////
function Command_ScriptWizard(data){
	out.mute(false);
	out.trc("ScriptWizard():",1);
	data.func.command.ClearFiles();

	var result = COMMAND_SUCCEEDED;
	var p = {
		about		: GetParameter(data, "ABOUT", null, false),
		update		: GetParameter(data, "UPDATE", null, false),
		archive		: GetParameter(data, "ARCHIVE", null, false),
		visit		: GetParameter(data, "VISIT", null, false),
		openLog		: GetParameter(data, "OPENLOG", null, false),
		all			: GetParameter(data, "ALL", null, false),
		file		: GetParameter(data, "FILE", null, ""),
		folder		: GetParameter(data, "FOLDER", null, ""),
		check		: GetParameter(data, "CHECK", null, false),
		updateOffer	: GetParameter(data, "UPDATEOFFER", null, false),
		updateHash	: GetParameter(data, "UPDATEHASH", null, false),
		prepScript	: GetParameter(data, "PREPAREUPLOAD", null, false),
		force		: GetParameter(data, "FORCE", null, false),
		interactive	: GetParameter(data, "INTERACTIVE", null, false),
		silent		: GetParameter(data, "SILENT", null, false),
		showResults	: GetParameter(data, "SHOWRESULTS", null, false),
		progress	: GetParameter(data, "PROGRESS", null, false),
		clearCols	: GetParameter(data, "CLEARCOLS", null, false),
		win			: GetParameter(data, "WIN", null, null)
	}

	if (!p.win)	p.win = data.func.sourcetab.lister;
	var resUp = new DOResourceUpdater();
	resUp.silent		= p.silent;
	resUp.interactive	= p.interactive;
	resUp.progress		= p.progress;
	resUp.showResults	= p.showResults;
	resUp.win			= p.win;
	resUp.force			= p.force;
	resUp.updateOffer	= p.updateOffer

	function GetFiles(data){
		try{
			var files = data.func.sourcetab.selected_files;
			return { enumerator:new Enumerator(files), count:files.count};
		} catch(e){
			return {enumerator:null, count:0};
		}
	}

	var resultTmp = true;
	var files = {enumerator:null, count:0};

	if (!p.folder) p.folder = DOpus.FSUtil.Resolve("/dopusdata/script addins");

	var file = "";
	if (p.file)
		file = p.file;
	else {
		files = GetFiles(data);
		if (files.count)
			file = files.enumerator.item().realpath;
	}
	///////////////////////////////////////////////////////
	if (0){}
	else if (p.about && file){
		var ad = new AboutDialog( file, p.win);
		ad.Init();
		ad.Show();
	}
	///////////////////////////////////////////////////////
	else if (p.visit && file){
		resultTmp = resUp.Visit(file);
	}
	///////////////////////////////////////////////////////
	else if (p.clearCols){
		resultTmp = ColCache.Clear();
	}
	///////////////////////////////////////////////////////
	else if (p.archive){
		out.put("Archive..");
		if (p.file)
			resultTmp = resUp.ArchiveScript(String(p.file));
		else if (p.all){
			var fEnum = new Enumerator(data.func.sourcetab.files);
			while (!fEnum.atEnd()) {
				var file = fEnum.item().realpath; fEnum.moveNext();
				resUp.ArchiveScript(String(file));
			}
		}
		else if (files.count){
			var fEnum = files.enumerator;
			while (!fEnum.atEnd()) {
				var file = fEnum.item().realpath; fEnum.moveNext();
				resUp.ArchiveScript(String(file));
			}
		}
		else
			out.put("Bad params. No scripts given/selected.");
	}
	///////////////////////////////////////////////////////
	else if (p.openLog){
		out.put("OpenLog..");
		resultTmp = !resUp.OpenLog();
	}
	///////////////////////////////////////////////////////
	else if (p.check){
		out.put("Check..");
		if (p.all)
			resultTmp = resUp.UpdateCheckAll(p.folder);
		else if (p.file)
			resultTmp = resUp.UpdateCheck(p.file);
		else if (files.count){
			var fEnum = files.enumerator;
			while (!fEnum.atEnd()) {
				var file = fEnum.item().realpath; fEnum.moveNext();
				resUp.UpdateCheck(file);
			}
		}
		else
			out.put("Bad params. No scripts given/selected.");
	}
	///////////////////////////////////////////////////////
	else if (p.update){
		out.put("Update..");
		if (p.all)
			resultTmp = resUp.UpdateAll(p.folder);
		else if (p.file)
			resultTmp = resUp.Update(p.file);
		else if (files.count){
			var fEnum = files.enumerator;
			while (!fEnum.atEnd()) {
				var file = fEnum.item().realpath; fEnum.moveNext();
				resultTmp = resUp.Update(file);
			}
		}
		else
			out.put("Bad params. No scripts given/selected.");
	}
	///////////////////////////////////////////////////////
	else if (p.updateHash && file){
		out.put("UpdateHash..");
		var preparer = new UploadPreparer();
		resultTmp = preparer.UpdateMD5(file);
	}
	///////////////////////////////////////////////////////
	else if (p.prepScript && file){
		out.put("PrepScript..");
		var preparer = new UploadPreparer();
		preparer.win = p.win;
		resultTmp = preparer.PrepareScript(file);
	}
	///////////////////////////////////////////////////////
	else {
		out.put("Bad params. Bad command or no script given/selected.");
		result = COMMAND_ABORTED;
	}

	if (!resultTmp) result = COMMAND_ABORTED;
	out.reset();
	return result;
}
///////////////////////////////////////////////////////////////////////////////
function OnAboutScript(data){ //v0.1
	var cmd = DOpus.Create.Command();
	if (!cmd.Commandlist('s').exists("ScriptWizard")){
		if (DOpus.Dlg.Request("The 'ScriptWizard' add-in has not been found.\n\n"+
"Install 'ScriptWizard' from [resource.dopus.com].\nThe add-in enables this dialog and also offers "+
"easy updating of scripts and many more.","Yes, take me there!|Cancel", "No About.. ", data.window))
		cmd.RunCommand('http://resource.dopus.com/viewtopic.php?f=35&t=23179');}
	else
		cmd.RunCommand('ScriptWizard ABOUT WIN='+data.window+' FILE="'+Script.File+'"');
}
///////////////////////////////////////////////////////////////////////////////
function OnStartup(){
	var cmd = DOpus.Create.Command();
	if (Script.config["OnStartup.Update.SW"] == 2) //updating sw disabled
		return;
	if (Script.config["OnStartup.Update.SW"] == 1){ //updating sw silently
		DOpus.Delay(15000);
		cmd.RunCommand('ScriptWizard UPDATE FILE="'+Script.File+'"');
	}
	if (Script.config["OnStartup.Update.SW"] == 0){ //updating sw with confirmation
		DOpus.Delay(15000);
		cmd.RunCommand('ScriptWizard CHECK INTERACTIVE UPDATEOFFER PROGRESS FILE="'+Script.File+'"');
	}
}
///////////////////////////////////////////////////////////////////////////////
function AboutDialog( file, win){
	this.res		= null;
	this.file		= file;
	this.win		= win;
	this.cmd		= DOpus.Create.Command();
	this.confirm	= 1;
	///////////////////////////////////////////////////////////////////////////
	this.Show = function(){
		out.trc("ShowAbout():",1);
		var dlg			= DOpus.Dlg;
		dlg.window		= (this.win?this.win:null);
		dlg.message		= this.GetText();
		dlg.title		= "ScriptAbout: "+this.res.name;
		dlg.buttons		= this.buttons;
		dlg.icon		= "info";
		dlg.max			= 512;
		dlg["default"]	= this.file;
		var label		= t("req.confirm_operations");
		for(var len=0;len<120;len++) label+=" ";label+="\t";
		dlg.options(0).label = label;
		dlg.options(0).state = this.confirm;
		var result = dlg.Show();
		this.confirm = dlg.options(0).state;
		switch (result){
			case this.BtnID(t("button.visitforum")):			this.Button_VisitForum();		break;
			case this.BtnID(t("button.checkversion")):			this.Button_UpdateCheck();		break;
			case this.BtnID(t("button.update")):				this.Button_Update();			break;
			case this.BtnID(t("button.updateall")):				this.Button_UpdateAll();		break;
			case this.BtnID(t("button.openlog")):				this.Button_OpenLog();			break;
			case this.BtnID(t("button.showdetails")):			this.Button_ShowDetails();		break;
			case this.BtnID(t("button.prepareupload")):			this.Button_PrepareUpload();	break;
			case this.BtnID(t("button.archive")):				this.Button_Archive();			break;
			case this.BtnID(t("button.updatemd5")):				this.Button_UpdateMD5();		break;
			case this.BtnID(t("button.delete")):				this.Button_Delete();			break;
			case this.BtnID(t("button.rename")):				this.Button_Rename(dlg.input);	break;
			case this.BtnID(t("button.exit")):													break;
		}
		out.trc("",-1);
		return COMMAND_SUCCEEDED;
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_VisitForum = function(){
		this.cmd.RunCommand('ScriptWizard VISIT INTERACTIVE FILE="'+this.file+'" WIN='+this.win);
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_Rename = function(newFileNamePath){
		var doPath = DOpus.FSUtil.NewPath(this.file);
		var newName = newFileNamePath.getFilePart();
		var newNamePath = doPath.pathpart+"\\"+newName;
		if (this.confirm && !Request(t("req.rename.text", this.res.name, this.res.filePath.getFilePart()), t("button.ok | button.cancel"), t("req.rename.title"), "question", this.win)){
		} else {
			if (!newName || DOpus.FSUtil.Exists(newNamePath)){
				Request(t("req.rename_err.text"), t("button.ok"), t("req.rename_err.title"), "error", this.win);
			} else {
				this.cmd.RunCommand('Rename FROM="'+this.file+'" TO="'+newName+'"');
				this.file = newNamePath;
				this.Init();
			}
		}
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_Delete = function(){
		if (!Request(t("req.delete.text", this.res.name, this.res.filePath.getFilePart()),
				t("button.ok|button.cancel") ,t("req.delete.title"),"question",this.win)){
			this.Show();
		} else
			this.cmd.RunCommand('Delete QUIET FORCE FILE="'+this.file+'"');
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_UpdateCheck = function(){
		this.cmd.RunCommand('ScriptWizard CHECK UPDATEOFFER INTERACTIVE PROGRESS WIN='+
			this.win+' FILE="'+this.file+'"');
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_Update = function(){
		if (this.confirm && !Request( t("req.update.text", this.res.name, this.res.filePath.getFilePart()), t("button.ok|button.cancel"), t("req.update.title"), "question", this.win)){
		} else{
			this.cmd.RunCommand('ScriptWizard UPDATE INTERACTIVE PROGRESS WIN='+this.win+' FILE="'+this.file+'"');
			this.Init(); //reload script
		}
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_UpdateAll = function(){
		if (this.confirm && !Request( t("req.update_all.text"), t("button.ok|button.cancel"), t("req.update_all.title"), "question", this.win)){
		} else
			this.cmd.RunCommand('ScriptWizard UPDATE ALL PROGRESS SHOWRESULTS WIN='+this.win);
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_OpenLog = function(){
		this.cmd.RunCommand('ScriptWizard OPENLOG');
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_ShowDetails = function(){
		var details = "";
		for(prop in this.res){
			if (prop.substring(0,1)=="_") continue;
			details += prop.toUpperCase()+":\n    "+this.res[prop]+"\n";
		}
		Request(details,t("button.ok"),t("req.details.title"),"info",this.win);
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_Archive = function(){
		if (!this.cmd.RunCommand('ScriptWizard ARCHIVE FILE="'+this.file+'"'))
			Request( t("req.archive_err.text", this.res.name, this.res.filePath.getFilePart()), t("button.ok"), t("req.archive_err.title"), "error", this.win);
		else
			Request( t("req.archive_succeeded.text", this.res.name), t("button.ok"), t("req.archive_succeeded.title"), "info", this.win);
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_UpdateMD5 = function(){
		if (this.confirm && !Request( t("req.updatemd5.text", this.res.name, this.res.filePath.getFilePart()), t("button.ok | button.cancel"), t("req.updatemd5.title"), "question", this.win)){

		} else {
			if (!this.cmd.RunCommand('ScriptWizard UPDATEHASH FILE="'+this.file+'"'))
				Request( t("req.updatemd5_err.text", this.res.name), t("button.ok"),t("req.updatemd5_err.title"),"error",this.win);
			else
				Request( t("req.updatemd5_succeeded.text", this.res.name), t("button.ok"), t("req.updatemd5.title"), "info", this.win);
		}
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Button_PrepareUpload = function(){
		if (!this.cmd.RunCommand('ScriptWizard PREPAREUPLOAD FILE="'+this.file+'" WIN='+this.win))
			Request( t("req.prepare_err.text",this.res.name), t("button.ok"), t("req.prepare_err.title"), "error", this.win);
		else
			Request( t("req.prepare_succeeded.text",this.res.name), t("button.ok"), t("req.prepare_succeeded.title"),"info",this.win);
		this.Show();
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetText = function(){
		var text = "";
		text += t("words.name")+":\n        "+this.res.name;
		if (this.res.uid) text+=" - (id: "+this.res.uid+")";
		if (this.res.desc) text+="\n\n"+t("words.description")+":\n        "+this.res.desc;
		//if (props.copyright) text+="\n\nCopyright:\n        "+this.res.copyright;
		if (this.res.version) text+="\n\n"+t("words.version")+", "+t("words.modified")+":\n        "+this.res.version+", ";
		if (this.res.modified===null) text +=t("words.modified_unknown"); else text+=(this.res.modified?t("words.modified_yes"):t("words.modified_no"));
		//if (this.res.min_version) text+="\n\nMinVersion:\n        "+props.min_version;
		text+="\n\n"+t("words.resourceurl")+":\n        "+(this.res.url?this.res.url:t("words.unavailable"));
		return text;
	}
	///////////////////////////////////////////////////////////////////////////
	this.BtnID = function(label){
		for(var b=0;b<this.abuttons.length;b++)
			if (this.abuttons[b]==label){
				if (b==this.abuttons.length-1) b=-1; break; }
		return (b+1);
	}
	///////////////////////////////////////////////////////////////////////////
	this.Init = function(){
		this.res = ResParser.Load(this.file);
		if (!this.res){
			Request( t("init.failed.text", this.file), t("button.ok"), t("init.failed.title"), "error", (this.win?this.win:null));
			out.err("Loading script ["+this.file+"] failed");
			return false;
		}
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	Translator.
		AddT("en", {
			"button.ok"						:	"Ok",
			"button.cancel"					:	"Cancel",
			//
			"button.visitforum"				:	"Visit Forum",
			"button.checkversion"			:	"Check Version",
			"button.update"					:	"Update",
			"button.updateall"				:	"Update all Scripts",
			"button.openlog"				:	"Open LogFile",
			"button.prepareupload"			:	"Prepare Upload",
			"button.updatemd5"				:	"Update MD5",
			"button.showdetails"			:	"Show Details",
			"button.archive"				:	"Archive",
			"button.rename"					:	"Rename",
			"button.delete"					:	"Delete",
			"button.exit"					:	"Exit",
			//
			"req.confirm_operations"		:	"Confirm operations",
			//
			"req.delete.title"				:	"Delete Script",
			"req.delete.text"				:	"Really delete this script?\n\nScriptname:\n    %s\nFilename:\n    %s",
			//
			"req.rename.title"				:	"Rename Script",
			"req.rename.text"				:	"Really rename this script?\n\nScriptname:\n    %s\nFilename:\n    %s",
			"req.rename_err.title"			:	"Rename Script - Error",
			"req.rename_err.text"			:	"Rename failed!\n\nNo proper name given or the file already exists.",
			//
			"req.update.title"				:	"Update Script",
			"req.update.text"				:	"Really update this script?\n\nScriptname:\n    %s\nFilename:\n    %s",
			//
			"req.update_all.title"			:	"Update Script",
			"req.update_all.text"			:	"You're about to update all scripts.\n\n"+
												"Don't worry, you'll be safe! Any changed or modified script "+
												"will not be updated automatically.\nScript configurations will be preserved as well.",
			//
			"req.details.title"				:	"Script Details",
			//
			"req.archive_succeeded.title"	:	"Archive Script",
			"req.archive_succeeded.text"	:	"Archiving of script [%s] succeeded!",
			"req.archive_err.title"			:	"Archive Script - Error",
			"req.archive_err.text"			:	"Archiving of script [%s] failed!",
			//
			"req.updatemd5.title"			:	"Update Hash",
			"req.updatemd5.text"			:	"Really update MD5 hash of this script?\n\nScriptname:\n    %s\nFilename:\n    %s",
			"req.updatemd5_succeeded.text"	:	"Updating MD5 hash of script [%s] succeeded!",
			"req.updatemd5_err.title"		:	"Archive Script - Error",
			"req.updatemd5_err.text"		:	"Updating MD5 hash of script [%s] failed!",
			//
			"req.prepare_succeeded.title"	:	"Prepare ScriptUpload",
			"req.prepare_succeeded.text"	:	"Preparing upload of script [%s] succeeded!",
			"req.prepare_err.title"			:	"Prepare ScriptUpload - Error",
			"req.prepare_err.text"			:	"Preparing upload of script [%s] failed!",
			//
			"words.name"					:	"Name",
			"words.description"				:	"Description",
			"words.version"					:	"Version",
			"words.resourceurl"				:	"Resource Url",
			"words.modified"				:	"modified",
			"words.modified_yes"			:	"*** modified ***",
			"words.modified_no"				:	"not modified",
			"words.modified_unknown"		:	"unknown",
			"words.unavailable"				:	"<not available>",
			//
			"init.failed.title"				:	"AboutDialog - Error",
			"init.failed.text"				:	"Loading script [%s] failed."
		}).
		AddT("de", {
			"button.ok"                     :   "Ok",
			"button.cancel"                 :   "Abbruch",
			//
			"button.visitforum"             :   "Forum besuchen",
			"button.checkversion"           :   "Version prüfen",
			"button.update"                 :   "Aktualisieren",
			"button.updateall"              :   "Aktualisieren (alle)",
			"button.openlog"                :   "Log-Datei öffnen",
			"button.prepareupload"          :   "Upload vorbereiten",
			"button.updatemd5"              :   "MD5 aktualisieren",
			"button.showdetails"            :   "Details anzeigen",
			"button.archive"                :   "Archivieren",
			"button.rename"                 :   "Umbenennen",
			"button.delete"                 :   "Löschen",
			"button.exit"                   :   "Beenden",
			//
			"req.confirm_operations"        :   "Bestätigung für Aktionen anfordern",
			//
			"req.delete.title"              :   "Skript löschen",
			"req.delete.text"               :   "Das folgende Skript wirklich löschen?\n\nName:\n    %s\nDatei:\n    %s",
			//
			"req.rename.title"              :   "Skript umbenennen",
			"req.rename.text"               :   "Dieses Skript wirklich umbenennen?\n\nSkriptname:\n    %s\nDateiname:\n    %s",
			"req.rename_err.title"          :   "Skript umbenennen - Fehler",
			"req.rename_err.text"           :   "Umbenennen fehlgeschlagen!\n\nEs wurde kein gültiger Name gegeben oder die Datei existiert bereits.",
			//
			"req.update.title"              :   "Skript aktualisieren",
			"req.update.text"               :   "Dieses Skript wirklich aktualisieren?\n\nSkriptname:\n    %s\nDateiname:\n    %s",
			//
			"req.update_all.title"          :   "Skripte aktualisieren",
			"req.update_all.text"           :   "Du bist dabei, alle Skripte zu aktualisieren.\n\n"+
												"Keine Sorge, der Vorgang ist sicher! Skripte, die von dir geändert oder modifiziert wurden, "+
												"werden nicht automatisch aktualisiert.\nAlle Skript-Konfigurationen bleiben erhalten.",
			//
			"req.details.title"             :   "Skript-Details",
			//
			"req.archive_succeeded.title"   :   "Skript archivieren",
			"req.archive_succeeded.text"    :   "Archivierung des Skripts [%s] erfolgreich!",
			"req.archive_err.title"         :   "Skript archivieren - Fehler",
			"req.archive_err.text"          :   "Archivierung des Skripts [%s] fehlgeschlagen!",
			//
			"req.updatemd5.title"           :   "Hash aktualisieren",
			"req.updatemd5.text"            :   "Den MD5 Hash dieses Skripts wirklich aktualisieren?\n\nSkriptname:\n    %s\nDateiname:\n    %s",
			"req.updatemd5_succeeded.text"  :   "Aktualisierung des MD5 Hashwertes des Skripts [%s] erfolgreich!",
			"req.updatemd5_err.title"       :   "Skript archivieren - Fehler",
			"req.updatemd5_err.text"        :   "Die Aktualisierung des MD5 Hashwertes des Skripts [%s] ist fehlgeschlagen!",
			//
			"req.prepare_succeeded.title"   :   "Skript zum Upload vorbereiten",
			"req.prepare_succeeded.text"    :   "Vorbereitung des Skripts zum Upload [%s] erfolgreich!",
			"req.prepare_err.title"         :   "Skript zum Upload vorbereiten - Fehler",
			"req.prepare_err.text"          :   "Die Vorbereitung des Skripts zum Upload [%s] ist fehlgeschlagen!",
			//
			"words.name"                    :   "Name",
			"words.description"             :   "Beschreibung",
			"words.version"                 :   "Version",
			"words.resourceurl"             :   "Url der Ressource",
			"words.modified"                :   "modifiziert",
			"words.modified_yes"            :   "*** modifiziert ***",
			"words.modified_no"             :   "nicht modifiziert",
			"words.modified_unknown"        :   "unbekannt",
			"words.unavailable"             :   "<nicht verfügbar>",
			//
			"init.failed.title"             :   "Info-Dialog - Fehler",
			"init.failed.text"              :   "Das Laden des Skripts [%s] ist fehlgeschlagen."
		});
	///////////////////////////////////////////////////////////////////////////
	this.buttons	=	t("button.visitforum |"+
						"button.checkversion + button.update + button.updateall + button.openlog |"+
						"button.prepareupload + button.updatemd5 + button.showdetails |"+
						"button.archive + button.rename + button.delete |"+
						"button.exit");
	this.abuttons	= this.buttons.replace(/\+/g,"|").split("|");
}
///////////////////////////////////////////////////////////////////////////////
var RES_UPDATE_FOUND = 1;
var RES_UPDATED = 2;
var RES_UPTODATE = 4;
var RES_UPDATE_UNSUPPORTED = 8;
var RES_STATUS_FAILED = 16;
var RES_UPDATE_FAILED = 32;
var RES_UNKNOWN = 1024;
var RES_MORERECENT = 2048;
var RES_MODIFIED = 4096;

var ERR_RES_NORESURL		= 110;
var ERR_RES_NOVERSION		= 120;
var ERR_RES_NOVERSIONS		= 130;
var ERR_RES_NOVERSIONDOWN	= 140;

var ERR_FILE_NOT_FOUND = 210;
var ERR_BAD_FILETYPE = 215;
var ERR_BAD_XMLRESPONSE = 220;
var ERR_BAD_HTTPSTATUS = 230;
var ERR_BAD_XMLHTTP = 240;
var ERR_UID_MISMATCH = 250;
var ERR_MISSING_ARCFILE = 260;

var ERRMSGS = [];
ERRMSGS[ERR_RES_NORESURL]		= "Missing resource url in script";
ERRMSGS[ERR_RES_NOVERSION]		= "Missing version information in script";
ERRMSGS[ERR_RES_NOVERSIONS]		= "No downloads found for script";
ERRMSGS[ERR_RES_NOVERSIONDOWN]	= "No version string in download details";
ERRMSGS[RES_MORERECENT]			= "The local script is more recent";
ERRMSGS[RES_MODIFIED]			= "The local script has been modified";

ERRMSGS[ERR_FILE_NOT_FOUND]		= "Script file not found";
ERRMSGS[ERR_BAD_FILETYPE]		= "Unsupported file/script-type";
ERRMSGS[ERR_BAD_XMLRESPONSE]	= "Resource parsing error";
ERRMSGS[ERR_BAD_HTTPSTATUS]		= "Downloading resource failed";
ERRMSGS[ERR_BAD_XMLHTTP]		= "No XMLHttp object available";
ERRMSGS[ERR_UID_MISMATCH]		= "Unique script id mismatch";

///////////////////////////////////////////////////////////////////////////////
function DOResourceUpdater(){
	this.fso = new ActiveXObject("Scripting.FileSystemObject");
	this.interactive = false;
	this.showResults = false;
	this.force = false;
	this.win = null;
	this.progress = null;
	///////////////////////////////////////////////////////////////////////////////
	this.OpenProgressDialog = function ( win, title, numFiles){
		var progress = DOpus.Create.Command.Progress;
		progress.delay = false;
		progress.abort = false;
		progress.owned = true;
		progress.full = true;
		//progress.bytes = true;
		progress.Init(win);
		progress.SetTitle(title);
		progress.Show();
		progress.AddFiles(numFiles);
		return progress;
	}
	///////////////////////////////////////////////////////////////////////////
	this.OpenLog = function(){
		out.trc("OpenLog():",1);
		var cmd = DOpus.Create.Command();
		var logFile = DOpus.FSUtil.Resolve(Script.config["Log.ToFile.Path"]);
		out.put("Opening file ["+logFile+"]");
		if (!DOpus.FSUtil.Exists(logFile)){
			out.err("File not found");
			out.trc("",-1);
			if (this.interactive)
				Request("The log file ["+logFile+"] is missing!",
				t("button.ok"),"Open Log - Error","error",this.win);
			return false;
		}
		cmd.RunCommand(logFile);
		out.trc("",-1);
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.Visit = function( scriptFile ){
		out.trc("Visit():",1);
		out.put("File: " + scriptFile);
		var cmd = DOpus.Create.Command();
		var res = ResParser.Load(String(scriptFile)) //todo result check / exception
		out.put("Url: " + res.url);
		if (res.url.search("https?://")==-1){
			out.err("Script has no url set");
			if (this.interactive)
				Request(t("req.visit_forum_err.text"),t("button.ok"),t("req.visit_forum_err.title"),"error",this.win);
			out.trc("",-1);
			return false;
		}
		out.put("Opening url ["+res.url+"]");
		cmd.RunCommand(res.url);
		out.trc("",-1);
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.UpdateCheck = function(resFilePath, showProgress){
		var resFileName = String(resFilePath).getFilePart()
		out.put("UpdateCheck(): \""+resFileName+"\":",1);
		try{
			if (showProgress == undefined) showProgress = this.progress;
			if (this.progress && showProgress){
				this.progress = this.OpenProgressDialog(this.win, "UpdateCheck", 1);
				//this.progress && this.progress.SetPercentProgress(33);
			}
			//progress.SetTitle("MyStatus!");

			var status = this.GetStatus(resFilePath, this.interactive, this.updateOption);
			if (this.progress && showProgress){
				//this.progress && this.progress.StepFiles(1);
				this.progress && this.progress.Hide();
			}
			out.put("",-1);
			return status;
		} catch(e){
			out.put(e,-1);
			throw e;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.Update = function(resFilePath, showProgress){
		var resFileName = String(resFilePath).getFilePart();
		out.put("Update(): \""+resFileName+"\":",1);
		if (showProgress == undefined) showProgress = this.progress;
		if (this.progress && showProgress){
			this.progress = this.OpenProgressDialog(this.win, "Update", 1);
		}
		try{
			//non-interactive, no-update btn
			var status = this.GetStatus(resFilePath, false, false);
			if (status.error || !status.update){
				if (this.interactive){
					this.progress && this.progress.SetStatus(t("progress.title"));
					Request(t("req.update_err.text",resFileName,status.msg),t("button.ok"),t("req.update_err.title"),"error",this.win);
				}

				if (this.progress && showProgress){
					//this.progress && this.progress.StepFiles(1);
					this.progress && this.progress.Hide();
				}
				out.put("",-1);
				return status;
			}

			var proceed = true;
			if (status.code & RES_MODIFIED) {
				proceed = false;
				if (this.force) proceed = true;
				if (!proceed && this.interactive){
					this.progress && this.progress.SetStatus(t("progress.title"));
					if (Request(t("req.update_confirm.text", resFileName, status.raw.curRes.version, status.raw.versions[0].version),
								t("req.update_confirm.yes|button.cancel"),
								t("req.update_confirm.title"),"question",this.win))
						proceed = true;
				}
				out.put("Update confirmed/forced: "+proceed);
			}

			if (proceed)
				this.ReplaceWithDownload( status.raw.curRes, status.raw.versions[0] );

			if (this.progress && showProgress){
				//this.progress && this.progress.StepFiles(1);
				this.progress && this.progress.Hide();
			}
			out.put("",-1);
			return status;
		} catch(e){
			out.xit("Update(): " + e.message);
			if (this.interactive)
				Request(t("req.update_failure.text",e.message),t("button.ok"),t("req.update_err.title"),"error",this.win);
			out.put("",-1);
			throw e;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.ArchiveScript = function(script, throwEx){
		out.put("ArchiveScript():",1);
		out.dmp("TypeIn : " + typeof script);
		if (throwEx==undefined) throwEx = false;
		try{
			if (typeof script == "string"){
				out.dmp("Turning string into resource-object..");
				script = ResParser.Load(script) //todo result check / exception
			}

			var arcFileName = script.fileName;
			if (script.version)arcFileName += '_v'+script.version
			arcFileName += '_'+ new Date().formatDate().replace(/\./g,'');
			arcFileName += '_'+ new Date().formatTime().replace(/\:/g,'');
			if (ResParser.IsPackage(script.fileName))
				arcFileName += ".osp";
			else
				arcFileName += ".txt";
			var arcFolderPath = DOpus.FSUtil.Resolve(Script.config["Archive.Path"]);
			var arcFilePath = arcFolderPath+"\\"+arcFileName;
			FSMagic.CreatePath(arcFolderPath);
			out.put("Source  file: " + script.filePath);
			out.put("Archive file: " + arcFilePath);
			this.fso.CopyFile(script.filePath, arcFilePath);
			if (!this.fso.FileExists(arcFilePath)){
				out.xit("Archived file is missing, archiving failed");
				out.put("",-1);
				if (throwEx) throw new Error(ERR_MISSING_ARCFILE, ERRMSGS[ERR_MISSING_ARCFILE]);
				return false;
			}
			out.put("",-1);
			return true;
		}
		catch(e){
			out.err(e);
			out.put("",-1);
			if (throwEx) throw e;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.ReplaceWithDownload = function(curResource, version){
		out.trc("ReplaceWithDownload():",1);
		this.progress && this.progress.SetStatus("Downloading update..");
		try{
			var tmpFile = FSMagic.GetTmpFileName("DO.ScriptDownload.", "."+version.extension);
			this.DownloadToFile(version.url, tmpFile.fullname, true); //version.package);
			var newScript = ResParser.Load(tmpFile.fullname);
			out.put("Current script UID: " + curResource.uid);
			out.put("Update  script UID: " + newScript.uid);
			if (curResource.uid && (newScript.uid != curResource.uid))
				throw new Error(ERR_UID_MISMATCH,ERRMSGS[ERR_UID_MISMATCH]);
			this.ArchiveScript(curResource, true); //throw

			var newFilePath = curResource.filePath.getParentPart();
			var newFileName = version.fileName;
			if (curResource.package == version.package){ //same type?
				out.put("Same type of script resource");
				if (!curResource.package && Script.Config["PreserveName.SingleScript"])
					newFileName = curResource.fileName.rTrim(".txt").getBaseName()+"."+version.extension; //use old script basename
				if (curResource.package && Script.Config["PreserveName.Package"])
					newFileName = curResource.fileName; //use old package basename
			} else {
				out.put("Different types of script resources, basename: " + curResource.fileName.replace("\\.txt$","").getBaseName());
				if (Script.Config["PreserveName.TypeMismatch"]) //use old resource name if script vs. package?
					newFileName = curResource.fileName.rTrim(".txt").getBaseName()+"."+version.extension; //use old basename
			}
			newFilePath += "\\"+newFileName;

			out.put("Tmp resource file: " + tmpFile.fullname);
			out.put("New resource file: " + newFilePath);
			this.fso.DeleteFile(curResource.filePath);
			this.fso.MoveFile(tmpFile.fullname, newFilePath);

			out.inf("Update successful");
			if (this.interactive){
				Request(t("req.update_success.text" ),t("button.ok"),t("req.update_success.title"),"info",this.win);
			}

			out.trc("",-1);
		} catch(e){
			out.xit("ReplaceWithDownload(): " + e.message);
			out.trc("",-1);
			throw e;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetStatus = function(resFilePath, interactive, updateOption){
		out.trc("GetStatus():",1);
		var resFileName = String(resFilePath).getFilePart();
		this.progress && this.progress.SetName(resFileName);
		this.progress && this.progress.SetStatus("Analyzing local script file..");
		this.progress && this.progress.SetFileSize(100);
		this.progress && this.progress.StepBytes(0);
		if (interactive == undefined) interactive=this.interactive;
		if (updateOption == undefined) updateOption=this.updateOption;
		var statusRaw	= null;
		var status		= {code:RES_UNKNOWN, raw:statusRaw, error:null, update:false, msg:""};
		var msg			= "", tmpMsg="";
		try{
			statusRaw = this.GetStatusRaw(resFilePath);
			this.progress && this.progress.StepBytes(30);
			status.raw = statusRaw;
			status.code = statusRaw.code;
			if (status.code & RES_UPDATE_FOUND &&
				!(status.code & RES_MORERECENT) &&
					!(status.code & RES_UPTODATE)){
				status.update = true;
				(tmpMsg=t("reg.status.updatefound",statusRaw.versions[0].version)) && out.inf(tmpMsg) && (msg+="    "+tmpMsg+"\n");
			}
			else
				(tmpMsg=t("reg.status.updatenotfound")) && out.put(tmpMsg) && (msg+="    "+tmpMsg+"\n");

			if (status.code & RES_UPTODATE)
				(tmpMsg=t("reg.status.isuptodate")) && out.put(tmpMsg) && (msg+="    "+tmpMsg+"!\n");
			if (status.code & RES_MORERECENT)
				(tmpMsg=t("reg.status.ismorerecent")) && out.wrn(tmpMsg) && (msg+=t("req.status.part.warning", tmpMsg));
			if (status.code & RES_MODIFIED)
				(tmpMsg=t("reg.status.ismodified")) && out.wrn(tmpMsg) && (msg+=t("req.status.part.warning", tmpMsg));

			if (interactive){
				this.progress && this.progress.StepBytes(60);
				this.progress && this.progress.SetStatus(t("progress.title"));
				this.progress && this.progress.Hide();
				msg=t("req.status.part.upper", resFileName, status.raw.curRes.version, msg);
				var updateNow = Request(msg,(this.updateOffer&&status.update?t("button.updatenow | button.cancel"):t("button.ok")),t("req.status.title"),"info",this.win);
				if (updateNow && this.updateOffer && status.update){
					msg = "";
					this.progress && this.progress.Show();
					this.progress && this.progress.StepBytes(70);
					this.ReplaceWithDownload( status.raw.curRes, status.raw.versions[0]);
				}
			}
			status.msg = msg;
			out.trc("",-1);
			return status;
		} catch(e){
			status.raw = statusRaw;
			status.error = e;
			if (e.number>200){
				(tmpMsg="Failure: "+e.message) && out.err(tmpMsg) && (msg+=tmpMsg+"!\n");
				status.code = RES_STATUS_FAILED;
			} else
			if (e.number>100){
				(tmpMsg="Unsupported: "+e.message) && out.err(tmpMsg) && (msg+=tmpMsg+"!\n");
				//DOpus.Output("UNsupported message:" +e.message);
				status.code = RES_UPDATE_UNSUPPORTED;
			} else{
				(tmpMsg="Unknown error: "+e.message) && out.err(tmpMsg) && (msg+=tmpMsg+"!\n");
				throw e;
			}

			status.msg = msg;
			if (interactive){
				this.progress && this.progress.SetStatus(t("progress.title"));
				msg=t("req.status_err.part.upper", resFileName, msg);
				Request(msg,t("button.ok"),t("req.status_err.title"),"error",this.win);
			}
			out.trc("",-1);
			return status;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetStatusRaw = function( resFilePath ){
		out.trc("GetStatusRaw():",1);
		resFilePath = new String(resFilePath);
		var status = {code:RES_UNKNOWN, curRes:null, versions:[]};

		if (!resFilePath.getParentPart()){
			var parent = DOpus.FSUtil.Resolve("/dopusdata/script addins");
			resFilePath = parent + "\\" + resFilePath;
		}

		try{
			if (!this.fso.FileExists(resFilePath))
				throw new Error(ERR_FILE_NOT_FOUND, ERRMSGS[ERR_FILE_NOT_FOUND]);

			var res = ResParser.Load(resFilePath) //todo
			status.curRes = res;
			if (!res.url)
				throw new Error(ERR_RES_NORESURL, ERRMSGS[ERR_RES_NORESURL]);

			if (!res.version)
				throw new Error(ERR_RES_NOVERSION, ERRMSGS[ERR_RES_NOVERSION]);

			this.progress && this.progress.SetStatus("Searching for updates..");
			var versions = this.GetAvailableVersions(res);
			if (!versions.length)
				throw new Error(ERR_RES_NOVERSIONS, ERRMSGS[ERR_RES_NOVERSIONS]);

			status.versions = versions;
			out.dmp("Script version: "+status.curRes.version);
			out.dmp("Latest version: "+status.versions[0].version);

			if (status.versions[0].version == 0)
				throw new Error(ERR_RES_NOVERSIONDOWN, ERRMSGS[ERR_RES_NOVERSIONDOWN]);

			switch (ResParser.Compare(status.curRes.version, status.versions[0].version, {lexicographical:true, zeroExtend:true})){
				case 1: //curRes lower
					status.code += RES_UPDATE_FOUND; break;
				case 0: //equal
					status.code += RES_UPTODATE; break;
				case -1: //curRes more recent
					status.code += RES_MORERECENT; break;
			}

			if (res.modified)
				status.code += RES_MODIFIED;

		} catch(e){
			out.trc("",-1);
			throw e;
		}
		out.trc("",-1);
		return status;
	}
	///////////////////////////////////////////////////////////////////////////
	this.UpdateCheckAll = function( scriptsFolderPath ){
		this.PrintHeader("ScriptWizard - Check ALL");
		out.put("UpdateCheckAll():",1);
		var scriptsFolder = this.fso.GetFolder(scriptsFolderPath);
		var fEnum = new Enumerator(scriptsFolder.files);
		if (this.progress)
			this.progress = this.OpenProgressDialog(this.win, "ScriptWizard Check - All", scriptsFolder.files.count);

		var results = { updateable:0, uptodate:0, updated:0, unsupported:0, morerecent:0, failed:0, na:0};
		for (var count=0; !fEnum.atEnd(); fEnum.moveNext()){
			if (!ResParser.ValidateExtension(fEnum.item(), false)){
				this.progress && this.progress.StepFiles(1);
				continue;
			}
			count++;
			var status = this.UpdateCheck(fEnum.item(), false);
			this.CountResults(results, status);
			this.progress && this.progress.StepFiles(1);
		}
		out.put("").put("",-1);
		this.PrintResults(results, count);
		this.progress && this.progress.Hide();
		return COMMAND_SUCCEEDED;
	}
	///////////////////////////////////////////////////////////////////////////
	this.UpdateAll = function( scriptsFolderPath ){
		this.PrintHeader("ScriptWizard - ALL");
		out.put("UpdateAll():",1);
		var scriptsFolder = this.fso.GetFolder(scriptsFolderPath);
		if (this.progress)
			this.progress = this.OpenProgressDialog(this.win, "ScriptWizard - All", scriptsFolder.files.count);
		var fEnum = new Enumerator(scriptsFolder.files);
		var results = { updateable:0, uptodate:0, updated:0, unsupported:0, morerecent:0, failed:0, na:0};
		for (var count=0; !fEnum.atEnd(); fEnum.moveNext()){
			if (!ResParser.ValidateExtension(fEnum.item(), false)){
				this.progress && this.progress.StepFiles(1);
				continue;
			}
			count++;
			var status = this.Update(fEnum.item(), false);
			this.CountResults(results, status);
			this.progress && this.progress.StepFiles(1);
		}
		out.put("").put("",-1);
		this.PrintResults(results, count);
		this.progress && this.progress.Hide();
		return COMMAND_SUCCEEDED;
	}
	///////////////////////////////////////////////////////////////////////////
	this.PrintHeader = function(text){
		out.put("--------------------------------------------------------------------------------");
		out.put(text + " - " + new Date().formatDate()+ " " + new Date().formatTime());
		out.put("--------------------------------------------------------------------------------");
	}
	///////////////////////////////////////////////////////////////////////////
	this.CountResults = function(results, status){
		if		(status.code &  RES_UPDATE_FOUND)		results.updateable++;
		else if	(status.code &  RES_UPTODATE)			results.uptodate++;
		else if	(status.code &  RES_MORERECENT)			results.morerecent++;
		else if	(status.code &  RES_UPDATED)			results.updated++;
		else if	(status.code == RES_UPDATE_UNSUPPORTED)	results.unsupported++;
		else if	(status.code == RES_STATUS_FAILED)		results.failed++;
		else {											results.na++; }
	}
	///////////////////////////////////////////////////////////////////////////
	this.PrintResults = function(results, count){
		out.put("Results",1);
		out.put("Updateable  : " + results.updateable);
		out.put("Uptodate    : " + results.uptodate);
		out.put("MoreRecent  : " + results.morerecent);
		out.put("Updated     : " + results.updated);
		out.put("Unsupported : " + results.unsupported);
		out.put("Failed      : " + results.failed);
		out.put("?           : " + results.na,-1);
		out.put(t("req.results.total", count));
		out.put("");
		if (this.showResults){
			var msg = t("req.results.header")+
				t("req.results.updateable", results.updateable)+
				t("req.results.uptodate", results.uptodate)+
				t("req.results.unsupported", results.unsupported)+
				t("req.results.failed", results.failed)+
				t("req.results.na", results.na)+
				t("req.results.total", count);

			Request(msg,t("button.ok"),t("req.results.title"),"info",this.win);
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetAvailableVersions = function( resource, attemptNum ){
		attemptNum = attemptNum || 1;
		out.trc("GetAvailableVersions():",1);
		try{
			var down = this.Download(resource.url);
			var doRTP = new DOResourceThreadParser();
			var versions = doRTP.GetResourceDownloads(down.content, resource);
			out.trc("",-1);
			return versions;
		} catch(e){
			//scriptwizard alternative download location #1
			out.wrn("Error: " + attemptNum);
			if (resource.uid == "D4072BDA-B049-4A11-8B40-266E083D6F2D" && attemptNum<3){ //F
				//alternative download location for sw #1
				if (attemptNum==1) resource["url"] = "http://www.steax.net/dopus/scriptwizard.htm";
				//alternative download location for sw #2
				if (attemptNum==2) resource["url"] = "http://www.steax.net/dopus/scriptwizard.htm";
				out.wrn("ScriptWizard update (attempt "+attemptNum+") failed.");
				out.wrn("Trying alternative download location: " + resource.url);
				attemptNum++;
				try{
					return this.GetAvailableVersions( resource, attemptNum);
				}
				catch (e){
					out.trc("",-1);
					throw e;
				}
			}
			out.trc("",-1);
			throw e;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.Download = function(url, binary){
		out.trc("Download():",1)
		if (!binary) binary = false;
		var result = { status:200, content:""};
		var versions = ['MSXML2.XMLHTTP', 'Microsoft.XMLHTTP','MSXML.XMLHTTP', 'Msxml2.XMLHTTP.7.0',
		'Msxml2.XMLHTTP.6.0','Msxml2.XMLHTTP.5.0',
		'Msxml2.XMLHTTP.4.0','MSXML2.XMLHTTP.3.0','MSXML2.XMLHTTP','Microsoft.XMLHTTP',
		'WinHttp.WinHttpRequest','WinHttp.WinHttpRequest.5.1','MSXML2.ServerXMLHTTP'];
		try{
			for (var i=0;i<versions.length; i++){
				try{
					var objHTTP = new ActiveXObject (versions[i]);
					if (objHTTP){
						out.dmp("Using HTTPObject ["+versions[i]+"]");
						break;
					}
				} catch(e){};
			}

			if (!objHTTP)
				throw new Error(ERR_BAD_XMLHTTP, ERRMSGS[ERR_BAD_XMLHTTP]);

			//objHTTP.OverrideMimeType('text/plain; charset=x-user-defined');
			//objHTTP.responseType = 'arraybuffer';

			out.dmp("URL: " + url);
			out.dmp("Binary: " + binary);

			objHTTP.open("GET", url, false);
			objHTTP.send();
			while((objHTTP.readyState != 4) && (objHTTP.readyState != 'complete')) {
				out.dmp("    Waiting for response..");
				DOpus.Delay(100);
			}
			out.dmp("    HTTPStatus : "+objHTTP.Status);
			out.dmp("    ResponseTextLen: "+objHTTP.ResponseText.length);
			//out.dmp("    ResponseBodyLen: "+objHTTP.ResponseBody.length);

			if (200 != objHTTP.Status){
				var errTxt = ERRMSGS[ERR_BAD_HTTPSTATUS]+ " - url ["+url+"]";
				if (objHTTP.status==404) errTxt += ", url not found";
				else errTxt += ", http-status ["+objHTTP.status+"]";
				throw new Error(ERR_BAD_HTTPSTATUS, errTxt);
			}

			result.content = objHTTP.ResponseText;
			if (binary){
				//result.content = this.BinaryToString(objHTTP.ResponseBody);
				out.dmp("Using response body..");
				result.content = objHTTP.ResponseBody;
			} else {

			}

			out.trc("",-1);
			return result;
		} catch(e){
			out.xit("Download failed: " +e);
			out.trc("",-1);
			throw e;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.DownloadToFile = function(url, filePath, binary) {
		function ContainsSurrogatePair(str) {
			return /[\uD800-\uDFFF]/.test(str);
		}
		out.trc("DownloadToFile():",1);
		out.put("Download: "+url);
		out.put("FilePath: "+filePath);
		try{
			var down = this.Download(url, binary);

			if (binary){
				var objADOStream = new ActiveXObject("ADODB.Stream");
				objADOStream.Open();
				objADOStream.Type = 1; //adTypeBinary
				//objADOStream.Type = 2; //adTypeText
				objADOStream.Write(down.content);
				objADOStream.Position = 0; //set the stream position to the start
				objADOStream.SaveToFile(filePath, 2); //create & overwrite
				objADOStream.Close();
			} else {
				try{
					out.dmp("BOM: " + down.content.substring(0,5));
					out.dmp("UNI: " + ContainsSurrogatePair(down.content));
					out.dmp("Trying unicode save..");
					var file = this.fso.OpenTextFile( filePath, 2, true, -1); //unicode
					file.Write(""+down.content);
					file.Close();
				} catch(e){
					file.Close();
					out.dmp("    failed");
					out.dmp("Trying ascii save..");
					var file = this.fso.OpenTextFile( filePath, 2, true, 0); //ascii
					file.Write(""+down.content);
					file.Close();
				}
			}
			out.trc("",-1);
			return true;
		} catch(e){
			out.xit("DownloadToFile(): " +e.message);
			out.trc("",-1);
			throw e;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.BinaryToString = function(Binary, CharSet){
		var adTypeText = 2;
		var adTypeBinary = 1;
		//Create Stream object
		var BinaryStream = new ActiveXObject("ADODB.Stream");
		//Specify stream type - we want To save text/string data.
		BinaryStream.Type = adTypeBinary
		//Open the stream And write text/string data To the object
		BinaryStream.Open();
		BinaryStream.Write(Binary);
		//Change stream type To binary
		BinaryStream.Position = 0;
		BinaryStream.Type = adTypeText;
		//Specify charset For the source text (unicode) data.
		if (CharSet != undefined)
			BinaryStream.CharSet = CharSet;
		else
			//BinaryStream.CharSet = "us-ascii";
			BinaryStream.CharSet = "utf-8";
		//open the stream and get binary data from the object
		return BinaryStream.ReadText();
	}
	///////////////////////////////////////////////////////////////////////////
	Translator.
		AddT("en", {
			"button.ok"						: "Ok",
			"button.cancel"					: "Cancel",

			"progress.title"				: "Waiting for user input..",

			"button.yesupdate"				: "Yes, update!",
			"button.updatenow"				: "Update now!",

			"req.status_err.title"			: "Script Status - Error",
			"req.status_err.part.upper"		: "Scriptfile:\n    %s\n\nResult:\n%s",

			"req.status.title"				: "Script Status",
			"req.status.part.upper"			: "Scriptfile:\n    %s (v%s)\n\nResult:\n%s",
			"req.status.part.warning"		: "\nWARNING:\n    %s!\n",

			"reg.status.updatefound"		: "Update found (v%s)",
			"reg.status.updatenotfound"		: "No update available",
			"reg.status.isuptodate"			: "The local script is uptodate",
			"reg.status.ismorerecent"		: "Local script is more recent",
			"reg.status.ismodified"			: "Local script has been modified",

			"req.visit_forum_err.title"		: "Visit Forum - Error",
			"req.visit_forum_err.text"		: "Sorry, this script has no forum url set!\n\nPlease tell the script author to fix this, thanks! o)",

			"req.update_err.title"			: "Update - Error",
			"req.update_failure.text"		: "Update failed!\n\n%s",
			"req.update_err.text"			: "Scriptfile:\n    %s\n\nResult:\n%s",

			"req.update_confirm.title"		: "Update - Confirm",
			"req.update_confirm.text"		: "Scriptfile:\n    %s (v%s)\n\nThe local script has been modified! Confirmation required to update to v%s.",
			"req.update_confirm.yes"		: "Yes, update!",

			"req.update_success.title"		: "Update - Succeeded",
			"req.update_success.text"		: "Update successful!",

			"req.results.title"				: "ScriptWizard - All Scripts",
			"req.results.header"			: "Results:\n\n",
			"req.results.updateable"		: "    Updateable :  %s\n        (intentionally skipped, these were modified e.g.)\n",
			"req.results.uptodate"			: "    Uptodate :  %s\n        (no later versions found for these)\n",
			"req.results.updated"			: "    Updated :  %s\n        (updated scripts)\n",
			"req.results.unsupported"		: "    Unsupported :  %s\n        (scripts not supporting updates)\n",
			"req.results.failed"			: "    Failed :  %s\n        (scripts which possibly can be updated, but failed)\n",
			"req.results.na"				: "    Unknown :  %s\n        (unknown errors while updating)\n\n",
			"req.results.total"				: "Scripts in total: %s"
		}).
		AddT("de", {
			"button.ok"                     : "Ok",
			"button.cancel"                 : "Abbruch",

			"progress.title"                : "Warte auf Benutzereingabe..",

			"button.yesupdate"              : "Ja, aktualisieren!",
			"button.updatenow"              : "Jetzt aktualisieren!",

			"req.status_err.title"          : "Skript-Status - Fehler",
			"req.status_err.part.upper"     : "Skriptdatei:\n    %s\n\nErgebnis:\n%s",

			"req.status.title"              : "Skript-Status",
			"req.status.part.upper"         : "Skriptdatei:\n    %s (v%s)\n\nErgebnis:\n%s",
			"req.status.part.warning"       : "\nWARNUNG:\n    %s!\n",

			"reg.status.updatefound"        : "Update gefunden (v%s)",
			"reg.status.updatenotfound"     : "Kein Update verfügbar",
			"reg.status.isuptodate"         : "Das lokale Skript ist aktuell",
			"reg.status.ismorerecent"       : "Das lokale Skript ist neuer",
			"reg.status.ismodified"         : "Das lokale Skript wurde modifiziert",

			"req.visit_forum_err.title"     : "Forum besuchen - Fehler",
			"req.visit_forum_err.text"      : "Sorry, das Skript enthält keine Forum-URL!\n\nBitte kontaktiere den Autor und bitte ihn, dies zu korrigieren; danke! o)",

			"req.update_err.title"          : "Update - Fehler",
			"req.update_failure.text"       : "Update fehlgeschlagen!\n\n%s",
			"req.update_err.text"           : "Skriptdatei:\n    %s\n\nErgebnis:\n%s",

			"req.update_confirm.title"      : "Update - Bestätigung",
			"req.update_confirm.text"       : "Skriptdatei:\n    %s (v%s)\n\nDas lokale Skript wurde modifiziert! Bestätigung erforderlich zur Aktualisierung auf v%s.",
			"req.update_confirm.yes"        : "Ja, aktualisieren!",

			"req.update_success.title"      : "Update - erfolgreich",
			"req.update_success.text"       : "Update erfolgreich!",

			"req.results.title"             : "ScriptWizard - Alle Skripte",
			"req.results.header"            : "Ergebnisse:\n\n",
			"req.results.updateable"        : "    Update vorhanden :  %s\n        (übersprungen, weil z.B. das lokale Skript modifiziert wurde)\n",
			"req.results.uptodate"          : "    Aktuell :  %s\n        (keine neueren Versionen gefunden)\n",
			"req.results.updated"           : "    Aktualisiert :  %s\n        (aktualisierte Skripte)\n",
			"req.results.unsupported"       : "    Nicht unterstützt :  %s\n        (Skripte unterstützen keine Updates)\n",
			"req.results.failed"            : "    Fehlgeschlagen :  %s\n        (Skripte können evtl. aktualisiert werden, das Update schlug aber fehl)\n",
			"req.results.na"                : "    Unbekannt :  %s\n        (unbekannte Fehler während des Updates)\n\n",
			"req.results.total"             : "Gesamtanzahl der Skripte: %s"
		});
}
///////////////////////////////////////////////////////////////////////////////
function DOResourceThreadParser(){
	this.baseAddress = "http://resource.dopus.com/";
	///////////////////////////////////////////////////////////////////////////
	this.GetResourceDownloads = function( xmlText, resource2Update ){
		out.trc("GetResourceDownloads():",1);
		var xmlDoc = this.GetXMLDoc();
		xmlDoc.loadXML(this.FilterXML(xmlText));
		if (xmlDoc.parseError.errorCode != 0) {
			var myErr = xmlDoc.parseError;
			var lines = xmlText.split("\n");
			out.err("Error: " + myErr.reason);
			out.err("    Line#: " + myErr.line);
			out.err("    Line : " + lines[myErr.line-1]);
			throw new Error(ERR_BAD_XMLRESPONSE,
					ERRMSGS[ERR_BAD_XMLRESPONSE]+" - reason ["+myErr.reason+"], line# ["+
					myErr.line+"], line ["+lines[myErr.line-1]+"]");
		}

		//remove txt extension from filename of resource 2 update for easier matching
		var fileName = resource2Update.fileName.toLowerCase().replace(/\.txt$/gi,'');

		var resources = this.GetResourcesFromXMLDoc( xmlDoc, fileName);
		resources = this.ProcessResources(resources, resource2Update);
		var resVersions = this.GetVersionsOfBestMatchingResource(resources);

		out.dmp("",-1);
		out.trc("",-1);
		return resVersions;
	}
	///////////////////////////////////////////////////////////////////////////
	this.ProcessResources = function( resources, resource2Update){
		out.trc("ProcessResources():",1)
		for(resourceName in resources){
			var resource = resources[resourceName];
			out.dmp("Resource ["+resourceName+"]:",1)
			for(var v=0;v<resource.versions.length;v++){
				out.dmp("Version ["+resource.versions[v].version+"]:");
				out.dmp("    Url ["+resource.versions[v].url+"]");
				var url = resource.versions[v].url;
				url = url.substring(2); //removing "./"
				url = resource2Update.url.replace( new RegExp("(https?://.*/)(.*)"),"$1"+url);
				out.dmp("    New ["+url+"]");
				resource.versions[v]["url"] = url;
			}
			out.dmp("",-1)
		}
		out.trc("",-1)
		return resources;
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetVersionsOfBestMatchingResource = function( resources ){
		var bestMatchRes = null;

		var resourcesIndexed = [];
		for(resourceName in resources){
			resourcesIndexed[resourcesIndexed.length] = resources[resourceName];
		}

		if (resourcesIndexed.length)
			bestMatchRes = resourcesIndexed[0];

		//sort sub resources by best matching name (distance value)
		if (resourcesIndexed.length > 1){
			out.dmp("Sorting resources for best match");
			resourcesIndexed = resourcesIndexed.sort( function(a,b){ return b.distance - a.distance; } );
			bestMatchRes = resourcesIndexed[0];
		}

		var resVersions = [];
		if (bestMatchRes){
			if (resourcesIndexed.length > 1 && bestMatchRes.distance < 0.8){
				out.inf("Best matching resource name is too different, name ["+
					bestMatchRes.versions[0].fileName+"], distance ["+bestMatchRes.distance+"]");
				//DumpObject(bestMatchRes);
				//DumpObject(bestMatchRes.versions[0]);
			} else {
				if (resourcesIndexed.length == 1 && bestMatchRes.distance < 0.8)
					out.wrn("Resource name is very different, name ["+
					bestMatchRes.versions[0].fileName+"], distance ["+bestMatchRes.distance+"]");
				resVersions = bestMatchRes.versions;
				out.dmp("Best matching resource name: " + resVersions[0].fileName);
				//sort sub resource versions
				out.dmp("Versions found: " + resVersions.length);
				resVersions.versions = resVersions.sort(
					function(a,b){ return ResParser.Compare(a.version, b.version, {lexicographical:true, zeroExtend:true} ); }
				);
			}
		} else {
			out.dmp("No matching resource found");
		}
		return resVersions;
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetResourcesFromXMLDoc = function(xmlDoc, cleanFileNameOfResource2Update){
		var resources = [];
		var resourcesFound = 0;
		var ScriptVersion = function(){};
		var fileNodes = xmlDoc.selectNodes("(//div[@class='postbody'])[1]//dl[@class='file']/dt/a[@class='postlink']/../..");
		out.dmp("Downloads found: " + fileNodes.length,1);
		for(var f=0;f<fileNodes.length;++f){
			var ver = new DOResource();
			ver.fileName = fileNodes[f].selectSingleNode("dt/a[@class='postlink']").text;
			ver.extension = ResParser.ValidateExtension(ver.fileName, false);
			if (!ver.extension){
				out.inf("Unsupported resource, name ["+ver.fileName+"], type ["+ver.extension+"]");
				continue;
			}
			var node = fileNodes[f].selectSingleNode("dd/em");
			if (node) ver.desc = node.text;
			ver.details = fileNodes[f].selectSingleNode("dd[not(em)]").text;
			ver.size = this.ParseSize(ver.details);
			ver.version = this.ParseVersion(ver.desc);
			ver.url = fileNodes[f].selectSingleNode("dt/a[@class='postlink']/@href").text;
			//out.put("    XML : " + fileNodes[f].xml);
			ver.package = ResParser.IsPackage(ver.fileName);
			out.dmp("Name: " + ver.fileName);
			out.dmp("    Details: " + ver.details);
			out.dmp("    Desc: " + ver.desc);
			out.dmp("    Size: " + ver.size);
			out.dmp("    Vers: " + ver.version);

			var nameLow = ver.fileName.toLowerCase().replace(/\.txt$/gi,'');
			if (!resources[nameLow]){
				var distance = this.Distance(cleanFileNameOfResource2Update, nameLow).toFixed(4);
				out.dmp("    Resource registered, distance ["+distance+"]");
				resources[nameLow] = { distance:distance, versions:[] };
				resourcesFound++;
				//resources[resources.length] = resources[nameLow];
			} else {
				out.dmp("    Resource already registered");
			}
			var subResource = resources[nameLow];
			subResource.versions[subResource.versions.length] = ver;
		}
		out.dmp("Different resources found: " + resourcesFound);
		return resources;
	}
	///////////////////////////////////////////////////////////////////////////
	this.FilterXML = function(xmlText){
		xmlText = xmlText.replace(/<\!DOCTYPE.*?\>/,""); //get rid of dtd
		xmlText = xmlText.replace(/<html.*?\>/,"<html>"); //get rid of namespacing
		xmlText = xmlText.replace(/\&bull\;/g,''); //get rid of some entities
		xmlText = xmlText.replace(/\&raquo\;/g,'');
		xmlText = xmlText.replace(/\&nbsp\;/g,'');
		xmlText = xmlText.replace(/\&reg\;/g,'');
		xmlText = xmlText.replace(/\&copy\;/g,'');

		xmlText = xmlText.replace(/\&uuml\;/g,'ü');
		xmlText = xmlText.replace(/\&auml\;/g,'ä');
		xmlText = xmlText.replace(/\&ouml\;/g,'ö');
		xmlText = xmlText.replace(/\&middot\;/g,'.');

		//remove li and ul tags as they often don't match and site cannot be parsed
		xmlText = xmlText.replace(/<li.*?>/g,'');
		xmlText = xmlText.replace(/<\/li>/g,'');
		xmlText = xmlText.replace(/<ul.*?>/g,'');
		xmlText = xmlText.replace(/<\/ul>/g,'');

		//fix iframe attribute with no value // ..allowfullscreen>..
		xmlText = xmlText.replace(/allowfullscreen\>/g,'allowfullscreen="">');
		//fix unclosed meta-tags
		xmlText = xmlText.replace(/<meta.*?>/g,'');
		//fix leos faq link
		xmlText = xmlText.replace(/viewtopic\.php\?f\=11\&t\=4095/g,'');

		//xmlText = '<!ENTITY % HTMLlat1 PUBLIC  "-//W3C//ENTITIES Latin 1 for XHTML//EN" "xhtml-lat1.ent">' + xmlText;
		return xmlText;
	}
	///////////////////////////////////////////////////////////////////////////
	this.ParseSize = function(str){
		var re = new RegExp("\(\\d{1,3}\.?\\d{1,3}?\\s..?\)",'gi');
		var match = re.exec(str); if (match) return match[1]; return "";
	}
	///////////////////////////////////////////////////////////////////////////
	this.ParseVersion = function(str){
		var re = new RegExp("(\\d{1,3}(?:\\.\\d{1,3})?(?:\\.\\d{1,6})?)",'gi');
		var match = re.exec(str);
		if (match)
			return match[1];
		return "0";
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetXMLDoc = function(){
		out.trc("GetXMLDoc():",1);
		try {
			var xmlDoc = new ActiveXObject("MSXML2.DOMDocument.6.0");
			xmlDoc.async = false;
			xmlDoc.validateOnParse = true;
			xmlDoc.resolveExternals = false;
		}
		catch (e) {
			out.trc("",-1);
			throw e;
		}
		out.trc("",-1);
		return xmlDoc;
	}
	///////////////////////////////////////////////////////////////////////////
	this.Distance = function(str1, str2) {
		var levenshtein = function(str1, str2) {
			var current = [], prev, value;
			for (var i = 0; i <= str2.length; i++)
				for (var j = 0; j <= str1.length; j++) {
				if (i && j)
					if (str1.charAt(j - 1) === str2.charAt(i - 1))
					value = prev;
					else
					value = Math.min(current[j], current[j - 1], prev) + 1;
				else
					value = i + j;

				prev = current[j];
				current[j] = value;
				}
			return current.pop();
		};
		if (str1 === null && str2 === null) throw 'Trying to compare two null values';
		if (str1 === null || str2 === null) return 0;
		str1 = String(str1); str2 = String(str2);

		var distance = levenshtein(str1, str2);
		if (str1.length > str2.length) {
			return 1 - distance / str1.length;
		} else {
			return 1 - distance / str2.length;
		}
	}
}
///////////////////////////////////////////////////////////////////////////////
function DOResourceOutline(){
	this.type			= "script";		//script
	this.package		= false;
	this.fileName		= "";			//filename only
	this.extension		= "";			//js, vbs, pyt or osp (additional .txt autom. removed)
	this.md5			= "";			//md5 internally stored
	this.desc			= "";			//script internal or download description
	this.version		= "0";			//version
	this.url			= "";			//resource center thread url
	this.details		= "";			//resource center download details
	this.sizeFriendly	= "";			//resource center download size
}
///////////////////////////////////////////////////////////////////////////////
function DOResource(){
	this.type			= "script";
	this.package		= false;
	this.filePath		= "";			//path to resource including filename
	this.fileName		= "";			//filename only
	this.scriptName		= "";			//diff. from filename if package
	this._content		= "";			//file content
	this._onAbout		= false;		//has onabout function
	this.extension		= "";			//js, vbs, pyt or osp (additional .txt autom. removed)
	this.md5			= "";			//md5 internally stored
	this.md5Fresh		= "";			//md5 determined
	this.modified		= null;			//md5 different from internal md5
	this.enabled        = null;
	this.name			= "";			//do script/resource name
	this.desc			= "";			//internal or download description
	this.copyright		= "";			//internal
	this.version		= "0";			//version
	this.minVersion		= "";			//do min version
	this.uid			= "";			//internal unique id
	this.doID           = "";			//do internal script id

	this.url			= "";			//resource center thread url
	this._urlInternal	= false;		//url provided by resource
	this.details		= "";			//resource center download details
	this.size			= 0;			//file size
	this.sizeFriendly	= "";			//resource center download size
}
///////////////////////////////////////////////////////////////////////////////
function PackageHelper( filePath){
	this.filePath	= filePath;
	this.fileName	= this.filePath.getFilePart();
	this.tmpPath	= "";
	this.fso		= FSMagic.fso;
	///////////////////////////////////////////////////////////////////////////
	this.Extract = function(){
		out.trc("Extract():",1);
		var cmd = DOpus.Create.Command;
		var tmpPath = FSMagic.GetTmpFileName();
		//prepare tmp copy of package file with added .zip extension,
		//to allow extracting with the internal "copy" raw command
		var tmpPathOSP = FSMagic.GetTmpFileName("", ".zip");
		if(!FSMagic.CreatePath(tmpPath.fullname)){
			out.trc("",-1);
			throw "Creating tmp folder failed ["+tmpPath.fullname+"]";
		}
		if(!FSMagic.CreatePath(tmpPathOSP.path)){
			out.trc("",-1);
			throw "Creating tmp folder for OSP failed ["+tmpPathOSP.path+"]";
		}
		out.dmp('Copy file="'+this.filePath+'" to="'+tmpPathOSP.path+'" as "'+tmpPathOSP.name+'"');
		cmd.RunCommand('Copy file="'+this.filePath+'" to="'+tmpPathOSP.path+'" as "'+tmpPathOSP.name+'"');
		this.tmpPath = tmpPath.fullname;
		out.dmp('Copy EXTRACT FILE="'+tmpPathOSP.fullname+'" TO="'+this.tmpPath+'"');
		cmd.RunCommand('Copy EXTRACT FILE="'+tmpPathOSP.fullname+'" TO="'+this.tmpPath+'"');
		out.dmp('Delete '+tmpPathOSP.fullname + ' ' + Script.Config["Log.What.KeepTmpFiles"]);
		if (Script.Config["Log.What.KeepTmpFiles"])
			this.fso.DeleteFile(tmpPathOSP.fullname);
		out.trc("",-1);
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.FindMainScriptResource = function(){
		out.trc("FindMainScriptResource():",1);
		var folder = this.fso.GetFolder( this.tmpPath );
		var fEnum = new Enumerator(folder.files);
		var file = null;
		var res = null;
		for (; !fEnum.atEnd(); fEnum.moveNext()){
			file = fEnum.item();
			if (!ResParser.ValidateExtension(file.Name, false)){
				out.dmp("No valid resource ["+file.Name+"]");
				continue;
			}
			res = ResParser.Load(this.tmpPath+"\\"+file.Name);
			if (res.package) continue;
			if (res.url && res._urlInternal || res.uid){
				out.dmp("Using package file ["+res.fileName+"]");
				break;
			}
		}
		out.trc("",-1);
		return res;
	}
	///////////////////////////////////////////////////////////////////////////
	this.CleanUp = function(){
		out.trc("CleanUp():",1);
		this.fso.DeleteFolder(this.tmpPath);
		out.trc("",-1);
	}
}
///////////////////////////////////////////////////////////////////////////////
function DOResourceParser(){
	this.reMD5			= "(?://|'|#)MD5\\s*=\\s*[\"'](.*?)[\"']";
	this.fso			= new ActiveXObject("Scripting.FileSystemObject");
	this.comment		= {js:"//", vbs:"'", pyt:"#"};
	///////////////////////////////////////////////////////////////////////////
	this.ValidateExtension = function(file, throwEx, silent){
		silent || out.trc("ValidateExtension(): ["+file+"]",1);
		if (throwEx==undefined) throwEx=true;
		var typeMatch =
			new RegExp("(?:.*?)\\.(js|vbs|pyt|osp)(?:\\.txt)?$","gi").exec(file);
		if (typeMatch==null || typeMatch.length!=2){
			silent || out.dmp("INVALID");
			silent || out.trc("",-1);
			if (throwEx)
				throw new Error(ERR_BAD_FILETYPE, ERRMSGS[ERR_BAD_FILETYPE]);
			return false;
		}
		silent || out.dmp("Valid");
		silent || out.trc("",-1);
		return typeMatch[1].toLowerCase();
	}
	///////////////////////////////////////////////////////////////////////////
	this.Load = function(filePath){
		out.trc("Load():",1);
		out.dmp("File:"+filePath);
		filePath = new String(filePath);

		if (!filePath) throw t("exception.no_file_given");

		var content		= "";
		var reMD5		= new RegExp(this.reMD5,"gi");
		var res			= new DOResource();
		var parent		= filePath.getParentPart();

		if (!parent){
			parent = DOpus.FSUtil.Resolve("/dopusdata/script addins");
			filePath = parent + "\\" + filePath;
		}

		if (!this.fso.FolderExists(parent)){
			out.xit(t("exception.archives_nogood", parent));
			out.trc("",-1);
			throw new Error(t("exception.archives_nogood", parent));
		}

		res.filePath	= filePath;
		res.fileName	= filePath.getFilePart();
		res.scriptName  = res.fileName;
		res.extension	= this.ValidateExtension(res.filePath);
		res.package		= this.IsPackage(res.filePath);
		res.size		= this.fso.GetFile(res.filePath).Size;

		if (!res.package){
			var doScriptConfigDetails = this.GetDOScriptConfigDetails(res.filePath);
			res.doID        = doScriptConfigDetails.id;
			res.enabled     = doScriptConfigDetails.enabled;
		}

		if (res.package){
			var ph = new PackageHelper( res.filePath );
			var pRes = ph.Extract().FindMainScriptResource();
			ph.CleanUp();
			if (pRes){
				pRes.filePath = res.filePath;
				pRes.scriptName = pRes.fileName;
				pRes.fileName = res.fileName;
				pRes.package = res.package;
				pRes.size = res.size;

				var doScriptConfigDetails = this.GetDOScriptConfigDetails(pRes.filePath+"\\"+pRes.scriptName);
				pRes.doID        = doScriptConfigDetails.id;
				pRes.enabled     = doScriptConfigDetails.enabled;

				out.trc("",-1);
				return pRes;
			}
			throw t("exception.no_script_in_pkg");
		}

		out.dmp("Opening and reading file");
		var file		= this.fso.OpenTextFile( res.filePath, 1, false, -2);
		while(!file.AtEndOfStream){
			var line = file.ReadLine();
			if (line=="") continue;
			var md5Match = reMD5.exec(line);
			if (!md5Match) //skip the hash line
				content += line;
			else
				res.md5 = md5Match[1];
		}
		out.dmp("Closing file");
		file.Close();
		out.dmp("Calculating MD5 hash (takes some time on XP)..");
		res.md5Fresh = MD5(content);
		out.dmp("    done");
		res._content = content;

		if (res.md5!="")
			res.modified = (res.md5+""!=""+res.md5Fresh);
		out.dmp("Getting properties");
		res.name		= this._GetName(res);
		res.desc		= this._GetDesc(res);
		res.copyright	= this._GetCopyright(res);
		res.version		= this._GetVersion(res);
		//DOpus.Output(res.version);
		res.minVersion	= this._GetMinVersion(res);
		res.uid			= this._GetUID(res);
		res.url			= this._GetUrl(res);
		res._onAbout	= this._GetOnAbout(res);
		out.dmp("done");
		out.trc("",-1);
		return res;
	}
	///////////////////////////////////////////////////////////////////////////
	this.IsPackage = function(filePath){
		out.trc("IsPackage(): ["+filePath+"]",1);
		if (filePath && filePath.match( new RegExp( "\\.osp$", "gi"))){
			out.trc("YES",-1);
			return true;
		}
		out.trc("NO",-1);
		return false;
	}
	///////////////////////////////////////////////////////////////////////////
	this.Compare_old = function(verStrA,verStrB){
		verStrA = this.CleanVer(verStrA);
		verStrB = this.CleanVer(verStrB);
		if (verStrA >  verStrB) return -1;
		if (verStrA == verStrB) return  0;
		if (verStrA <  verStrB) return  1;
	}
	///////////////////////////////////////////////////////////////////////////
	this.Compare_ToTest_HandlesAlphaChars = function (v1, v2, options){
		var zeroExtend = options && options.zeroExtend,
			v1parts = v1.split('.'),
			v2parts = v2.split('.');

		if (zeroExtend) {
			while (v1parts.length < v2parts.length) v1parts.push("0");
			while (v2parts.length < v1parts.length) v2parts.push("0");
		}

		for (var i = 0; i < v1parts.length; ++i) {
			if (v2parts.length == i) {
				return 1;
			}
			var v1Int = parseInt(v1parts[i], 10);
			var v2Int = parseInt(v2parts[i], 10);
			if (v1Int == v2Int) {
				var v1Lex = v1parts[i].substr((""+v1Int).length);
				var v2Lex = v2parts[i].substr((""+v2Int).length);
				if (aLex === '' && bLex !== '') return 1;
				if (aLex !== '' && bLex === '') return -1;
				if (aLex !== '' && bLex !== '') return aLex > bLex ? 1 : -1;
				continue;
			}
			else if (v1Int > v2Int) {
				return 1;
			}
			else {
				return -1;
			}
		}

		if (v1parts.length != v2parts.length) {
			return -1;
		}

		return 0;
	}
	//////////////////////////////////////////////////////////////////////////
	this.Compare = function(v1, v2, options){ //fixed by tbone for versions with no "."
		//compares two software version numbers (e.g. "1.7.1" or "1.2b")
		//copyright by Jon Papaioannou (["john", "papaioannou"].join(".") + "@gmail.com")
		//this function is in the public domain. do what you want with it, no strings attached.
		var lexicographical = options && options.lexicographical,
			zeroExtend = options && options.zeroExtend,
			v1parts = v1.split('.'),
			v2parts = v2.split('.');

		function isValidPart(x) { return (lexicographical ? /^\d+[A-Za-z]*$/ : /^\d+$/).test(x); }

		for(var v=0;v<v1parts.length;v++) if (!isValidPart(v1parts[v])){ return NaN; }
		for(var v=0;v<v2parts.length;v++) if (!isValidPart(v2parts[v])){ return NaN; }

		if (zeroExtend) {
			while (v1parts.length < v2parts.length) v1parts.push("0");
			while (v2parts.length < v1parts.length) v2parts.push("0");
		}

		if (!lexicographical) {
			v1parts = v1parts.map(Number);
			v2parts = v2parts.map(Number);
		}

		for (var i = 0; i < v1parts.length; ++i) {
			if (v2parts.length == i) { return -1; }
			if (Number(v1parts[i]) == Number(v2parts[i])) { continue; }
			else if (Number(v1parts[i]) > Number(v2parts[i])) {	return -1; }
			else { return 1; }
		}

		if (v1parts.length != v2parts.length) { return 1; }
		return 0;
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetDOScriptConfigDetails = function( filePath){
		out.trc("GetDOScriptConfigDetails():",1);
		filePath = new String(filePath);

		var id = "";
		var enabled = null;
		var scriptFileName	= filePath.getFilePart();
		var isPackage		= this.IsPackage(scriptFileName);

		if (isPackage)	scriptFileName  += "\\"; //to match attribute value "*.osp\<scriptname>"

		var doScriptConfig = ""+DOpus.FSUtil.Resolve("/dopusdata/configfiles/scriptconfig.oxc");
		if (typeof ScriptConfigXMLDoc == 'undefined'){
			ScriptConfigXMLDoc = new ActiveXObject("MSXML2.DOMDocument.6.0");
			out.dmp("DO config path: " + doScriptConfig);
			out.dmp("Script path: " + filePath);
			out.dmp("Script file: " + scriptFileName);
			ScriptConfigXMLDoc.async = false;
			ScriptConfigXMLDoc.validateOnParse = true;
			ScriptConfigXMLDoc.resolveExternals = false;
			out.dmp("Loading config");
			ScriptConfigXMLDoc.load(doScriptConfig);
			if (ScriptConfigXMLDoc.parseError.errorCode != 0) {
				var myErr = ScriptConfigXMLDoc.parseError;
				out.err("Parser error: " + myErr.reason);
				out.trc("",-1);
				delete ScriptConfigXMLDoc;
				return {id:id, enabled: enabled};
			}
		}
		out.dmp("Looking for nodes");
		var scriptNode = ScriptConfigXMLDoc.selectSingleNode("//script[starts-with(@path,'"+scriptFileName+"')]"); //@path='"+scriptFileName+"'
		if (!scriptNode){
			var msg = t("exception.script_not_found", scriptFileName);
			out.dmp(msg);
			//get new guid and remove curly brackets
			id = new ActiveXObject("Scriptlet.TypeLib").Guid.replace(/\{/gi,"").replace(/}.*/,"");
			out.trc("",-1);
			return {id:id, enabled: enabled};
		}

		id		= scriptNode.getAttribute("id");
		enabled	= scriptNode.getAttribute("disable")=="no"?true:false;

		out.dmp("done");
		out.trc("",-1);
		return {id:id, enabled: enabled};
	}
	///////////////////////////////////////////////////////////////////////////
	this.CleanVer = function(verString){
		var vTmp = "";
		while (vTmp != verString){
			vTmp = verString;
			verString = verString.replace(/\.0*$/,"");
		}
		return verString;
	}
	///////////////////////////////////////////////////////////////////////////
	this._ParseOnInitProperty = function(res, regEx, resultIndex ){
		var reOnInit = "(?:function\\s+OnInit[\\s\\S]*?)";
		var reOnInit = "(?:function\\s+OnInit.*?)";
		str = res._content;
		var re = new RegExp(reOnInit+regEx,"gim");
		var result = re.exec(res._content);
		if (result != null){
			//for (var i=0;i<result.length;i++)
				//WSH.Echo( result[i] );
			return result[resultIndex];
		}
		return "";
	}
	///////////////////////////////////////////////////////////////////////////
	this._GetName = function(res){
		var reOnInit = "(?:function\\s+OnInit[\\s\\S]*?)";
		var reOnInit = "(?:function\\s+OnInit.*?\\name)\\s=\\s[\"'](.*?)[\"']";
		var reOnInit = "(function\\s+OnInit(?:[.\\s\\S]*?)name)\\s*=\\s*[\"'](.*?)[\"']";
		str = res._content;
		var re = new RegExp(reOnInit,"gim");
		var result = re.exec(res._content);
		if (result != null){
			//for (var i=0;i<result.length;i++)
			//DOpus.Output( result[1] + " - " +result[2] );
			return result[2];
		}
		return "?";
		//return this._ParseOnInitProperty(res, "\\.name\\s=\\s[\"'](.*?)[\"']",1);
	}
	///////////////////////////////////////////////////////////////////////////
	this._GetOnAbout = function(res){
		var re = "(?:function\\s+OnAboutScript[\\s\\S]*?)";
		str = res._content;
		var re = new RegExp(re,"gim");
		var result = re.exec(res._content);
		if (result != null) return true;
		return false;
	}
	///////////////////////////////////////////////////////////////////////////
	this._GetVersion = function(res){
		return this._ParseOnInitProperty(res,
			"\\.version\\s*?=\\s*?[\"']?(?:(?:version|ver|v)?)(\\d{1,3}(?:\\.\\d{1,3})?(?:\\.\\d{1,6})?).*[\"']?",1);
	}
	///////////////////////////////////////////////////////////////////////////
	this._GetMinVersion = function(res){
		return this._ParseOnInitProperty(res,
			"\\.min_version\\s*?=\\s*?[\"']?(\\d{1,2}(?:\\.\\d{1,3})?(?:\\.\\d{1,6})?)[\"']?",1);
	}
	///////////////////////////////////////////////////////////////////////////
	this._GetDesc = function(res){
		return this._ParseOnInitProperty(res, "\\.desc\\s*?=\\s*?[\"'](.*?)[\"']",1);
	}
	///////////////////////////////////////////////////////////////////////////
	this._GetCopyright = function(res){
		return this._ParseOnInitProperty(res, "\\.copyright\\s*?=\\s*?[\"'](.*?)[\"']",1);
	}
	///////////////////////////////////////////////////////////////////////////
	this._GetUrl = function(res){
		var url = "";
		//native .url property since DO v12
		if (!url) url = this._ParseOnInitProperty(res, "\\.url\\s*?=\\s*?[\"'](.*?)[\"']",1);
		if (url){ res._urlInternal = true; }

		//var url method
		if (!url) url = this._ParseOnInitProperty(res, "\\s*?[^A-z]url\\s*?=\\s*?[\"'](.*?)[\"']",1);
		if (url) res._urlInternal = true;

		//determining url
		if (!url){
			var base = "http://resource.dopus.com/viewtopic.php?f=35&t=";
			var urls = [];
			urls[urls.length] = ["22946", "(.*?)GoRegistry.*", ""];
			urls[urls.length] = ["23135", "(.*?)CloseTabSiblings.*", ""];
			urls[urls.length] = ["23192", "(.*?)ModifiedWithin.*", ""];
			urls[urls.length] = ["23142", "(.*?)SelectRandom.*", ""];
			urls[urls.length] = ["23117", "(.*?)Say", ""];
			urls[urls.length] = ["23027", "(.*?)GoRefreshKeepSelection", ""];
			urls[urls.length] = ["23067", "(.*?)SetVar", ""];
			urls[urls.length] = ["21890", "(.*?)Tab-?Labelizer", ""];
			urls[urls.length] = ["22450", "(.*?)ScrollSelectionIntoView", ""];
			urls[urls.length] = ["22729", "(.*?)ExtendedEXIF", ""];
			urls[urls.length] = ["22889", "(.*?)ListerDoubleClick.*", ""];
			urls[urls.length] = ["22923", "(.*?)OverrideFormats", ""];
			urls[urls.length] = ["22853", "(.*?)CustomGrouping.*", ""];
			urls[urls.length] = ["22891", "(.*?)StartHidden", ""];
			urls[urls.length] = ["22835", "(.*?)Lines", ""];
			urls[urls.length] = ["22785", "(.*?)LogCommand", ""];
			urls[urls.length] = ["22649", "(.*?)JoinMP3", ""];
			urls[urls.length] = ["22620", "(.*?)RenameFolderAddCount", ""];
			urls[urls.length] = ["22867", "(.*?)RenameFromClipboard", ""];
			urls[urls.length] = ["23179", "(.*?)ScriptHelper", ""];
			urls[urls.length] = ["22603", "(.*?)(Newest_File_Column|NewestFile).*", ""];
			urls[urls.length] = ["21503", "(.*?)TheMovieDB Downloader.*", ""];
			urls[urls.length] = ["21876", "(.*?)Search(_|\\s)?Format(_|\\s)?Lock.*", ""];
			urls[urls.length] = ["21737", "(.*?)SmartGetSizes.*", ""];
			urls[urls.length] = ["22311", "(.*?)FilterMenu.*", ""];
			urls[urls.length] = ["21126", "(.*?)CompareTabs.*", ""];
			urls[urls.length] = ["22400", "(.*?)ExternalCompare.*", ""];
			urls[urls.length] = ["23353", "(.*?)FullScreenMetaEdit.*", ""];
			urls[urls.length] = ["22566", "(.*?)LevelColumn.*", ""];
			urls[urls.length] = ["21993", "(.*?)CloseAllTabs.*", ""];
			urls[urls.length] = ["23437", "(.*?)imgurUploader.*", ""];
			urls[urls.length] = ["23391", "(.*?)RegExColumns.*", ""];
			urls[urls.length] = ["21806", "(.*?)Tagger.*", ""];
			urls[urls.length] = ["22236", "(.*?)Settings ?Auto ?Backup.*", ""];
			urls[urls.length] = ["22930", "(.*?)TestBin", ""];
			urls[urls.length] = ["21098", "(.*?)Album.?Double.?Click.*", ""];
			urls[urls.length] = ["23012", "(.*?)HashCompare.*", ""];
			urls[urls.length] = ["22700", "(.*?)Extract.?Cover.?Art.*", ""];
			urls[urls.length] = ["20881", "(.*?)Beyond.?Compare.*", ""];
			urls[urls.length] = ["22643", "(.*?)FolderDateColumns", ""];
			urls[urls.length] = ["22643", "(.*?)FolderDateColumnsRec", ""];
			urls[urls.length] = ["http://resource.dopus.com/viewtopic.php?f=3&t=6351", "(.*?)ShowInfo", ""];
			urls[urls.length] = ["22555", "(.*?)Is.?Modified.*", ""];
			urls[urls.length] = ["22734", "(.*?)ColCoverArtDim.*", ""];
			urls[urls.length] = ["http://www.haage-partner.de/forum/viewtopic.php?f=45&t=4612", "(.*?)ToggleDoubleClickAction", ""];

			var fileName= res.fileName.replace(/\$/g,"\\$").replace(/\(/g,"\\(").replace(/\)/g,"\\)");
			var name	=     res.name.replace(/\$/g,"\\$").replace(/\(/g,"\\(").replace(/\)/g,"\\)");
			for(var u=0;u<urls.length;u++){
				var scriptName = urls[u][1];
				//var scriptName = urls[u][2]; //not used
				if (fileName.match( new RegExp( scriptName+"\\.(js|vbs|pyt|osp)(\\.txt)?$", "gi")) ||
						name.match( new RegExp( scriptName+"$", "gi")) ){
					if (urls[u][0].search("https?://")==-1)
						url = base+urls[u][0];
					else
						url = urls[u][0];

					break;
				}
			}
		}
		return url;
	}
	///////////////////////////////////////////////////////////////////////////
	this._GetUID = function(res){
		return this._ParseOnInitProperty(res, "\\s*?[^A-z]uid\\s*?=\\s*?[\"'](.*?)[\"']",1);
	}
	///////////////////////////////////////////////////////////////////////////
	Translator.
		AddT("en", {
			"exception.no_file_given"		:	"No file given",
			"exception.archives_nogood"		:	"Script in archive not supported [%s]",
			"exception.no_script_in_pkg"	:	"No script found in package",
			"exception.script_not_found"	:	"Script [%s] not found in DOs script configuration data"
		}).
		AddT("de", {
			"exception.no_file_given"       :   "Keine Datei gewählt",
			"exception.archives_nogood"     :   "Skript-Pakete werden nicht unterstützt [%s]",
			"exception.no_script_in_pkg"    :   "Kein Skript im Archiv gefunden",
			"exception.script_not_found"    :   "Das Skript [%s] wurde in den Skript-Konfigurationsdaten von DO nicht gefunden"
		});

}
///////////////////////////////////////////////////////////////////////////////
//if (!Array.prototype.every){
//  Array.prototype.every = function(fun /*, thisp*/){
/*    var len = this.length;
    if (typeof fun != "function")
      throw new TypeError();

    var thisp = arguments[1];
    for (var i = 0; i < len; i++){
      if (i in this && !fun.call(thisp, this[i], i, this))
        return false;
    }
    return true;
  };
}
*/
///////////////////////////////////////////////////////////////////////////////
function UploadPreparer(){
	this.scriptPath		= "";
	this.fso			= new ActiveXObject("Scripting.FileSystemObject");
	this.win			= null;
	this.res			= null;
	this.archived		= false;
	this.lineTemplates	= {	js	:'var %name% = "%value%";',
							vbs	:'dim %name% : %name% = "%value%"',
							pyt	:'%name% = "%value%"'};
	this.goOnWithoutVer  = false;
	this.goOnWithoutUID = false;
	this.goOnWithoutUrl = false;
	this.goOnWithoutAD  = false;
	///////////////////////////////////////////////////////////////////////////
	this._Load = function(scriptPath){
		out.trc("Load():",1);
		this.res = ResParser.Load(scriptPath);

		if (this.res.package){
			this.res = null;
			out.trc("",-1);
			throw t("exception.packages_nogood");
		}
		out.dmp("Successfully loaded");
		out.trc("",-1);
	}
	///////////////////////////////////////////////////////////////////////////
	this.PrepareScript = function(scriptPath){
		out.trc("PrepareScript():",1);
		this.scriptPath = scriptPath;
		try{
			if (this.CheckEsssentials()){
				this.UpdateMD5();
				this.Finish();
				out.trc("",-1);
				return true;
			}
		} catch(e){
			out.err(e);
			Request( t("req.prepare_err.header", e), t("button.ok"), t("req.prepare_err.title"), "error", this.win);
		}
		out.trc("",-1);
		return false;
	}
	///////////////////////////////////////////////////////////////////////////
	this.CheckEsssentials = function(){
		out.trc("CheckEsssentials():",1);

		this._Load(this.scriptPath);

		out.dmp("Resource version: "+this.res.version);
		if (!this.res.version && !this.goOnWithoutVer){
			out.wrn("No version information found");
			if (!this.ShowNoVersionDialog()){
				out.trc("",-1);
				return false;
			}
		}

		out.dmp("Resource url: "+this.res.url);
		out.dmp("  (internal): "+this.res._urlInternal);
		if (!this.res._urlInternal && !this.goOnWithoutUrl){
			out.wrn("No resource center url found");
			if (!this.ShowNoURLDialog()){
				out.trc("",-1);
				return false;
			}
		}

		out.dmp("Resource uid: "+this.res.uid);
		if (!this.res.uid && !this.goOnWithoutUID){
			out.wrn("No UID found");
			if (!this.ShowNoUIDDialog()){
				out.trc("",-1);
				return false;
			}
		}

		out.dmp("OnAbout available: "+this.res._onAbout);
		if (!this.res._onAbout && !this.goOnWithoutAD){
			out.wrn("No OnAboutScript() function found");
			if (!this.ShowNoAboutDialog()){
				out.trc("",-1);
				return false;
			}
		}

		out.trc("",-1);
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.Finish = function(){
		try{
			var extension = "";
			if (this.res.package)
				;
			else if (this.res.filePath.match(/\.txt/gi))
				;
			else
				extension = ".txt";
			var fileDstPath = FSMagic.GetTmpFileName();
			var tmpFilePath = fileDstPath.path+"\\"+this.res.fileName+extension;
			this.fso.CopyFile( this.res.filePath, tmpFilePath, true);
			this.ShowFinishDialog( tmpFilePath );

		} catch(e){
			throw e;
			return false;
		}
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.ShowFinishDialog = function( tmpFilePath ){
		out.trc("ShowFinishDialog():",1);
		DOpus.SetClip(tmpFilePath);
		var dlg			= DOpus.Dlg;
		dlg.window		= (this.win?this.win:null);
		dlg.title		= t("req.finish.title", this.res.name);
		dlg.message		= t("req.finish.text");
		dlg.buttons		= t("button.openthread | button.iamdone");
		dlg.icon		= "info";
		dlg["default"]	= tmpFilePath;
		dlg.max			= 512;
		var label		= t("req.finish.deletetmp");
		for(var len=0;label.length+len<160;len++) label+=" "; label+="\t";
		dlg.options(0).label = label;
		dlg.options(0).state = 1;
		var result = dlg.Show();
		if (result){
			out.trc("",-1);
			DOpus.Create.Command.RunCommand('ScriptWizard VISIT INTERACTIVE FILE="'+this.res.filePath+'" WIN='+this.win);
			return this.ShowFinishDialog(tmpFilePath);
		}

		if (dlg.options(0).state)
			this.fso.DeleteFile(tmpFilePath);

		out.trc("",-1);
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.ShowNoAboutDialog = function(){
		out.trc("ShowNoAboutDialog():",1);
		var dlg			= DOpus.Dlg;
		dlg.window		= (this.win?this.win:null);
		dlg.title		= t("req.prepare.noabout.title");
		dlg.message		= t("req.prepare.noabout.text");
		dlg.buttons		= t("button.ok | button.cancel");
		dlg.icon		= "info";
		var label		= t("req.prepare.noabout.skip");
		for(var len=0;label.length+len<120;len++) label+=" ";  label+="\t";
		dlg.options(0).label = label;
		dlg.options(0).state = this.goOnWithoutAD;
		var result = dlg.Show();

		out.trc("",-1);
		if (!result)
			return false;

		this.goOnWithoutAD = dlg.options(0).state;
		if (!this.goOnWithoutAD){
			this.AddAboutDialog(this.res);
			return this.CheckEsssentials();
		}
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.ShowNoVersionDialog = function(){
		out.trc("ShowNoVersionDialog():",1);
		var dlg			= DOpus.Dlg;
		dlg.window		= (this.win?this.win:null);
		dlg.title		= t("req.prepare.nover.title");
		dlg.message		= t("req.prepare.nover.text");
		dlg.buttons		= t("button.ok | button.cancel");
		dlg.icon		= "info";
		var label		= t("req.prepare.nover.skip");
		for(var len=0;label.length+len<120;len++) label+=" "; label+="\t";
		dlg.options(0).label = label;
		dlg.options(0).state = this.goOnWithoutUrl;
		var result = dlg.Show();

		out.trc("",-1);
		if (!result)
			return false;

		this.goOnWithoutVer = dlg.options(0).state;
		if (!this.goOnWithoutVer){
			return this.CheckEsssentials(); //reload
		}
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.ShowNoURLDialog = function(){
		out.trc("ShowNoURLDialog():",1);
		var dlg			= DOpus.Dlg;
		dlg.window		= (this.win?this.win:null);
		dlg.message		= t("req.prepare.nourl.text");
		dlg.title		= t("req.prepare.nourl.title");
		dlg.buttons		= t("button.ok | button.cancel");
		dlg.icon		= "info";
		dlg.max			= 512;
		var codeLine	= this.CreateCodeLine("url", t("req.prepare.nourl.paste"));
		dlg["default"]	= codeLine;
		var label		= t("req.prepare.nourl.skip");
		for(var len=0;label.length+len<120;len++) label+=" "; label+="\t";
		dlg.options(0).label = label;
		dlg.options(0).state = this.goOnWithoutUrl;
		dlg.options(1).label = t("req.prepare.nourl.myself");
		dlg.options(1).state = 0;
		var result = dlg.Show();

		out.trc("",-1);
		if (!result)
			return false;

		this.goOnWithoutUrl = dlg.options(0).state;
		if (!this.goOnWithoutUrl){
			var myself = dlg.options(1).state;
			if (!myself){
				http://resource.dopus.com/viewtopic.php?f=35&t=23179
				if (!dlg.input.match("(?:.*url)(?:\\s*=\\s*)(?:\'|\")https?\://(.*?)viewtopic\.php\\?f\=\\d+\&t=\\d+(?:\'|\")"))
					DOpus.Dlg.Request(  t("req.prepare.url_err.text"), t("button.ok"), t("req.prepare.nourl.title"), this.win)
				else
					this.AddToOnInit(ResParser.comment[this.res.extension]+"thread url added via script wizard (required for updating)\r\n\t"+dlg.input);
			}
			return this.CheckEsssentials(); //reload
		}
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.ShowNoUIDDialog = function(){
		out.trc("ShowNoUIDDialog():",1);
		var dlg			= DOpus.Dlg;
		dlg.window		= (this.win?this.win:null);
		dlg.message		= t("req.prepare.nouid.text");
		dlg.title		= t("req.prepare.nouid.title");
		dlg.buttons		= t("button.ok | button.cancel");
		dlg.icon		= "info";
		dlg.max			= 512;
		var codeLine	= this.CreateCodeLine("uid", this.res.doID);
		dlg["default"]	= codeLine;
		var label		= t("req.prepare.nover.skip");
		for(var len=0;label.length+len<120;len++) label+=" "; label+="\t";
		dlg.options(0).label = label;
		dlg.options(0).state = this.goOnWithoutUID;
		dlg.options(1).label = t("req.prepare.nover.myself");
		dlg.options(1).state = 0;
		var result = dlg.Show();

		out.trc("",-1);
		if (!result)
			return false;

		this.goOnWithoutUID = dlg.options(0).state;
		if (!this.goOnWithoutUID){
			var myself = dlg.options(1).state;
			if (!myself)
				this.AddToOnInit(ResParser.comment[this.res.extension]+"uid added via script wizard (do not change after publishing this script)\r\n\t"+codeLine);
			return this.CheckEsssentials(); //reload
		}
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.AddAboutDialog = function(){
		var dialogs = [];
		dialogs["js"] = ""+
			"///////////////////////////////////////////////////////////////////////////////"+"\r\n"+
			OnAboutScript;
		dialogs["vbs"] = ""+
			"'//////////////////////////////////////////////////////////////////////////////"+"\r\n"+
			"function OnAboutScript(data) 'v0.1"+"\r\n"+
			'   dim cmd : set cmd = DOpus.Create.Command()'+"\r\n"+
			'   if (not cmd.Commandlist("s").exists("ScriptWizard")) then '+"\r\n"+
			'       if (DOpus.Dlg.Request("The \'ScriptWizard\' add-in has not been found."&vbLF&vbLF&_ '+"\r\n"+
			'"Install \'ScriptWizard\' from [resource.dopus.com]."&vbLF&"The add-in enables this dialog and also offers "&_ '+"\r\n"+
			'"easy updating of scripts and many more.","Yes, take me there!|Cancel", "No About.. ", data.window)) then _ '+"\r\n"+
			'   cmd.RunCommand("http://resource.dopus.com/viewtopic.php?f=35&t=23179")'+"\r\n"+
			'   else cmd.RunCommand("ScriptWizard ABOUT WIN="&data.window&" FILE="""&Script.File&"""")'+"\r\n"+
			'   end if'+"\r\n"+
			'end function'+"\r\n";
		dialogs["pyt"] = "#todo"; //todo

		this._Archive();
		var fileSrc = null;
		var fileDst = null;
		var fileDstPath = FSMagic.GetTmpFileName("DO.UploadPreparer.",".txt");
		try{
			fileSrc = this.fso.OpenTextFile( this.res.filePath, 1, false, -2);
			fileDst = this.fso.OpenTextFile( fileDstPath.fullname, 2, true, -1);
			while(!fileSrc.AtEndOfStream)
				fileDst.WriteLine(fileSrc.ReadLine());
			fileDst.Write(dialogs[this.res.extension]);
			fileSrc.Close();
			fileDst.Close();
			this.fso.DeleteFile(this.res.filePath);
			this.fso.MoveFile(fileDstPath.fullname,this.res.filePath);
		} catch(e){
			throw e;
			return false;
		}
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this._Archive = function(){
		if (!this.archived){
			var resUp = new DOResourceUpdater();
			resUp.ArchiveScript(String(this.res.filePath), true); //throw
			this.archived = true;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.AddToOnInit = function( newOnInitLine ){
		out.trc("AddToOnInit():",1);
		this._Archive();
		var fileSrc = null;
		var fileDst = null;
		var fileDstPath = FSMagic.GetTmpFileName("DO.UploadPreparer.",".txt");

		fileSrc = this.fso.OpenTextFile( this.res.filePath, 1, false, -2);
		fileDst = this.fso.OpenTextFile( fileDstPath.fullname, 2, true, -1);

		var content = fileSrc.ReadAll(); fileSrc.Close();
		var regExs = [];
		regExs["js"]  = new RegExp("(function\\s+OnInit\\s*\\(.*?\\)[.\\s\\S]*?\\{.*\\S?)","gim");
		regExs["js"]  = new RegExp("(function\\s+OnInit\\s*\\(.*?\\)[.\\s\\S]*?\\{.*(?:\\r\\n|\\r|\\n))","gim");
		regExs["vbs"] = new RegExp("(function\\s+OnInit\\s*\\(.*?\\).*(?:\\r\\n|\\r|\\n))","gim");
		regExs["pyt"] = new RegExp("todo","gim"); //todo

		var re = regExs[this.res.extension];
		if (!content.match(re)){
			throw t("exception.oninit_notfound");
		}
		var contentNew = content.replace(re, "$1\t"+newOnInitLine+"\r\n");
		var lineAdded = (content != contentNew);

		if (!lineAdded){
			fileDst.Close();
			this.fso.DeleteFile(fileDstPath.fullname);
			out.trc("",-1);
			throw t("exception.addline_failed");
		}
		out.dmp("Line added");
		fileDst.Write(contentNew); fileDst.Close();
		this.fso.DeleteFile(this.res.filePath);
		this.fso.MoveFile(fileDstPath.fullname,this.res.filePath);
		out.trc("",-1);
	}
	///////////////////////////////////////////////////////////////////////////
	this.UpdateMD5 = function(filePath){
		out.trc("UpdateMD5():",1);
		if (filePath){
			out.dmp("Loading passed file ["+filePath+"]");
			try{
				this._Load(filePath);
			} catch(e){
				out.err("Error: " + e);
				return false;
			}
		}

		if (this.res.modified === false){
			out.dmp("File was not modified, aborting");
			out.trc("",-1);
			return true; //not modified
		}
		this._Archive();
		var fileSrc = null;
		var fileDst = null;
		var fileDstPath = FSMagic.GetTmpFileName("DO.UploadPreparer.",".txt");
		out.dmp("Opening files");
		fileSrc = this.fso.OpenTextFile( this.res.filePath, 1, false, -2);
		fileDst = this.fso.OpenTextFile( fileDstPath.fullname, 2, true, -1);
		var reMD5 = new RegExp(ResParser.reMD5,"gi");
		var firstLine = true;
		while(!fileSrc.AtEndOfStream){
			var line = fileSrc.ReadLine();
			if (firstLine){
				if (line.indexOf("") == 0) line = line.substring(3); //utf8 bom
				if (line.indexOf("þÿ") == 0) line = line.substring(2); //utf16 be bom
				if (line.indexOf("ÿþ") == 0) line = line.substring(2); //utf16 le bom
				firstLine = false;
			}

			var md5Match = reMD5.exec(line);
			if (!md5Match) //skip the hash line
				fileDst.WriteLine(line);
			else
				out.dmp("MD5 hash found in source file");
		}
		out.dmp("Appending MD5 hash ["+this.res.md5Fresh+"]");
		fileDst.WriteLine(ResParser.comment[this.res.extension]+
			'MD5'+' = '+'"'+this.res.md5Fresh+'"; DATE = "'+new Date().formatDate()+
			' - '+new Date().formatTime()+'"');
		out.dmp("Closing files");
		fileSrc.Close();
		fileDst.Close();
		this.fso.DeleteFile(this.res.filePath);
		this.fso.MoveFile(fileDstPath.fullname,this.res.filePath);
		out.trc("",-1);
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.CreateCodeLine = function( varName, varValue ){
		var line = this.lineTemplates[this.res.extension];
		line = line.replace(/%name%/gi,varName);
		line = line.replace(/%value%/gi,varValue);
		return line;
	}
	///////////////////////////////////////////////////////////////////////////
	Translator.
		AddT("en", {
			"button.ok"					:	"Ok",
			"button.cancel"				:	"Cancel",

			"exception.packages_nogood"	:	"Script packages cannot be prepared for uploading",
			"exception.addline_failed"	:	"Adding line of code to OnInit() failed",
			"exception.oninit_notfound"	:	"No 'OnInit' match found",

			"req.prepare_err.title"		:	"PrepareUpload - Error",
			"req.prepare_err.header"	:	"An error occured while preparing the script:\n\n%s",
			//
			"req.prepare.nourl.title"	:	"PrepareUpload - No Url",
			"req.prepare.nourl.text"	:	"No resource center URL found!\n\n"+
											"The script does not yet contain an url to its resource center thread.\n"+
											"Please paste the thread-url into the reserved area in the textbox below to continue.\n\n"+
											"No thread url yet?\nThen just create the thread right now to get the url, but do not upload the script yet.",
			"req.prepare.nourl.paste"	:	"<paste URL here>",
			"req.prepare.nourl.skip"	:	"Continue without url (not recommended, the script cannot be updated by its users)",
			"req.prepare.nourl.myself"	:	"I will add the url string to the script myself",
			"req.prepare.url_err.title"	:	"PrepareUpload - Url Error",
			"req.prepare.url_err.text"	:	"It looks like the url or line of code is invalid.\n"+
											"Make sure to keep the code syntax correct.\n\n"+
											"The url itself needs to match the following pattern:\n"+
											"http(s)://<website/path>/viewtopic.php?f=XX&t=XXXXX",
			//
			"req.prepare.noabout.title"	:	"PrepareUpload - No About",
			"req.prepare.noabout.text"	:	"No OnAboutScript() function found!\n\n"+
											"The script does not yet contain an OnAboutScript() function.\n"+
											"A very tiny function will be added, which makes use of the ScriptHelper about dialog.\n"+
											"The dialog offers updating, archiving and many more directly from the script preferences.",
			"req.prepare.noabout.skip"	:	"No dialog (not recommended, the script cannot be easily maintained or updated by its users)",
			//
			"req.prepare.nover.title"	:	"PrepareUpload - No Version",
			"req.prepare.nover.text"	:	"No version information found!\n\n"+
											"The script does not yet seem to contain a version string.\n"+
											"Please add it manually, by setting the onInitData.version property.",
			"req.prepare.nover.skip"	:	"Continue without version (not recommended, the script cannot be updated by its users)",
			//
			"req.prepare.nouid.title"	:	"PrepareUpload - No UID",
			"req.prepare.nouid.text"	:	"No UID found!\n\n"+
											"The script to upload does not yet contain the dopus internal script id.\n"+
											"The line displayed below will be added to the OnInit() function of your script.\n\n"+
											"Your script is safe, it will be archived automatically.",
			"req.prepare.nouid.skip"	:	"Continue without UID (not recommended, the id greatly helps identifying scripts)",
			"req.prepare.nover.myself"	:	"I will add the id string to the script myself",
			//
			"req.finish.title"			:	"PrepareUpload - Finished for %s",
			"req.finish.text"			:	"Script successfully prepared to upload!\n\n"+
											"A temporary copy has been created and its path inserted to the clipboard.\nFeel free to upload right now.\n\n"+
											"Reminders:\n"+
											"Did you increase the version number? If not hit ESC and restart.\n"+
											"Make sure to put the new version number into the uploaded file comment.\n\n"+
											"Thanks for using the ScriptWizard! o)",
			"req.finish.deletetmp"		:	"Delete the temporary script/package",
			"button.openthread"			:	"Open Thread",
			"button.iamdone"			:	"I'm done"

		}).
		AddT("de", {
			"button.ok"                 :   "Ok",
			"button.cancel"             :   "Abbruch",

			"exception.packages_nogood" :   "Script-Pakete können nicht zum Upload vorbereitet werden",
			"exception.addline_failed"  :   "Das Hinzufügen von Code zur Funktion OnInit() ist fehlgeschlagen",
			"exception.oninit_notfound" :   "Kein passender 'OnInit'-Eintrag gefunden",

			"req.prepare_err.title"     :   "Upload vorbereiten - Fehler",
			"req.prepare_err.header"    :   "Fehler beim Vorbereiten des Scripts:\n\n%s",
			//
			"req.prepare.nourl.title"   :   "Upload vorbereiten - Keine Url",
			"req.prepare.nourl.text"    :   "Es wurde keine Forum-URL gefunden!\n\n"+
											"Das Script enthält bisher keine URL zu seinem Forums-Beitrag.\n"+
											"Kopiere die URL des Forum-Beitrags in das Textfeld unten im Dialogfenster um fortzufahren.\n\n"+
											"Noch keinen Beitrag im Forum erstellt?\nDann erstelle jetzt den Beitrag um die URL zu erhalten aber lade das Script noch nicht hoch.",
			"req.prepare.nourl.paste"   :   "<URL hierher kopieren>",
			"req.prepare.nourl.skip"    :   "Fortfahren ohne URL (nicht empfohlen, das Script kann von den Benutzern nicht aktualisiert werden)",
			"req.prepare.nourl.myself"  :   "Ich werde die URL selbst dem Script hinzufügen",
			"req.prepare.url_err.title" :   "Upload vorbereiten - Url Fehler",
			"req.prepare.url_err.text"  :   "Die URL oder Code-Zeile scheint ungültig zu sein.\n"+
											"Stelle sicher, dass die Syntax der Zeichenfolge korrekt ist.\n\n"+
											"Die URL selbst muss der folgenden Form entsprechen:\n"+
											"http(s)://<Webseite/Pfad>/viewtopic.php?f=XX&t=XXXXX",
			//
			"req.prepare.noabout.title" :   "Upload vorbereiten - Keine OnAboutScript()-Funktion",
			"req.prepare.noabout.text"  :   "Keine OnAboutScript() Funktion gefunden!\n\n"+
											"Das Script enthält bisher keine OnAboutScript()-Funktion.\n"+
											"Eine kleine Funktion wird hinzugefügt, die die Schaltfläche für den Info-Dialog in den Script-Einstellungen aktiviert.\n"+
											"Der Dialog bietet Möglichkeiten zum aktualisieren und archivieren von Scripts (und mehr) direkt aus dessen Einstellungen heraus.",
			"req.prepare.noabout.skip"  :   "Kein Dialog (nicht empfohlen, das Script kann von den Benutzern nicht problemlos verwaltet und aktualisiert werden)",
			//
			"req.prepare.nover.title"   :   "Upload vorbereiten - Keine Versionsinformation",
			"req.prepare.nover.text"    :   "Keine Versionsinformation gefunden!\n\n"+
											"Das Script scheint bisher keine Versionsangabe zu enthalten.\n"+
											"Füge dies bitte manuell hinzu, indem du die Eigenschaft onInitData.version setzt.",
			"req.prepare.nover.skip"    :   "Fortfahren ohne Versionsangabe (nicht empfohlen, das Script kann von den Benutzern nicht aktualisiert werden)",
			//
			"req.prepare.nouid.title"   :   "Upload vorbereiten - Keine UID",
			"req.prepare.nouid.text"    :   "Keine UID gefunden!\n\n"+
											"Das Script enthält noch keine DOpus-interne Script-ID.\n"+
											"Die unten dargestellte Zeile wird der OnInit()-Funktion des Scripts hinzugefügt.\n\n"+
											"Das Original-Script ist sicher; es wird automatisch archiviert.",
			"req.prepare.nouid.skip"    :   "Ohne UID fortfahren (nicht empfohlen, die ID ist äusserst hilfreich um ScriptsScript zu identifizieren)",
			"req.prepare.nover.myself"  :   "Ich werde die ID-Zeile selbst hinzufügen",
			//
			"req.finish.title"          :   "Upload vorbereiten - Beendet für %s",
			"req.finish.text"           :   "Das Script wurde erfolgreich für den Upload vorbereitet!\n\n"+
											"Eine temporäre Kopie wurde erstellt und ihr Pfad in die Zwischenablage kopiert.\nDu kannst sofort mit dem Upload beginnen.\n\n"+
											"Checkliste:\n"+
											"Hast du im Script die Versionsnummer erhöht? Wenn nicht drücke ESC und starte erneut.\n"+
											"Stelle sicher, dass du die neue Versionsnummer im Kommentarfeld der hochgeladenen Datei eingetragen hast.\n\n"+
											"Vielen Dank für die Verwendung von ScriptWizard! o)",
			"req.finish.deletetmp"      :   "Lösche das temporäre Script/Paket",
			"button.openthread"         :   "Öffne Forumsbeitrag",
			"button.iamdone"            :   "Ich bin fertig"
		});
}


///////////////////////////////////////////////////////////////////////////////
function Request(txt,buttons,title,icon,win){
	var dlg			= DOpus.Dlg;
	dlg.window		= (win==undefined?null:win);
	dlg.message		= txt;
	dlg.title		= title;
	dlg.buttons		= buttons;
	dlg.icon		= icon;
	return dlg.Show();
}
///////////////////////////////////////////////////////////////////////////////
function GetParameter( data, templateName, configName, defaultValue){
	// v0.8
	function VectorToArray(vector){
		var a = new Array();
		for(var v=0;v<vector.length;v++)
			a[a.length] = vector(v);
		return a;
	}
	if (templateName && data.func.args.got_arg[templateName]){
		return data.func.args[templateName];
	}
	if (configName && Script.config[configName]!=undefined){
		switch(typeof(Script.config[configName])){
			case "string":
				if(Script.config[configName]!=="")
					return Script.config[configName];
				break;
			case "boolean":
				return Script.config[configName];
			case "object":
				//test for DO specific vector, convert 2 array
				if (Script.config[configName].capacity != undefined)
					return VectorToArray(Script.config[configName]);
				return Script.config[configName];
		}
	}
	return defaultValue;
}
///////////////////////////////////////////////////////////////////////////////
function FSMagic(){
	this.version = 0.2;
	this.fso = new ActiveXObject("Scripting.FileSystemObject");
	///////////////////////////////////////////////////////////////////////////
	this.GetTmpFileName = function(prefix, extension) {
		var tFolder = this.fso.GetSpecialFolder(2); //2 = temp folder
		var tFile = this.fso.GetTempName();
		if (prefix!=undefined) tFile=prefix+tFile;
		if (extension!=undefined) tFile+=extension;
		return {
			path	: tFolder.Path,
			name	: tFile,
			fullname: tFolder.Path+'\\'+tFile
		};
	}
	///////////////////////////////////////////////////////////////////////////
	this.CreatePath = function(fullPath){
		//version = 0.5.1;
		fullPath = new String(fullPath);
		if (this.fso.FolderExists(fullPath)) return true;
		var drive = fullPath.substring(0,3);
		var dirs = fullPath.split("\\");
		var path = ""
		for(var i=1;i<dirs.length;i++){
			var dir = dirs[i];
			if (path!="") path += "\\"; else path = drive;
			path += dir;
			if (this.fso.FolderExists(path)) continue;
			try{
				this.fso.CreateFolder(path);
			}
			catch (e){
				return false;
			}
		}
		return true;
	}
	///////////////////////////////////////////////////////////////////////
	this.GetLetter = function(path){
		var letterMatch = String(path).match(/^([A-Z]):.*/);
		if (!letterMatch)
			return "";
		return letterMatch[1];
	}
	///////////////////////////////////////////////////////////////////////////
	String.prototype.getFilePart = function (){
		return this.split("\\").slice(-1)[0];
	}
	///////////////////////////////////////////////////////////////////////////
	String.prototype.getParentPart = function (){
		var arr = this.split("\\");
		arr.pop(); //remove last element
		return arr.join("\\");
	}
	///////////////////////////////////////////////////////////////////////////
	String.prototype.getExtension = function (){
		return this.getFilePart().split(".").slice(-1)[0];
	}
	///////////////////////////////////////////////////////////////////////////
	String.prototype.getBaseName = function (){
		var arr = this.getFilePart().split(".");
		arr.pop();
		return arr.join(".");
	}
}
///////////////////////////////////////////////////////////////////////////////
function DebugOutput(level){
	this._version		= 0.51;
	this.outBuffer		= new Array();
	this._keepInds		= false;
	this._indent		= 0;
	this._indentChar	= " ";
	this._indentWidth	= 4;
	this._level			= (level==undefined?4:level);
	this._buffered		= false;
	this._muted			= false;
	this._console		= true;
	this._file			= false;
	this._filePath		= "";
	this._fileError		= false;
	this._fileMaxSize	= 0;
	this._tolerance		= 0; //max filesize tolerance in %
	this._fso			= null;
	this._lineFile		= "%date% %time% %msg%";
	this._lineConsole	= "%msg%";
	this._inDOP			= false;
	this._inWSH			= false;
	///////////////////////////////////////////////////////////////////////////
	try{this._inWSH		= WScript!=undefined}catch(e){};
	try{this._inDOP		= DOpus!=undefined}catch(e){};
	if(this._inDOP)
		DOpus.vars.Delete("DebugOutput.DumpInProgress");
	///////////////////////////////////////////////////////////////////////////
	this.lineFile = function(lineTemplate){
		this._lineFile = lineTemplate;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.lineConsole = function(lineTemplate){
		this._lineConsole = lineTemplate;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this._prepLine = function(msg, template){
		var curDate = new Date();
		template = template.replace(/\%msg\%/g,msg);
		template = template.replace(/\%date\%/g,curDate.formatDate());
		template = template.replace(/\%time\%/g,curDate.formatTime());
		return template;
	}
	///////////////////////////////////////////////////////////////////////////
	this.buffer = function(truefalse){
		if (truefalse==undefined) truefalse=true;
		this._buffered=truefalse;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.mute = function(truefalse){
		if (truefalse==undefined) truefalse=true;
		this._muted=truefalse;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.dump = function(extraLine){
		if (this._inDOP){
			var millisWaited = 0;
			while (DOpus.vars.Exists("DebugOutput.DumpInProgress") && millisWaited<2000){
				DOpus.Delay(100);
				millisWaited+=100;
			}
			DOpus.vars.Set("DebugOutput.DumpInProgress",1);
		}
		this.buffer(false);
		if ((extraLine!=undefined && extraLine) && this.outBuffer.length)
			this._conOut(""); //blank separating line
		for(var i=0;i<this.outBuffer.length;i++)
			this._conOut(this.outBuffer[i]);

		if (this._inDOP) DOpus.vars.Delete("DebugOutput.DumpInProgress");
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.console = function(truefalse){
		if (truefalse==undefined) truefalse=true;
		this._console=truefalse;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.inc = function(steps){
		//DOpus.Output(">");
		if (steps==undefined) steps=1;
		this._indent+=steps;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.dec = function(steps){
		//DOpus.Output("<");
		if (steps==undefined) steps=1;
		this._indent-=steps;
		if (this._indent<0) this._indent=0;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.reset = function(){
		this._indent=0;
		this.buffer = new Array();
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this._ind = function(indent){
		if (indent==undefined) return;
		if (indent>0) this.inc();
		if (indent<0) this.dec();
	}
	///////////////////////////////////////////////////////////////////////////
	this._pad = function( length) {
		var str = "";
		while (str.length < length) str+=this._indentChar;
		return str;
	}
	///////////////////////////////////////////////////////////////////////////
	this.level = function(level){
		if (level==undefined) level=4;
		if (level>-1) this._level=level;
		if (level>6) this._level=6;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this._conOut = function(txt){
		if (this._inDOP && !this._muted) DOpus.Output(txt);
		if (this._inWSH && !this._muted) WScript.Echo(txt);
	}
	///////////////////////////////////////////////////////////////////////////
	this.out = function(txt, indent, type){
		if (indent==undefined) indent=0;
		if (type==undefined) type="";
		var indTmp = this._indent;
		if (type!="" && indTmp==0) indTmp=1;
		if (this._level>0 && (txt!="" || indent==0)){
			var output =	type+
							this._pad(indTmp*this._indentWidth-type.length)
							+txt;
			this.outRaw(output);
		}
		this._ind(indent);
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.outRaw = function(output){
		if (this._buffered) this.outBuffer[this.outBuffer.length]=output;
		if (this._console) this._conOut(this._prepLine(output,this._lineConsole));
		if (this._file)	this._fileOut(this._prepLine(output,this._lineFile));
	}
	///////////////////////////////////////////////////////////////////////////
	this._fileOut = function(txt){
		if (this._save && this._fso.FileExists(this._filePath))
			this._fso.DeleteFile(this._filePath);
		this._save = false;
		var file = this.open(8, true); //append
		if (file === null) return false;
		try{file.WriteLine(txt);}catch(e){
			txt = txt.replace(/[^ -~]/ig,''); //printable chars only
			file.WriteLine(txt);
		}
		file.Close();
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.append = function(filepath){
		if (filepath==undefined) throw "No filepath given.";
		try{ this._fso = fso; } catch(e){
			this._fso = new ActiveXObject("Scripting.FileSystemObject");}
		this._filePath = filepath;
		this._file = true;
		this.truncate(this._fileMaxSize, this._tolerance);
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.save = function(filepath ){
		this._save = true;
		return this.append(filepath);
	}
	///////////////////////////////////////////////////////////////////////////
	this.max = function(maxFileSize){
		this._fileMaxSize = maxFileSize;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.tolerance = function(maxFileSizeTolerancePercent){
		this._tolerance = maxFileSizeTolerancePercent;
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.truncate = function(maxSize, percTolerance){
		if (!maxSize) return this;
		percTolerance = percTolerance || 0; var maxSizeTol = maxSize;
		if (percTolerance) maxSizeTol = maxSize+(maxSize*(percTolerance/100));
		if (!this._fso.FileExists(this._filePath)) return this;
		var file = this.open( 1, false);//read
		if (file === null) return this; file.Close();
		if(this._fso.GetFile(this._filePath).Size < maxSizeTol) return this;
		var content = [], file = this.open( 1, false);
		while(!file.AtEndOfStream) content[content.length] = file.ReadLine();
		file.Close(); var file=this.open( 2, true);
		var size=2/*bom*/, startIndex=content.length, delta=0;
		if (file === null) return this;
		while(startIndex && ((size+delta)<maxSize))//*2=utf16,+4=\r\n
			size += (delta = ((""+content[--startIndex]).length*2)+4);
		while(startIndex<content.length) file.WriteLine(content[startIndex++])
		file.Close();
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.open = function(mode, create){
		mode = mode || 1;
		create = create || false;
		try{
			var file = this._fso.OpenTextFile(this._filePath, mode, create, -1);
			this._fileError = false;
			return file;
		} catch(e){
			if (!this._fileError){
				this._fileError = true;
				this.err("FAILED TO OPEN LOGFILE ["+this._filePath+"]. " + e);
			}
			return null;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.dmp = function(txt, indent){
		if (this._level+1>6||(this._keepInds&&indent)) this.out(txt, indent);
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.trc = function(txt, indent){
		if (this._level+1>5||(this._keepInds&&indent)) this.out(txt, indent);
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.put = function(txt, indent){
		if (this._level+1>4||(this._keepInds&&indent)) this.out(txt, indent);
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.inf = function(txt, indent){
		if (this._level+1>3||(this._keepInds&&indent)) this.out(txt, indent, "I");
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.wrn = function(txt, indent){
		if (this._level+1>2||(this._keepInds&&indent)) this.out(txt, indent, "W");
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.err = function(txt, indent){
		if (this._level+1>1||(this._keepInds&&indent)) this.out(txt, indent, "E");
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.xit = function(txt, indent){
		if (this._level+1>0||(this._keepInds&&indent)) this.out(txt, indent, "X");
		return this;
	}
}
///////////////////////////////////////////////////////////////////////////////
var MD5 = function(string) {
	///////////////////////////////////////////////////////////////////////////
	function RotateLeft(lValue, iShiftBits) {
		return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
	}
	///////////////////////////////////////////////////////////////////////////
	function AddUnsigned(lX, lY) {
		var lX4, lY4, lX8, lY8, lResult;
		lX8 = (lX & 0x80000000);
		lY8 = (lY & 0x80000000);
		lX4 = (lX & 0x40000000);
		lY4 = (lY & 0x40000000);
		lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
		if (lX4 & lY4) return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
		if (lX4 | lY4) {
			if (lResult & 0x40000000) return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
			else
			return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
		} else
		return (lResult ^ lX8 ^ lY8);
	}
	///////////////////////////////////////////////////////////////////////////
	function F(x, y, z) { return (x & y) | ((~x) & z); }
	///////////////////////////////////////////////////////////////////////////
	function G(x, y, z) { return (x & z) | (y & (~z)); }
	///////////////////////////////////////////////////////////////////////////
	function H(x, y, z) { return (x ^ y ^ z); }
	///////////////////////////////////////////////////////////////////////////
	function I(x, y, z) { return (y ^ (x | (~z))); }
	///////////////////////////////////////////////////////////////////////////
	function FF(a, b, c, d, x, s, ac) {
		a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
		return AddUnsigned(RotateLeft(a, s), b);
	};
	///////////////////////////////////////////////////////////////////////////
	function GG(a, b, c, d, x, s, ac) {
		a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
		return AddUnsigned(RotateLeft(a, s), b);
	};
	///////////////////////////////////////////////////////////////////////////
	function HH(a, b, c, d, x, s, ac) {
		a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
		return AddUnsigned(RotateLeft(a, s), b);
	};
	///////////////////////////////////////////////////////////////////////////
	function II(a, b, c, d, x, s, ac) {
		a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
		return AddUnsigned(RotateLeft(a, s), b);
	};
	///////////////////////////////////////////////////////////////////////////
	function ConvertToWordArray(string) {
		var lWordCount;
		var lMessageLength = string.length;
		var lNumberOfWords_temp1 = lMessageLength + 8;
		var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
		var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
		var lWordArray = Array(lNumberOfWords - 1);
		var lBytePosition = 0;
		var lByteCount = 0;
		while (lByteCount < lMessageLength) {
			lWordCount = (lByteCount - (lByteCount % 4)) / 4;
			lBytePosition = (lByteCount % 4) * 8;
			lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition));
			lByteCount++;
		}
		lWordCount = (lByteCount - (lByteCount % 4)) / 4;
		lBytePosition = (lByteCount % 4) * 8;
		lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
		lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
		lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
		return lWordArray;
	};
	///////////////////////////////////////////////////////////////////////////
	function WordToHex(lValue) {
		var WordToHexValue = "",
			WordToHexValue_temp = "",
			lByte, lCount;
		for (lCount = 0; lCount <= 3; lCount++) {
			lByte = (lValue >>> (lCount * 8)) & 255;
			WordToHexValue_temp = "0" + lByte.toString(16);
			WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
		}
		return WordToHexValue;
	};
	///////////////////////////////////////////////////////////////////////////
	function Utf8Encode(string) {
		string = string.replace(/\r\n/g, "\n");
		var utftext = "";
		for (var n = 0; n < string.length; n++) {
			var c = string.charCodeAt(n);
			if (c < 128) {
				utftext += String.fromCharCode(c);
			} else if ((c > 127) && (c < 2048)) {
				utftext += String.fromCharCode((c >> 6) | 192);
				utftext += String.fromCharCode((c & 63) | 128);
			} else {
				utftext += String.fromCharCode((c >> 12) | 224);
				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
				utftext += String.fromCharCode((c & 63) | 128);
			}
		}
		return utftext;
	};
	///////////////////////////////////////////////////////////////////////////
	var x = Array();
	var k, AA, BB, CC, DD, a, b, c, d;
	var S11 = 7, S12 = 12, S13 = 17, S14 = 22, S21 = 5, S22 = 9, S23 = 14, S24 = 20;
	var S31 = 4, S32 = 11, S33 = 16, S34 = 23, S41 = 6, S42 = 10, S43 = 15, S44 = 21;
	string = Utf8Encode(string);
	x = ConvertToWordArray(string);
	a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
	for (k = 0; k < x.length; k += 16) {
		AA = a; BB = b; CC = c; DD = d;
		a = FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
		d = FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
		c = FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
		b = FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
		a = FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
		d = FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
		c = FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
		b = FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
		a = FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
		d = FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
		c = FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
		b = FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
		a = FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
		d = FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
		c = FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
		b = FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
		a = GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
		d = GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
		c = GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
		b = GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
		a = GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
		d = GG(d, a, b, c, x[k + 10], S22, 0x2441453);
		c = GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
		b = GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
		a = GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
		d = GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
		c = GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
		b = GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
		a = GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
		d = GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
		c = GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
		b = GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
		a = HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
		d = HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
		c = HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
		b = HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
		a = HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
		d = HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
		c = HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
		b = HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
		a = HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
		d = HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
		c = HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
		b = HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
		a = HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
		d = HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
		c = HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
		b = HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
		a = II(a, b, c, d, x[k + 0], S41, 0xF4292244);
		d = II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
		c = II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
		b = II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
		a = II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
		d = II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
		c = II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
		b = II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
		a = II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
		d = II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
		c = II(c, d, a, b, x[k + 6], S43, 0xA3014314);
		b = II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
		a = II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
		d = II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
		c = II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
		b = II(b, c, d, a, x[k + 9], S44, 0xEB86D391);
		a = AddUnsigned(a, AA);
		b = AddUnsigned(b, BB);
		c = AddUnsigned(c, CC);
		d = AddUnsigned(d, DD);
	}
	var temp = WordToHex(a) + WordToHex(b) + WordToHex(c) + WordToHex(d);
	return temp.toLowerCase();
}
///////////////////////////////////////////////////////////////////////////////
function OnAddColumns(data){

	///////////////////////////////////////////////////////////////////////////
	Translator.
		AddT("en", {
			"column.name.header"			:	"Name",
			"column.name.label"				:	"SWizard.Name",
			"column.description.header"		:	"Description",
			"column.description.label"		:	"SWizard.Description",
			"column.copyright.header"		:	"Copyright",
			"column.copyright.label"		:	"SWizard.Copyright",
			"column.enabled.header"			:	"Enabled",
			"column.enabled.label"			:	"SWizard.Enabled",
			"column.version.header"			:	"Version",
			"column.version.label"			:	"SWizard.Version",
			"column.minversion.header"		:	"MinVersion",
			"column.minversion.label"		:	"SWizard.MinVersion",
			"column.status.header"			:	"Status",
			"column.status.label"			:	"SWizard.Status",
			"column.modified.header"		:	"Modified",
			"column.modified.label"			:	"SWizard.Modified",
			"column.url.header"				:	"Url",
			"column.url.label"				:	"SWizard.Url",
			"column.info.header"			:	"Information",
			"column.info.label"				:	"SWizard.Information"
		}).
		AddT("de", {
			"column.name.header"			:	"Name",
			"column.name.label"				:	"SWizard.Name",
			"column.description.header"		:	"Beschreibung",
			"column.description.label"		:	"SWizard.Beschreibung",
			"column.copyright.header"		:	"Copyright",
			"column.copyright.label"		:	"SWizard.Copyright",
			"column.enabled.header"			:	"Aktiviert",
			"column.enabled.label"			:	"SWizard.Aktiviert",
			"column.version.header"			:	"Version",
			"column.version.label"			:	"SWizard.Version",
			"column.minversion.header"		:	"MinVersion",
			"column.minversion.label"		:	"SWizard.MinVersion",
			"column.status.header"			:	"Status",
			"column.status.label"			:	"SWizard.Status",
			"column.modified.header"		:	"Modifiziert",
			"column.modified.label"			:	"SWizard.Modifiziert",
			"column.url.header"				:	"Url",
			"column.url.label"				:	"SWizard.Url",
			"column.info.header"			:	"Information",
			"column.info.label"				:	"SWizard.Information"
		});

	var col = data.AddColumn();
	col.multicol = true;
	col.name = "Name";
	col.method = "Column_ScriptDetails_Multi";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "left";
	col.defwidth = "175px";
	tc(col);

	var col = data.AddColumn();
	col.multicol = true;
	col.name = "Description";
	col.method = "Column_ScriptDetails_Multi";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "left";
	col.defwidth = "175px";
	tc(col);

	var col = data.AddColumn();
	col.multicol = true;
	col.name = "Copyright";
	col.method = "Column_ScriptDetails_Multi";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "left";
	col.defwidth = "175px";
	tc(col);

	var col = data.AddColumn();
	col.multicol = true;
	col.name = "Version";
	col.method = "Column_ScriptDetails_Multi";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "left";
	col.defwidth = "45px";
	tc(col);

	var col = data.AddColumn();
	col.multicol = true;
	col.name = "MinVersion";
	col.method = "Column_ScriptDetails_Multi";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "left";
	col.defwidth = "45px";
	tc(col);

	var col = data.AddColumn();
	col.multicol = true;
	col.name = "Modified";
	col.method = "Column_ScriptDetails_Multi";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "right";
	col.defwidth = "50px";
	tc(col);

	var col = data.AddColumn();
	col.multicol = true;
	col.name = "Url";
	col.method = "Column_ScriptDetails_Multi";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "left";
	col.defwidth = "300px";
	tc(col);

	var col = data.AddColumn();
	col.multicol = true;
	col.name = "Info";
	col.method = "Column_ScriptDetails_Multi";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "left";
	col.defwidth = "300px";
	tc(col);

	//single columns
	var col = data.AddColumn();
	col.name = "Status";
	col.method = "Column_ScriptStatus_Single";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "center";
	col.defwidth = "80px";
	tc(col);

	var col = data.AddColumn();
	col.name = "Enabled";
	col.method = "Column_ScriptEnabled_Single";
	col.autorefresh = true;
	col.namerefresh = true;
	col.justify = "right";
	col.defwidth = "50px";
	tc(col);

}
///////////////////////////////////////////////////////////////////////////
Translator.
	AddT("en", {
		"column.enabled.yes"			: "yes",
		"column.enabled.no"				: "no",
		"column.modified.yes"			: "yes",
		"column.modified.no"			: "no",
		"column.modified.unknown"		: "?",
		"column.status.old"				: "old",
		"column.status.uptodate"		: "uptodate",
		"column.status.newer"			: "newer"
	}).
	AddT("de", {
		"column.enabled.yes"			: "ja",
		"column.enabled.no"				: "nein",
		"column.modified.yes"			: "ja",
		"column.modified.no"			: "nein",
		"column.modified.unknown"		: "?",
		"column.status.old"				: "veraltet",
		"column.status.uptodate"		: "aktuell",
		"column.status.newer"			: "neuer"
	});
///////////////////////////////////////////////////////////////////////////////
function Column_ScriptStatus_Single(data) {
	if (data.item.is_dir) return;
	if (!ResParser.ValidateExtension(data.item.name, false, true)) return;

	out.trc("Column_ScriptStatus_Single(): ["+data.item.name+"]",1);

	ColCache.Initialize(data);
	var cacheItem = ColCache.LookupItem(data.item);
	if (!cacheItem || cacheItem.isModified || cacheItem.isExpired){
		out.dmp("Creating new item");
		cacheItem = ColCache.CreateItem(data.item, cacheItem);
	}

	out.dmp("    Modified: " + cacheItem.isModified);
	out.dmp("    Expired : " + cacheItem.isExpired + ", expires in " + cacheItem.ExpirationHours() + " hours." );
	out.dmp("Status: " + cacheItem.GetColumn("Status"));
	if (cacheItem.GetColumn("Status")!==undefined){
		out.dmp("Using cached column values");
		cacheItem.ExportColumns();
		out.trc("",-1);
		return;
	}
	out.dmp("*NOT* using cached item values, getting fresh values");

	try{
		ColCache.SetColumns("");

		out.mute(false);
		var resUp = new DOResourceUpdater();
		resUp.interactive	= false;
		resUp.progress		= false;
		resUp.showResults	= false;
		resUp.win			= null;

		var statusTxt = "";
		var status = resUp.UpdateCheck(data.item, true);

		if		(status.code &  RES_UPDATE_FOUND)		statusTxt=t("column.status.old");
		else if	(status.code &  RES_UPTODATE)			statusTxt=t("column.status.uptodate");
		else if	(status.code &  RES_MORERECENT)			statusTxt=t("column.status.newer");
		else if	(status.code == RES_UPDATE_UNSUPPORTED)	statusTxt="?";
		else if (status.code == RES_STATUS_FAILED)		statusTxt ="error";
		else statusTxt="?";
		data.value = statusTxt;

		cacheItem.ImportColumns().Save();

	} catch(e){
	  out.xit("SEVERE ERROR: " + e.toString());
	}

	out.trc("",-1);
}
///////////////////////////////////////////////////////////////////////////////
function Column_ScriptEnabled_Single(data) {
	if (data.item.is_dir) return;
	if (!ResParser.ValidateExtension(data.item.name, false, true)) return;
	if (Script.Config["Log.What.Columns"]) out.mute(false); else out.mute(true);

	out.trc("Column_ScriptEnabled_Single(): ["+data.item.name+"]",1);

	try{
		var scriptDetails = ResParser.GetDOScriptConfigDetails(""+data.item.realpath);
		if (scriptDetails.enabled===true)	data.value = t("column.enabled.yes");
		if (scriptDetails.enabled===false)	data.value = t("column.enabled.no");
		if (scriptDetails.enabled===null)	data.value = "?";
	} catch(e){
		out.err(e);}

	out.trc("",-1);
}
///////////////////////////////////////////////////////////////////////////////
function Column_ScriptDetails_Multi(data) {
	if (data.item.is_dir) return;
	if (!ResParser.ValidateExtension(data.item.name, false, true)) return;
	if (Script.Config["Log.What.Columns"]) out.mute(false); else out.mute(true);
	out.trc("Column_ScriptDetails_Multi(): ["+data.item.name+"]",1);

	ColCache.Initialize( data, ["Name", "Description", "Copyright", "Version", "MinVersion", "Modified", "Url", "Info"]);
	var cacheItem = ColCache.LookupItem(data.item);
	if (!cacheItem || cacheItem.isModified || cacheItem.isExpired){
		out.dmp("Creating new item");
		cacheItem = ColCache.CreateItem(data.item, cacheItem);
	}

	out.dmp("    Modified: " + cacheItem.isModified);
	out.dmp("    Expired : " + cacheItem.isExpired + ", expires in " + cacheItem.ExpirationHours() + " hours." );

	if (cacheItem.GetColumn("Name")!==undefined){
		out.dmp("Using cached column values");
		cacheItem.ExportColumns();
		out.trc("",-1);
		return;
	}
	out.dmp("*NOT* using cached item values, getting fresh values");

	try{
		ColCache.SetColumns("");
		out.mute(false);
		try{
			var res = ResParser.Load(data.item.realpath);
		} catch(e){
			out.err(e);
			out.trc("",-1);
			return;
		}

		if (res.name)				data.columns("Name").value = res.name;
		if (res.desc)				data.columns("Description").value = res.desc;
		if (res.copyright)			data.columns("Copyright").value = res.copyright;
		if (res.version)			data.columns("Version").value = res.version;
		if (res.minVersion)			data.columns("MinVersion").value = res.minVersion;
		if (res.modified===false)	data.columns("Modified").value = t("column.modified.no");
		if (res.modified===true)	data.columns("Modified").value = t("column.modified.yes");
		if (res.modified===null)	data.columns("Modified").value = t("column.modified.unknown");
		if (res.url)				data.columns("Url").value = res.url;

		if (!res._urlInternal)
			data.columns("Info").value = ERRMSGS[ERR_RES_NORESURL].replace("Unsupported: ","")+"!";

		if (Script.Config["Log.What.Columns"]) out.mute(false); else out.mute(true);
		cacheItem.ImportColumns().Save();

	} catch(e){
	  out.xit("SEVERE ERROR: " + e);
	}

	out.trc("",-1);
}
///////////////////////////////////////////////////////////////////////////////
function ColumnCache(id, enabled, msExpired, persistent, columnNames){
	this.version		= 0.6;
	this.versionData	= 0.5;
	this.log			= false;
	this.data			= null;
	this.enabled		= (enabled===undefined) || enabled;
	this.initialized	= false;
	this.persistent		= (persistent===undefined) || persistent;
	this.id				= id;
	this.varName		= "Script.ColumnCache."+this.id;
	this.msExpired		= (msExpired==undefined?7*86400000/*7 days*/:msExpired);
	this.columnNamesAll	= [];
	this.columnNames	= [];
	this.columnsHash	= "";

	this.cacheData			= null;
	this.cacheRoot			= null;

	this.CACHE_DATA			= 0;
	this.CACHE_DATA_VERSION	= 1;
	this.CACHE_DATE_CREATED	= 2;
	this.CACHE_COLUMNSHASH	= 3;

	this.ITEM_ID            = 0;
	this.ITEM_TYPE          = 1;
	this.ITEM_DATE_MODIFIED = 2;
	this.ITEM_DATE_ADDED    = 3;
	this.ITEM_COLVALUES     = 4;
	///////////////////////////////////////////////////////////////////////////
	this.Item = function(id){
		this.log			= false;
		this.cache          = null;
		this.id             = "";
		this.index          = null;
		this.type           = "";
		this.dateCreated    = new Date().getTime();
		this.dateModified   = "";
		this.isExpired      = null;
		this.colValues      = null;
		///////////////////////////////////////////////////////////////////////
		this.ExpirationHours = function(){
			return ((this.cache.msExpired-(new Date().getTime()-this.dateCreated))/60/60/1000).toFixed(2);
		}
		///////////////////////////////////////////////////////////////////////
		this.GetColumn = function(columnName){
			if (!this.cache.initialized){ this.log&&out.xit("Item.GetColumn(), Cache not initialized",-1); out.trc("",-1); return this; }
			//if (!this.cache.enabled){ this.log&&out.dmp("Item.GetColumn(), Cache not enabled"); out.trc("",-1); return this; }
			var index = this.cache.columnNamesAll[columnName];
			if (index!==undefined && index<this.colValues.length){
				return this.colValues(index);
			} else {
				this.log&&out.err("GetColumn() failed for column ["+columnName+"], index ["+index+"], colValues.length ["+this.colValues.length+"]");
			}
			return undefined;
		}
		///////////////////////////////////////////////////////////////////////
		this.SetColumn = function(columnName, columnValue, silent){
			if (!this.cache.initialized){ this.log&&out.xit("Item.SetColumn(), Cache not initialized",-1); out.trc("",-1); return this; }
			if (!this.cache.enabled){ this.log&&out.dmp("Item.SetColumn(), Cache not enabled"); out.trc("",-1); return this; }
			var index = this.cache.columnNamesAll[columnName];
			if (index!==undefined){
				if (!(index<this.colValues.length))
					out.wrn("    SetColumn(), Index out of bounds (adding field), column ["+columnName+"], index ["+index+"], value ["+columnValue+"]");
				if (!silent) out.dmp("SetColumn(), column ["+columnName+"], index ["+index+"], value ["+columnValue+"]");
				this.colValues(index) = columnValue;
			} else {
				out.err("    SetColumn() failed for column ["+columnName+"], index ["+index+"], colValues.length ["+this.colValues.length+"]");
			}
		}
		///////////////////////////////////////////////////////////////////////
		this.Save = function(){
			this.log&&out.trc("Save():",1);
			if (!this.cache.initialized){ this.log&&out.xit("Item.Save(), Cache not initialized",-1); out.trc("",-1); return this; }
			if (!this.cache.enabled){ this.log&&out.dmp("Item.Save(), Cache not enabled"); out.trc("",-1); return this; }
			this.log&&out.dmp("CacheData length: " + this.cache.cacheData.length);
			if (this.index===null){
				this.index = this.cache.cacheData.length;;
				this.log&&out.dmp("New item index: " + this.index);
				this.cache.cacheData(this.index) = DOpus.Create.Vector();
				this.cache.cacheData(this.index)(this.cache.ITEM_ID) = this.id;
				this.cache.cacheData(this.index)(this.cache.ITEM_TYPE) = this.type;
			}
			this.cache.cacheData(this.index)(this.cache.ITEM_DATE_ADDED) = this.dateCreated;
			this.cache.cacheData(this.index)(this.cache.ITEM_COLVALUES) = this.colValues;
			this.cache.cacheData(this.index)(this.cache.ITEM_DATE_MODIFIED) = this.dateModified;
			this.log&&out.trc("",-1);
		}
		///////////////////////////////////////////////////////////////////////
		this.ImportColumns = function() {
			this.log&&out.trc("ImportColumns():",1);
			if (!this.cache.initialized){ this.log&&out.xit("Item.ImportColumns(), Cache not initialized",-1); out.trc("",-1); return this; }
			if (!this.cache.enabled){ this.log&&out.dmp("Item.ImportColumns(), Cache not enabled"); out.trc("",-1); return this; }
			this.log&&out.dmp("Columns regged ["+this.cache.columnNamesAll.length+"], current ["+this.cache.columnNames.length+"], cached ["+this.colValues.length+"]");
			for(var n=0;n<this.cache.columnNamesAll.length;n++){
				var columnName, colNamePadded; columnName = colNamePadded = this.cache.columnNamesAll[n];
				while (!out._muted && colNamePadded.length<16) colNamePadded+=" ";
				var output = "Column ["+colNamePadded+"], index ["+this.cache.columnNamesAll[columnName]+"], ";
				var value = undefined;
				if (this.cache.columnNames[columnName]===undefined){
					this.log&&out.dmp(output+ "skipped (not inited)");
					continue;
				}
				//out.dmp(output+"setting value [" + value + "]");
				value = this.cache.GetColumn(columnName, true); //silent
				this.log&&out.dmp(output+"setting value ["+value+"]");
				this.SetColumn(columnName, value, true); //silent
			}
			this.log&&out.trc("",-1);
			return this;
		}
		///////////////////////////////////////////////////////////////////////
		this.ExportColumns = function(){
			this.log&&out.trc("ExportColumns():",1);
			if (!this.cache.initialized){ this.log&&out.xit("ExportColumns(), Cache not initialized",-1); out.trc("",-1); return this; }
			if (!this.cache.enabled){ this.log&&out.dmp("ExportColumns(), Cache not enabled"); out.trc("",-1); return this; }

			this.log&&out.dmp("Columns regged ["+this.cache.columnNamesAll.length+"], current ["+this.cache.columnNames.length+"], cached ["+this.colValues.length+"]");
			for(var n=0;n<this.cache.columnNamesAll.length;n++){
				var columnName, colNamePadded; columnName = colNamePadded = this.cache.columnNamesAll[n];
				while (!out._muted && colNamePadded.length<16) colNamePadded+=" ";
				var output = "Column ["+colNamePadded+"], index ["+this.cache.columnNamesAll[columnName]+"], ";
				if (this.cache.columnNames[columnName]===undefined){
					this.log&&out.dmp(output+ "skipped (not inited)");
					continue; //column not in current columns
				}
				if (n<this.colValues.length){
					var value = this.colValues(n);
					this.log&&out.dmp(output+"setting value [" + value + "]");
					this.cache.SetColumn(columnName, value, true /*silent*/);
				} else {
					out.wrn(output+"ExportColumn failed (index not found in cache data) n ["+n+"], length ["+this.colValues.length+"]");
				}
			}
			this.log&&out.trc("",-1);
			return true;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.CreateItem = function(doItem, cacheItemExpired){
		var item            = new this.Item(id);
		item.cache          = this;
		item.log			= this.log;
		item.id             = String(doItem.realpath);
		item.type           = (doItem.is_dir?"folder":"file");
		item.dateModified   = ""+doItem.modify_utc;
		item.colValues      = DOpus.Create.Vector(this.columnNamesAll.length);
		if (cacheItemExpired) item.index = cacheItemExpired.index;
			return item;
	}
	///////////////////////////////////////////////////////////////////////////
	this._RegisterColumns = function( columns ){
		if (!columns) throw "Bad parameter, bad or missing array of column names";
		this.columnNamesAll = columns;
		for(var n=0;n<this.columnNamesAll.length;n++){
			var colName = this.columnNamesAll[n];
			this.columnNamesAll[colName]    = n;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.Initialize = function( data, columns ){
		this.log&&out.trc("ColumnCache.Initialize(): ["+this.id+"]",1);

		/*if (!this.enabled){
			this.log&&out.dmp("Cache not enabled"); out.trc("",-1);
			return false;
		}*/
		this.data = data;

		//if no column(s) passed or single col mode, use default column
		if (!columns || !this.data.columns){
			var colName = data.col;
			this.columnNames = [colName];
			this.columnNames[colName] = 0;
		} else {
			this.columnNames = columns;
			for(var n=0;n<columns.length;n++){
				var colName = this.columnNames[n];
				this.columnNames[colName] = n;
			}
		}
		this.log&&out.dmp("Columns: " + this.columnNames);

		if (this._ValidateColumns())
			if (!this.initialized) this._InitCreate();

		this.log&&out.trc("",-1);
		return this.initialized;
	}
	///////////////////////////////////////////////////////////////////////////
	this._InitCreate = function(createCacheIfNotExists){
		this.log&&out.trc("_InitCreate():",1);
		if (createCacheIfNotExists===undefined) createCacheIfNotExists = true;
		this.log&&out.dmp("Create cache    : " + createCacheIfNotExists);

		if (this.initialized){
			this.log&&out.dmp("already initialized");
			this.log&&out.trc("",-1);
			return true;
		}

		if (this.columnNamesAll.length==0 && this.enabled){
			out.xit("No column names registered, use RegisterColumns() first!");
			this.log&&out.trc("",-1);
			return false;
		}

		this.columnsHash = this.columnNamesAll.join(";").toLowerCase();

		if (!DOpus.Vars.Exists(this.varName)){
			this.log&&out.dmp("Cache not exists");
			if (createCacheIfNotExists){
				this.log&&out.dmp("    creating..");
				this.cacheRoot = DOpus.Create.Vector();
				DOpus.Vars.Set(this.varName, this.cacheRoot);
				this.cacheRoot(this.CACHE_DATA) = DOpus.Create.Vector();
				this.cacheRoot(this.CACHE_DATA_VERSION) = this.versionData;
				this.cacheRoot(this.CACHE_DATE_CREATED) = new Date().getTime();
				this.cacheRoot(this.CACHE_COLUMNSHASH) = this.columnsHash;
				this.cacheData = this.cacheRoot(this.CACHE_DATA);
				this.initialized = true;
			}
		} else {
			this.log&&out.dmp("Cache already exists");
			try{
				var cacheRootVar = DOpus.Vars(this.varName);
				if (cacheRootVar(this.CACHE_DATA_VERSION) != this.versionData)
					throw new Error("Cache data version mismatch, ver ["+this.versionData+"], cached ver ["+cacheRootVar(this.CACHE_DATA_VERSION)+"]");
				if (this.enabled && cacheRootVar(this.CACHE_COLUMNSHASH) != this.columnsHash){
					out.wrn("Number or names of columns mismatch, hash ["+this.columnsHash+"], cached hash ["+cacheRootVar(this.CACHE_COLUMNSHASH)+"]");
					//throw new Error("Number or names of columns mismatch, hash ["+this.columnsHash+"], cached hash ["+cacheRootVar(this.CACHE_COLUMNSHASH)+"]");
				}
			} catch(e){
				this.log&&out.inf("Clearing existing cache: " + e.message);
				this.Clear();
				this.log&&out.trc("ReInitializing..",-1);
				return this._InitCreate(createCacheIfNotExists);
			}
			cacheRootVar.persist = this.persistent && DOpus.Version.AtLeast("11.8.3");
			this.log&&out.dmp("CacheDataVersion: " + cacheRootVar(this.CACHE_DATA_VERSION));
			this.log&&out.dmp("CachePersistent : " + cacheRootVar.persist);
			this.cacheRoot = cacheRootVar.value;
			this.cacheData = cacheRootVar(this.CACHE_DATA);
			this.initialized = true;
		}
		this.log&&out.dmp("Initialized     : " + this.initialized);
		this.log&&out.trc("",-1);
		return this.initialized;
	}
	///////////////////////////////////////////////////////////////////////////
	this._ValidateColumns = function(){
		this.log&&out.trc("_ValidateColumns():",1);
		if (!this.data) return false;
		var columnsValid = true;
		for(var n=0;n<this.columnNames.length;n++){
			var columnName = this.columnNames[n];
			if (this.columnNamesAll[columnName]===undefined){
				out.err("Column ["+columnName+"] not registered");
				columnsValid = false;
			}
		}
		this.log&&out.trc("",-1);
		return columnsValid;
	}
	///////////////////////////////////////////////////////////////////////////////
	this.SetColumn = function (columnName, value, silent){
		silent = silent || false;
		if (!this.data.columns){
			this.data.value = value;
			if (!silent) this.log&&out.dmp("SetSingle Column ["+columnName+"] = " + value);
			return;
		}
		try{
			this.data.columns(columnName).value = value;
			if (!silent) this.log&&out.dmp("SetMulti Column ["+columnName+"] = " + value);
		}
		catch(e){
			if (e.number == -2146828279) //index out of bounds
				out.err("SetMulti Column ["+columnName+"] is an undefined DO column, cannot set value")
			else
				throw new Error(e);
		}
	}
	///////////////////////////////////////////////////////////////////////////////
	this.SetColumns = function (value){
		this.log&&out.trc("SetColumns():",1);
		value = value || "";
		for(var n=0;n<this.columnNames.length;n++)
			this.SetColumn(this.columnNames[n], value);
		this.log&&out.trc("",-1);
	}
	///////////////////////////////////////////////////////////////////////////////
	this.GetColumn = function (columnName, silent){
		silent = silent || false;
		var value = undefined;
		if (!this.data.columns){
			value = this.data.value;
			if (!silent) this.log&&out.dmp("GetSingle Column ["+columnName+"] = " + value);
			return value;
		}
		try{
			value = this.data.columns(columnName).value;
			if (!silent) this.log&&out.dmp("GetMulti Column ["+columnName+"] = " + value);
		}
		catch(e){
			if (e.number == -2146828279) //index out of bounds
				out.err("GetMulti Column ["+columnName+"] is an undefined DO column, cannot get value")
			else
				throw new Error(e);
		}
		return value;
	}
	///////////////////////////////////////////////////////////////////////////
	this.LookupItem = function( doItem ){
		if (!this.enabled) return null;
		if (!this.initialized) return null;
		var itemID, itemIDShort; itemID = itemIDShort = String(doItem.realpath);
		if (itemIDShort.length > 80) itemIDShort = ".."+itemID.substring(itemID.length-80);

		this.log&&out.trc("ColumnCache.LookupItem(): ["+itemIDShort+"]",1);
		for (var v=0;v<this.cacheData.length;v++){
			var cacheItem = this.cacheData(v);
			if (cacheItem(this.ITEM_ID) == itemID){
				this.log&&out.dmp("found");
				//out.dmp("CACHEITEM MODIFIED: " + cacheItem(this.ITEM_DATE_MODIFIED));
				//out.dmp("DATAITEM MODIFIED : " + doItem.modify_utc);
				//out.dmp("MODIFIED       ?: " + (""+cacheItem(this.ITEM_DATE_MODIFIED)!=""+doItem.modify_utc));
				out.trc("",-1);
				var item = new this.Item(cacheItem(this.ITEM_ID));
				item.index          = v;
				item.type           = cacheItem(this.ITEM_TYPE);
				item.dateCreated    = cacheItem(this.ITEM_DATE_ADDED);
				item.colValues      = cacheItem(this.ITEM_COLVALUES);
				item.isExpired      = (new Date().getTime()-cacheItem(this.ITEM_DATE_ADDED))>this.msExpired;
				item.dateModified   = cacheItem(this.ITEM_DATE_MODIFIED);
				item.isModified     = cacheItem(this.ITEM_DATE_MODIFIED)+""!=""+doItem.modify_utc;
				item.cache          = this;
				return item;
			}
		}
		this.log&&out.dmp("not found");
		this.log&&out.trc("",-1);
		return null;
	}
	///////////////////////////////////////////////////////////////////////////
	this.Compact = function(){
		this.log&&out.trc("ColumnCache.Compact(): ["+this.id+"]",1);
		if (!this.initialized){
			//do not create cache if not exists
			this._InitCreate(false);
		}
		if (!this.initialized){
			this.log&&out.inf("Cache is not initialized (maybe does not exist yet)");
			this.log&&out.dmp("failed");
			this.log&&out.trc("",-1);
			return false;
		}
		this.log&&out.dmp("Testing indexes [0-"+this.cacheData.length+"]..");
		for (var v=0;v<this.cacheData.length;v++){
			var cacheItem = this.cacheData(v);
			switch(cacheItem(this.ITEM_TYPE)){
				case "file":
				case "folder":
					if (!DOpus.FSUtil.Exists(cacheItem(this.ITEM_ID))) {
						this.log&&out.dmp("    Erasing index ["+v+"], item ["+cacheItem(this.ITEM_ID)+"]");
						this.cacheData.erase(v--);
					}
			}
		}
		this.log&&out.dmp("succeeded");
		this.log&&out.trc("",-1);
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	this.Clear = function(){
		out.trc("Clear():",1);
		if (DOpus.Vars.Exists(this.varName)){
			out.put("Deleting global variable ["+this.varName+"]");
			DOpus.Vars.Delete(this.varName);
		} else {
			out.put("Global variable ["+this.varName+"] not found, cache has not been used");
		}
		out.trc("",-1);
	}
	///////////////////////////////////////////////////////////////////////////
	out.trc("ColumnCache():",1);
	out.dmp("CacheID: " + this.id);
	out.dmp("Version: " + this.version);
	out.dmp("Enabled: " + this.enabled);
	out.dmp("Persist: " + this.persistent);
	out.dmp("Expire : " + this.msExpired + " ("+
		(this.msExpired/86400000).toFixed(2) + " days, "+
		(this.msExpired/3600000 ).toFixed(2) + " hours, "+
		(this.msExpired/60000   ).toFixed(2) + " mins, "+
		(this.msExpired/1000    ).toFixed(2) + " secs)");
	if (columnNames)
		this._RegisterColumns(columnNames);
	out.dmp("Columns: " + this.columnNamesAll);
	out.trc("",-1);
}
///////////////////////////////////////////////////////////////////////////////
function Translator(gThis){
	this.version = 0.21;
	this.lang = "en";
	if (!gThis.Translator.translations){
		gThis.Translator = this;
		this.translations = {en:{}};
		///////////////////////////////////////////////////////////////////////////
		gThis.t = function(textID){
			function translate(textID, splitter, values){
				var text = "", textIDs = textID.split(splitter);
				for(var ti=0;ti<textIDs.length;ti++){
					textID = textIDs[ti].replace(/^\s+/g,'').replace(/\s+$/g,'');
					if (textID.indexOf("+")!=-1){
						var textTmp = translate(textID, "+", values);
					} else {
						var textTmp = Translator.translations[Translator.lang][textID];
						if (!textTmp) textTmp = Translator.translations["en"][textID];
						if (!textTmp) textTmp = "na:"+textID+"."+Translator.lang;
						for(var a=0;a<values.length;a++)
							textTmp = textTmp.replace("%s", values[a]);
					}
					text += textTmp + (ti+1<textIDs.length?splitter:"");
				}
				return text;
			}
			var args = [];
			for(var a=1;a<arguments.length;a++)
				args[args.length] = arguments[a];
			return translate(textID, "|", args);
		}
		///////////////////////////////////////////////////////////////////////////
		gThis.tc = function(column){ //translate column
			var colName = new String(column.name).toLowerCase();
			column.header = t("column."+colName+".header");
			column.label = t("column."+colName+".label");
		}
	}
	///////////////////////////////////////////////////////////////////////////
	this.SetLanguage = function(lang){
		this.lang = String(lang).toLowerCase().substring(0,2);
		if (!this.translations[this.lang]) this.translations[this.lang] = {};
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this.AddT = function( lang, translations){
		lang = String(lang).toLowerCase().substring(0,2);
		this.translations[lang] = this._MergeObjects(this.translations[lang], translations);
		return this;
	}
	///////////////////////////////////////////////////////////////////////////
	this._MergeObjects = function() {
		var obj = {}, i = 0, il = arguments.length, key;
		for (; i < il; i++) {
			for (key in arguments[i]) {
				if (arguments[i].hasOwnProperty(key)) {
					obj[key] = arguments[i][key];
				}
			}
		}
		return obj;
	};
	///////////////////////////////////////////////////////////////////////////
	this.SetLanguage(DOpus.language);
	//this.SetLanguage("de");
}
///////////////////////////////////////////////////////////////////////////////
function RemoveDeprecatedVersions(){
	var scriptsPath = DOpus.FSUtil.Resolve("/dopusdata\\script addins");
	var names = [	"Command.Generic_ScriptHelper.js",
					"Command.Generic_ScriptHelper.js.txt",
					"Command.Generic.ScriptHelper.js",
					"Command.Generic.ScriptHelper.js.txt"];
	try{
		for(var i=0;i<names.length;i++){
			var deprecatedScriptPath = scriptsPath+"\\"+names[i];
			if (ResParser.fso.FileExists(deprecatedScriptPath))
				ResParser.fso.DeleteFile(deprecatedScriptPath);
		}
	} catch(e){
		out.err("Could not remove deprecated script version");
	}
}
///////////////////////////////////////////////////////////////////////////////
function DumpObject(o){
	var maxLen = 0;
	for(prop in o)
		if (prop.length > maxLen) maxLen = prop.length;
	for(prop in o){
		var pad = ""; while (pad.length+prop.length<maxLen) pad+=" ";
		DOpus.Output("    "+prop.toUpperCase()+pad+": "+o[prop]);
	}
}
///////////////////////////////////////////////////////////////////////////////
function DumpVector( v, pad){
	pad = pad || "";
	for(var vIndex=0;vIndex<v.length;vIndex++){
		try{
			if (v(vIndex).count == undefined) throw "no vector";
			DOpus.Output(pad+vIndex+" vector["+v(vIndex).count+"]");
			DumpVector( v(vIndex), "    "+pad);
		}
		catch(e){
			DOpus.Output(pad+vIndex+" "+v(vIndex));
		}
	}
}
//MD5 = "93305049523679a6df43f828562b5f6d"; DATE = "2016.08.05 - 21:12:33"