var XLog = 'd';

//todo: moved/renamed items from level x to level y
//todo01: split status line at " -> " coming from git and create two
//        separate entries for renamed/moved items (for native status as well)

// v0.3
// - added native status column (showing unmodified status indicators out of "git status .." output

///////////////////////////////////////////////////////////////////////////////
function OnInit(data) {
	//uid added via script wizard (do not change after publishing this script)
	var uid = "464E82F7-079B-4CC6-B71D-1CE60E3ABBCB";
	//thread url added via script wizard (required for updating)
	var url = "https://resource.dopus.com/t/column-git/29230";
    data.name = "Column.Generic: Git";
    data.desc = "Git columns.";
	data.version = "0.3";
    data.default_enable = true;
	if (DOpus.Version.AtLeast("11.8.2")) data.log_prefix = "GIT ";

	///////////////////////////////////////////////////////////////////////////
	function ConfigHelper(data){ //v1.2
		var t=this; t.d=data; t.c=data.config; t.cd=DOpus.Create.Map();
		t.add=function(name, val, des){ t.l={n:name,ln:name.
			toLowerCase()}; return t.val(val).des(des);}
		t.des=function(des){ if (!des) return t; if (t.cd.empty)
			t.d.config_desc=t.cd; t.cd(t.l.n)=des; return t;}
		t.val=function(val){ var l=t.l; if (l.v!==l.x&&typeof l.v=="object")
			l.v.push_back(val);else l.v=t.c[l.n]=val;return t;}
		t.trn=function(){return t.des(t("script.config."+t.l.ln));}}
	var cfg = new ConfigHelper(data);
	///////////////////////////////////////////////////////////////////////////
	var cfg = new ConfigHelper(data);

	cfg.add('XLog',									DOpus.Create.Vector()).
		val(5).val("Off").val("Exception").val("Error").val("Warning").val("Info").val("Normal").val("Trace").val("Dump").val("All").
		des('Console output level. The higher, the more output will be visible in the console window. ');

	cfg.add("Git.exe",								"").
		des("Path to Git.exe. Leave empty to use Git.exe somewhere in your %path%.");

	cfg.add("Column.Status.Header",					"Git-Status").
		des("Header of status column.");

	cfg.add("Column.Status.Text.Unchanged",			"-").
		des("Column value for unchanged git status.");

	cfg.add("Column.Status.Text.Unknown",			"?").
		des("Column value for items outside of git repos.");

	cfg.add("Column.Status.Text.Repository",		"Git Repository").
		des("Column value for git repos.");

	cfg.add("Column.StatusNative.Header",			"Git-Status (native)").
		des("Header of native status column.");

	cfg.add("Cache.ExpirationTimeSpan",				2000).
		des("Time in milliseconds for cached repository status to expire.");
}
///////////////////////////////////////////////////////////////////////////////
var COMMAND_FAILURE = true;
var COMMAND_USERABORT = true;
var COMMAND_BADPARAMS = true;
var COMMAND_SUCCESS = false;
var gThis = this;
///////////////////////////////////////////////////////////////////////////////
String.prototype.lTrim = function(chr){chr=chr||"\\s";return new String(this.replace(new RegExp("^"+chr+"*"),''));}
String.prototype.rTrim = function(chr){chr=chr||"\\s";return new String(this.replace(new RegExp(chr+"*$"),''));}
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);}
///////////////////////////////////////////////////////////////////////////////
var template =
	//main features..
	"REFRESHCOLS/S,"+
	//shared misc
	"NOFAIL/S,NODESELECT/S,XLOG/O[off,xit,error,warning,info,<normal>,trace,dump,all]";

///////////////////////////////////////////////////////////////////////////////
function OnAddCommands(data){
	Log("Git.OnAddCommands():", "t", 1);

	var cmd = data.AddCommand();
    cmd.name = "Git";
    cmd.method = "Command_Git";
    cmd.desc = "Git";
    cmd.label = "Git";
	cmd.template = template;

	Log("-", "t", -1);
}
///////////////////////////////////////////////////////////////////////////////
function Command_Git(data){
	var args = ArgsMagic(data, null, template), result = null;
	//DumpObject(args); //return;

	if (args["XLOG"].exists){ 				XLog =		args["XLOG"].value; } Log("CmdLine: " + data.cmdline,"d");
	if (args["NODESELECT"].exists)			data.func.command.deselect	= false;

	if (args["NOFAIL"].exists)				COMMAND_FAILURE				= COMMAND_SUCCESS;

	if (0);
	//else if (args["CHECKOUT"].exists)		return		Command_Git_CHECKOUT(data.func.command, data.func.sourcetab, args);
	else if (args["REFRESHCOLS"].exists)	return		Command_Git_REFRESHCOLS(args);

	if (result===null){
		Log("Bad/incomplete params.","X");
		return COMMAND_BADPARAMS;
	}

	return result;
}
///////////////////////////////////////////////////////////////////////////////
function SetBusy(){
	DOpus.Vars.Set("Script.Git.IsBusy", true);
	DOpus.Create.Command.UpdateToggle();
}
///////////////////////////////////////////////////////////////////////////////
function SetNoBusy(){
	DOpus.Vars.Delete("Script.Git.IsBusy");
	DOpus.Create.Command.UpdateToggle();
}
///////////////////////////////////////////////////////////////////////////////
function Command_Git_REFRESHCOLS(args){
	RefreshColumns();
}
///////////////////////////////////////////////////////////////////////////////
function RefreshColumns(){
	Log("RefreshColumns():", 't');
	Script.RefreshColumn("Status");
}
///////////////////////////////////////////////////////////////////////////////
function RunHiddenAdvanced( exe, params, tmpFileBase, tmpFileExt, shell, fso){
	//v0.5 - only check for existing exe if path given
	///////////////////////////////////////////////////////////////////////////
	function ReadFile( path, fso ){
		Log("ReadFile():", "t", 1);
		fso = fso || new ActiveXObject("Scripting.FilesystemObject");
		var content = "";
		if (!fso.FileExists(path)){
			Log("ReadFile(), file ["+path+"] not found.", "e");
			Log("-", "t", -1);
			return content;
		}
		Log("ReadFile(), opening ["+path+"]..", "d");
		var file = fso.OpenTextFile( path, 1, -2); // Read, UseDefaultEncoding
		if (!file.AtEndOfStream) content = file.ReadAll();
		file.Close();
		Log("-", "t", -1);
		return content;
	}
	///////////////////////////////////////////////////////////////////////////
	function CreateTmpFileName(prefix, extension, fso) {
		if (!fso) fso = new ActiveXObject("Scripting.FilesystemObject");
		var tFolder = fso.GetSpecialFolder(2); // 2 = temp folder
		var tFile = fso.GetTempName();
		if (prefix!=undefined) tFile=prefix+tFile;
		if (extension!=undefined) tFile+=extension;
		return {
			path	: tFolder.Path,
			name	: tFile,
			fullname: tFolder.Path+'\\'+tFile
		};
	}
	///////////////////////////////////////////////////////////////////////////
	Log("RunHiddenAdvanced():", "t", 1);
	if (!fso)	fso		= new ActiveXObject("Scripting.FilesystemObject");
	if (!shell) shell	= new ActiveXObject("WScript.Shell");
	if (!tmpFileBase)	tmpFileBase = "DO.Temp.";
	if (!tmpFileExt)	tmpFileExt = ".txt";
	var tmpFileStdout = CreateTmpFileName(tmpFileBase, tmpFileExt, fso).fullname;
	var tmpFileStderr = tmpFileStdout+".err"+tmpFileExt;
	var cmd = '%comspec% /c ""'+exe+'" '+params+' >"'+tmpFileStdout+'" 2>"'+tmpFileStderr+'""';
	var result = {};
	result.cmd = cmd;
	Log("    CMD: "+cmd, 'd');
	if (exe.search(/^(\\\\.*|[a-z]\:|\/\/.*)/i)==0 && !fso.FileExists(exe)){
		var msg = "Executable not found ["+exe+"]";
		Log(msg, "e");
		Log("-", "t", -1);
		throw msg;
	}

	result.returncode = shell.Run( cmd, 0, true);

	Log("Return: "+result.returncode, "d");
	result.stdout = ReadFile(tmpFileStdout, fso); fso.DeleteFile(tmpFileStdout);
	result.stderr = ReadFile(tmpFileStderr, fso); fso.DeleteFile(tmpFileStderr);
	Log("-", "t", -1);
	return result;
}
///////////////////////////////////////////////////////////////////////////////
function OnAddColumns(data){
	var cols = new Array();
	var column = null;
	column = cols[cols.length] = data.AddColumn();
	column.name =	"Name";
	column.justify = "left";
	column.defwidth = "6px";

	column = cols[cols.length] = data.AddColumn();
	column.name =	"Status";
	column.header = Script.config["Column.Status.Header"];
	column.justify = "left";
	column.defwidth = "70px";

	column = cols[cols.length] = data.AddColumn();
	column.name =	"StatusNative";
	column.header = Script.config["Column.StatusNative.Header"];
	column.justify = "left";
	column.defwidth = "30px";

	column = cols[cols.length] = data.AddColumn();
	column.name =	"Type";
	column.justify = "right";
	column.defwidth = "50px";

	for(var c=0;c<cols.length;c++){
		cols[c].header = cols[c]['header'] ? cols[c]['header'] : cols[c].name;
		cols[c].label = "Git." + (cols[c]['label'] ? cols[c]['label'] : cols[c].name);
		cols[c].method = "Column_OnGitColumn";
		cols[c].multicol = true;
		cols[c].autogroup = true;
		cols[c].autorefresh = 2; //todo: true; //DO12 vs. DO11
		cols[c].namerefresh = true;
	}
}
///////////////////////////////////////////////////////////////////////////////
//intentionally global, so they live on between calls to Column_OnGitColumn()
var gitStatusCache	= null;
DOpus.Output("SCRIPT REINIT");
var fso				= new ActiveXObject("Scripting.FilesystemObject");
///////////////////////////////////////////////////////////////////////////////
function Column_OnGitColumn(data) {
	///////////////////////////////////////////////////////////////////////////
	function GetRepoRoot(data) {
		var itemPath = data.item.path+'';
		var repoRoot = '';

		if (gitStatusCache && gitStatusCache.path2RepoMap) {
			repoRoot = gitStatusCache.path2RepoMap[itemPath];
			if (repoRoot) return repoRoot; repoRoot = '';
		}

		var doPathTmp = DOpus.FSUtil.NewPath(itemPath);
		Log("Path: " + doPathTmp, "d");

		do {
			if (DOpus.FSUtil.exists(doPathTmp+"\\.git")) {
				repoRoot = doPathTmp+'';
				break;
			}
		} while (doPathTmp.parent());

		if (!gitStatusCache) gitStatusCache = {};
		if (!gitStatusCache.path2RepoMap) gitStatusCache.path2RepoMap = {};

		if (repoRoot)
			gitStatusCache.path2RepoMap[itemPath] = repoRoot;

		return repoRoot;
	}
	///////////////////////////////////////////////////////////////////////////
	function GetRepo(repoRootPath) {
		if (!repoRootPath) return null;
		if (!gitStatusCache) gitStatusCache = {};
		if (!gitStatusCache.repoCache) gitStatusCache.repoCache = {};
		var repo = gitStatusCache.repoCache[repoRootPath];
		if (repo) return repo;
		repo = {
			lastTime : 0,
			repoRoot : repoRootPath,
			status   : {},
			untrackedFolders : [],
			ignoredFolders : [],
			renamedItems : {},
			movedItems : {}
		}
		gitStatusCache.repoCache[repoRootPath] = repo;
		return repo;
	}
	///////////////////////////////////////////////////////////////////////////
	function GetRelativeRepoItemPath(item, repo) {
		var relRepoItemPath = (data.item.realpath+'').replace(repo.repoRoot+"\\","").replace(/\\/g,'/');
		if (data.item.is_dir) relRepoItemPath+='/';
		return relRepoItemPath;
	}
	///////////////////////////////////////////////////////////////////////////
	function FetchItemStatus(item, relRepoItemPath, repo) {
		var status = repo.status[relRepoItemPath], relFolderPath='';
		if (!status) {
			//do some path matching with all the remembered untracked folders
			//so we can show "untracked" status for single items below untracked folders
			for(var f=0;f<repo.untrackedFolders.length;f++) {
				relFolderPath = repo.untrackedFolders[f];
				if (relRepoItemPath.indexOf(relFolderPath)==0) {
					status = "untracked";
					break;
				}
			}
		}

		if (!status) {
			//do some path matching with all the remembered ingored folders
			//so we can show "ignored" status for single items below ignored folders
			for(var f=0;f<repo.ignoredFolders.length;f++) {
				relFolderPath = repo.ignoredFolders[f];
				if (relRepoItemPath.indexOf(relFolderPath)==0) {
					status = "ignored";
					break;
				}
			}
		}

		if (!status) {
			var oldName, parts;
			if (repo.renamedItems[relRepoItemPath]) {
				oldName	= repo.renamedItems[relRepoItemPath].trim('/');
				parts	= oldName.split('/');
				oldName	= parts[parts.length-1];
				status	= "renamed (" + oldName + ")";
			}
		}

		if (!status) {
			var oldLocation;
			if (repo.movedItems[relRepoItemPath]) {
				oldLocation	= repo.movedItems[relRepoItemPath].trim('/');
				status	= "moved (" + oldLocation + ")";
			}
		}

		if (!status && data.item.is_dir) {
			//empty folders will never show and cannot be added to a git repo
			//so they are basically "untracked" by default, they also do not show up
			//in "git status", so we check emptyness ourself and come up
			//with "untracked" here as well
			var folderEnum = DOpus.FSUtil.ReadDir(data.item.realpath);
			var emptyFolder = folderEnum.complete;
			if (emptyFolder) status = "untracked (empty)";
		}

		if (!status) status = Script.config["Column.Status.Text.Unchanged"];
		return status;
	}
	///////////////////////////////////////////////////////////////////////////
	function FetchItemStatusNative(item, relRepoItemPath, repo) {
		var status = repo.statusNative[relRepoItemPath];
		if (!status) return '';
		return status;
	}
	///////////////////////////////////////////////////////////////////////////

	//workaround for bug in v12.6.1
	//column function would be called for "no" column or something
	//DOpus.Output("ColCount: " + data.columns.count);
	if (data.columns.count==1) return COMMAND_FAILURE;
	if (!data.columns.count) return COMMAND_FAILURE;
	if (!data.columns.count) return COMMAND_FAILURE;
	if (!data.columns('Name')) return COMMAND_FAILURE;
	//end of workaround

	Log("Column_OnGitColumn("+data.col+"): "+data.item.name, "t", 1);
	SetBusy();

	data.columns('Name').value = data.item.name;
	data.columns('Type').value = data.item.is_dir ? "Folder" : "File";

	if ((data.item.realpath+'').search(/(\\|\/|^)\.git($|\\|\/).*?/)!=-1) {
		data.columns('Status').value = "git";
		Log("-", "t", -1);
		SetNoBusy();
		return COMMAND_SUCCESS;
	}

	var repoRoot	= GetRepoRoot(data);
	var repo		= GetRepo(repoRoot);

	if (!repo){
		data.columns('Status').value = Script.config["Column.Status.Text.Unknown"];
		if (DOpus.FSUtil.exists(data.item.realpath+"\\.git")) {
			data.columns('Status').value = Script.config["Column.Status.Text.Repository"];
		}
		Log("-", "t", -1);
		SetNoBusy();
		return COMMAND_FAILURE;
	}

	Log("Repo.lastTime: " + repo.lastTime, 't');

	var reload		= false;
	Log("RepoRoot: " + repo.repoRoot, "t");

	if (repo.lastTime == 0) {
		Log("Reload needed (first)", "t");
		reload = true;
	}

	curTime  = new Date().getTime(); //milliseconds
	if (!reload && (curTime-repo.lastTime)>Script.config['Cache.ExpirationTimeSpan']) {
		Log("Reload needed (expired)", "t");
		reload = true;
	}

	if (!reload) {
		Log("Skipping reload, column [" + data.col + "].", "t");
	} else {
		var result = FetchRepoStatus(data, repo, fso);
		if (result == COMMAND_FAILURE){
			SetNoBusy();
			Log("-", "t", -1);
			return COMMAND_FAILURE;
		}
	}

	var after = new Date().getTime(); //millis
	var relRepoItemPath = GetRelativeRepoItemPath(data.item, repo);
	data.columns('Status').value		= FetchItemStatus(data.item, relRepoItemPath, repo);
	data.columns('StatusNative').value	= FetchItemStatusNative(data.item, relRepoItemPath, repo);

	Log("-", "t", -1);
	SetNoBusy();
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function FetchRepoStatus(data, repo, fso) {
	Log('FetchRepoStatus('+data.col+')', 't', 1);
	DOpus.Output('Fetching repo ['+repo.repoRoot+']..');
	var gitExe = Script.config["Git.exe"] || "Git.exe";
	var result = RunHiddenAdvanced( gitExe, ' -C "'+data.item.path + '" status --ignored --porcelain', 'DO.GitColumn.', '.txt', null, fso);
	//Log("result.returncode  : " + result.returncode	, "d");
	//Log("result.stdout      : " + result.stdout		, "d");
	if (result.stderr || result.returncode) {
		Log('Error running git, code ['+result.returncode+'], msg ['+result.stderr+'].',"e");
		Log("-", "t", -1);
		return COMMAND_FAILURE;
	}

	repo.status = {};
	repo.statusNative = {};

	var lines = result.stdout.split("\n");
	var relRepoItemPath, line, status, isDir;

	for(var li=0;li<lines.length;li++) {
		line			= lines[li];
		isDir			= line.substring(line.length-1) == '/';
		status			= line.substring(0,2);
		relRepoItemPath	= line.substring(3)

		//file:///D:/bin/dev/Git/mingw64/share/doc/git-doc/git-status.html
		/*X          Y     Meaning
		-------------------------------------------------
			  [MD]   not updated
		M        [ MD]   updated in index
		A        [ MD]   added to index
		D         [ M]   deleted from index
		R        [ MD]   renamed in index
		C        [ MD]   copied in index
		[MARC]           index and work tree matches
		[ MARC]     M    work tree changed since index
		[ MARC]     D    deleted in work tree
		-------------------------------------------------
		D           D    unmerged, both deleted
		A           U    unmerged, added by us
		U           D    unmerged, deleted by them
		U           A    unmerged, added by them
		D           U    unmerged, deleted by us
		A           A    unmerged, both added
		U           U    unmerged, both modified
		-------------------------------------------------
		?           ?    untracked
		!           !    ignored
		-------------------------------------------------*/
		repo.statusNative[relRepoItemPath] = status.replace(/\s/g,'[ ]'); //surround blanks for eye-easyness

		if (0);
		else if (status=="!!") status = "ignored";
		else if (status==" M") status = "modified";
		else if (status=="??") status = "untracked";
		else if (status=="A ") status = "added";
		else if (status=="RM") status = "renamed, modified";
		else if (status=="R ") status = "renamed";

		repo.status[relRepoItemPath] = status; //todo01: should not get in there when renamed/moved (two paths in line)

		if (isDir && status == "untracked")	{
			//remember every untracked folder
			//untracked folders contain (must contain) only untracked items
			//untracked items on the other hand, will not show up in "git status"
			//only the upper most untracked folder will be listed as "untracked".
			//so we remember the untracked folders, do some path matching later and come
			//up with an "untracked" status for all items in untracked folders on our own
			repo.untrackedFolders.push(relRepoItemPath);
		}

		if (isDir && status == "ignored")	{
			//remember every untracked folder
			//untracked folders contain (must contain) only untracked items
			//untracked items on the other hand, will not show up in "git status"
			//only the upper most untracked folder will be listed as "untracked".
			//so we remember the untracked folders, do some path matching later and come
			//up with an "untracked" status for all items in untracked folders on our own
			repo.ignoredFolders.push(relRepoItemPath);
		}

		if (status.indexOf("renamed")!=-1) {
			delete repo.status[relRepoItemPath];
			//renames will only be displayed on files, folders are implicitely(?) renamed
			//path depth will always be equal for old / new if renamed, not moved
			//  case (folder): tmp/delme/readme.txt -> tmp/delmesoon/readme.txt *and*
			//  case (file)  : tmp/delme/readme.txt -> tmp/delme/readme2.txt
			var oldName='', newName='';
			var parts	= relRepoItemPath.split(" -> ");

			//if (parts[0].indexOf('/')!=-1 && parts[1].indexOf('/')!=-1) {

			oldNameParts = parts[0].split('/');
			newNameParts = parts[1].split('/');
			if (oldNameParts.length == newNameParts.length) { //renamed, no move (same depth)
				for(var p=0;p<oldNameParts.length;p++) {
					oldName += oldNameParts[p] + '/';
					newName += newNameParts[p] + '/';
					if (oldNameParts[p] != newNameParts[p]) break;
				}
				if (!isDir) { //trim last backlash if file
					oldName = oldName.rTrim('/');
					newName = newName.rTrim('/');
				}
				if (newName) repo.renamedItems[newName] = oldName;
				//trim backslashs on folders for output prettyness after storing names
				oldName = oldName.trim('/');
				newName = newName.trim('/');
				Log("Rename:", "d");
				Log("oldName           : " + oldName, "d");
				Log("newName           : " + newName, "d");
			} else { //moved
				delete repo.status[relRepoItemPath];
				status = 'moved';

				oldNameAndLocation = parts[0];
				newNameAndLocation = parts[1];
				repo.movedItems[newNameAndLocation] = oldNameAndLocation;
				oldNameAndLocation = oldNameAndLocation.trim('/');
				newNameAndLocation = newNameAndLocation.trim('/');
				var oldName = oldNameAndLocation.split('/').slice(-1)[0];
				var newName = newNameAndLocation.split('/').slice(-1)[0];
				if (oldName != newName) status = 'moved as';
				Log(status+":", "d");
				Log("oldNameAndLocation: " + oldNameAndLocation + " - " + oldName, "d");
				Log("newNameAndLocation: " + newNameAndLocation + " - " + newName, "d");
			}
		}
		//Log(relRepoItemPath + " = " + status + (isDir?" DIR":""), "d");
	}

	repo.lastTime = new Date().getTime(); //millis

	Log("-", "t", -1);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function ArgsMagic(data, jsonData, template){
	this.version = 0.42;
	///////////////////////////////////////////////////////////////////////////
	function Arg(name, type, exists, value, subOpsTemplate){
		this.name = name; this.exists = exists; this.type = type;
		this.value = value; this.options = []; if (!this.exists) return;
		switch (type){ case "switch":; case "numeric":; case "multiple": return;}
		if (this.type=="optional" && this.value===true) this.value="";
		var op,ops=this.value!=""?new String(this.value).split(","):null, match;
		if (ops && ops.length) for(op in ops) {
			var opName = ops[op].replace('"','');
			var opValue = true, parts = opName.split("=");
			opName = parts[0].trim("<").trim(">");
			if (parts.length>1)	opValue = parts.slice(1).join("");
			this.options[opName] = opValue;
		}
		if (!(!this.value && subOpsTemplate)) return;
		if (!(match = subOpsTemplate.match(/\<(.+?)\>/))) return;
		this.options[match[1]] = true; this.value = match[1];
	}
	///////////////////////////////////////////////////////////////////////////
	var types = {s:"switch",k:"keyword",o:"optional",n:"numeric",m:"multiple",r:"raw"};
	var names = template.replace(/\/(.)\,/g,"/$1;").replace(/\]\,/g,"];").split(";"), args = [];
	for(arg in names) {
		var parts = names[arg].split("/"); var name=parts[0].toUpperCase(), subOpsTemplate=null;
		var parts2 = parts[1].split("["); var type=parts2[0].toLowerCase();
		if (parts2.length>1) subOpsTemplate = parts2[1].substring(0,parts2[1].length-1);
		var exists=(data&&data.func.args.got_arg[name])||(jsonData&&(jsonData[name]!=undefined))||false;
		var value = (data && data.func.args[name]) || (jsonData && jsonData[name]) || undefined;
		args.push( args[name] = new Arg(name, types[type], exists, value, subOpsTemplate ));
	}
	///////////////////////////////////////////////////////////////////////////
	args.Get = function( argName, configName, noneValue){
		var arg = this[argName = argName.toUpperCase()];
		if (!arg) throw new Error(0, "Unknown parameter ["+argName+"]");
		if (arg.exists) return arg.value;
		//DOpus.Output("argName: " + argName);
		//DOpus.Output("configName: " + configName);
		if (!configName) return noneValue;
		if (typeof Script.config[configName] == "string")
			return new String(""+Script.config[configName]);
		return Script.config[configName];
	}
	return args;
}
///////////////////////////////////////////////////////////////////////////////
function Log(text, lvl, ind){ //XLog v0.41
    var u,lvs={o:0,x:1,e:2,w:3,i:4,n:5,t:6,d:7,a:8},i=["","X","E","W","I","","","",""];
	if (typeof XLog==(u="undefined")){var v=DOpus.Vars; if (v.Exists("XLog") && typeof XLogForce==u) {XLog=v.Get("XLog"); }}
	if (typeof XLog==u){var c=Script.Config; if(typeof c!="undefined" && typeof c.XLog!=u){ XLog=c.XLog; }}
	if (typeof XLog==u){XLog="normal";} if(XLog.paused===undefined){ if(XLog===true) var L=5;
	else if(!isNaN(parseInt(XLog,10))) var L=XLog*1; else var L=lvs[(""+XLog).substring(0,1)]; XLog={paused:false,I:0,L:L};}
	lvl=(lvl==undefined?5:lvs[lvl.substring(0,1).toLowerCase()]);
	if (!(lvl && XLog.L && !XLog.paused && (lvl<=XLog.L))){ return;} var pad = (XLog.I==0?"":new Array(XLog.I+1).join("    "));
	if (i[lvl])pad = i[lvl]+(!pad?"   ":pad.substring(1)); if (text!="-"){ var d=DOpus; if (d.Version.AtLeast("11.13.1"))
	d.Output(pad+text,((lvl==1||lvl==2)?1:0)); else d.Output(pad+text);}
	ind=(ind!==undefined?ind:0);XLog.I+=ind;if(XLog.I<0)throw new Error("XLog indent went sub-zero.");
}
///////////////////////////////////////////////////////////////////////////////
function DumpObject(o, name, upperCaseProps, self, level){
	var version = 0.4;
	name = name || "unnamed";
	if (self == undefined)
		DOpus.Output("DumpObject(): ["+name+"]");
	var maxLen = 0;
	upperCaseProps = upperCaseProps || false;
	self = self || false;
	level = level || "    ";

	for(prop in o)
		if (prop.length > maxLen) maxLen = prop.length;

	for(prop in o) {
		var pad = ""; while (pad.length+prop.length<maxLen) pad+=" ";
		propName = (upperCaseProps?prop.toUpperCase():prop);
		if (!o.hasOwnProperty(prop))
			continue;
		switch(typeof o[prop]) {
			case "function":
				DOpus.Output(level+propName+pad+": function(){}..");
			break;
			case "object":
				DOpus.Output(level+propName+pad+": "+o[prop]);
				DumpObject(o[prop], propName, upperCaseProps, false, level+"    ");
			break;
			default:
				DOpus.Output(level+propName+pad+": "+o[prop]);
		}
	}
}
///////////////////////////////////////////////////////////////////////////////
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('https://resource.dopus.com/t/command-scriptwizard-multipurpose-scripting-resources-aid/19326');}
	else
		cmd.RunCommand('ScriptWizard ABOUT WIN='+data.window+' FILE="'+Script.File+'"');
}
//MD5 = "5c675323e886fbfe2fc7d02bf0de250d"; DATE = "2018.06.28 - 17:15:28"