//v0.1 - o4/2o15
//- initial
//v0.3 - o5/2o15
//- new feature "ITEM", select item (supports full paths if the USEPATH switch is used,
//               which doesn't work with the native select)
//- new feature "TOVAR", save current selection to memory (persistent storage)
//- new feature "TOFILE", save current selection to file
//- new feature "FROMVAR", load selection from memory
//- new feature "NTH", select every n-th item
//- new feature "RANDOM", select items randomly (formerly known as SelectRandom script command)
//- new feature "LINEAR", select items linear (same as RANDOM, but not random o)
//- new feature "AUTO", trigger for autoselection (simulate onafterfolderchange)
//- new feature "SIMILARMETA", select files with similar meta data
//- new feature "SIMILARMETAJS", select files with similar meta data using a jscript snippet
//- new feature "FILTERDROP", un/select, un/hide items by choosing a filter from a dropdown
//- new feature "FILTERLIST", un/select, un/hide items by choosing (multiple) filters from a list
//- new switch "SKIPITEMSWITHPATH", skip items with paths when selecting from clip/file/mem
//- new switch "SKIPITEMSWITHOUTPATH", skip items with no path when selecting from clip/file/mem
//- new switch "USEPATH", select by full path instead of using only the names from clip/file/mem
//- new option "PT" = pass through, to pass arguments through to the native select command
//- new option "DESELECTNOMATCH", works like native DESELECTNOMATCH switch (deselects first)
//- new option "NODESELECT", works like native @nodeselect modifier
//- new option "APPEND", append selected items to files, memorized-variables, clipboard
//- new option "GO", switches folder to the first item in clip/file/memory before selecting
//- new option "MAKEVISIBLE", works like native MAKEVISIBLE switch (scroll into view),
//              but can also be used "standalone" to scroll to currently selected/checked items
//- new option "EXACT", works like native EXACT switch (do not interpret pattern-chars)
//- new option "XLOG", enable output and set level (defaults to normal if no value given)

//Includes generic/enhanced variants of following addins:
//- "SelectFromTxt (select files from text file)" (http://resource.dopus.com/viewtopic.php?f=35&t=23130)
//- "Select every nth files in a lister" (http://resource.dopus.com/viewtopic.php?f=3&t=20185)
//- "SelectRandom" (http://resource.dopus.com/viewtopic.php?f=35&t=23142)
//- "Auto-select items when entering folders" (http://resource.dopus.com/viewtopic.php?f=35&t=24306)
//- "Select by Filter buttons" (http://resource.dopus.com/viewtopic.php?f=35&t=22311)
//- "Select Similar Dimensions" menu button" (http://resource.dopus.com/viewtopic.php?f=35&t=22428)
//- "ScrollSelectionIntoView" (http://resource.dopus.com/viewtopic.php?f=35&t=22450)

//v0.4 - o5/2o15
//- removed unused code, minor tweaks
//- option SETTABVAR renamed to SETVAR
//- option SETENVVAR renamed to SETENV
//- new feature FROMVARDROP to easify picking of memorized selections

//v0.4.1 - o5/2o15
//- no need for a selected item when using SIMILARMETAJS

//v0.4.2 - o5/2o15
//- distance() function available for simple fuzzy selections
//- new OPTION "JSBREAK" for custom rules on when to stop item selection/picking
//- TOFILE and APPEND options now also work in conjunction with RANDOM/LINEAR

//v0.4.3 - o6/2o15
//- MAKEVISIBLE fixed, threw error in previous upload
//- JSBREAK finetuning: return true to stop item picking, false to skip item and null/undefined will select/pick
//- JSFILTER performance gain
//- Usage of Confighelper v1.2 and XLog 0.3

//v0.4.4 - o6/2o15
//- TOFILE/FROMFILE encoding-awareness added (did not always load selection-files correctly)
//- new script config "AutoSelect.DeselectNoMatch" to deselect automatically selected first file

//v0.4.5 - o6/2o15
//- the AUTO feature, to trigger auto-selection from commandline and not automatically by entering a folder, is now independent from the "AutoSelect" script configs (despite the list).
//That means you can disable AutoSelect and still use it occasionally from a "SelectEx AUTO" button. AutoSelect.MakeVisible/DeselectNoMatch also don't apply anymore if invoked manually (use the regular switches for that).

//issues
//- error message "Variable uses an Automation type not supported in JScript ..."
//  when using an /M type argument (desired for ITEM arg)
//-todo
//- re-test clearfiles() problem on data.func.command in top of SelectArrayItems()

///////////////////////////////////////////////////////////////////////////////
var template =
	//main features..
	"FROMCLIP/S,FROMFILE/K,FROMVAR/O,FROMVARDROP/S,TOCLIP/S,TOFILE/K,TOVAR/O,ITEM/K,NTH/K,RANDOM/S,LINEAR/S,AUTO/S,SIMILARMETA/K,"+
	"SIMILARMETAJS/K,FILTERDROP/O[<select>,deselect,hide,hidenomatch],FILTERLIST/O[<select>,deselect,hide,hidenomatch],MAKEVISIBLE/O[checked],"+
	//fromfile, fromclip, fromvar, fromvardrop
	"SKIPITEMSWITHPATH/S,SKIPITEMSWITHOUTPATH/S,EXACT/S,GO/S,GOPT/R,"+
	//fromfile, fromclip, fromvar, item
	"USEPATH/S,"+
	//tofile, tovar, toclip
	"APPEND/S,"+
	//random, linear
	"PATH/K,RECURSE/S,SETVAR/K,SETENV/K,FOLDERS/S,FILES/S,SINGLEFOLDER/S,SINGLEFOLDERMINCOUNT/K,"+
	"ITEMCOUNTRND/S,ITEMCOUNT/K,ITEMCOUNTPERC/K,ACTION/K,NAME/K,MINSIZE/K,MAXSIZE/K,MAXSIZETOTAL/K,"+
	"JSFILTER/K,JSBREAK/K,ECHO/S,COPYTOCOLL/K,COMMANDS/R,"+
	//shared misc
	"DESELECTNOMATCH/S,NODESELECT/S,XLOG/O[off,xit,error,warning,info,<normal>,trace,dump],PT/R"; //and MAKEVISIBLE
///////////////////////////////////////////////////////////////////////////////
function OnInit(data){
	//uid added via script wizard (do not change after publishing this script)
	var uid = "D6E6CF87-1FFB-4285-85F2-6C69727D2BD8";
	//resource center url added via script wizard (required for updating)
	var url = "http://resource.dopus.com/viewtopic.php?f=35&t=24414";
	data.name = "Command.Generic: SelectEx";
	data.log_prefix = "SelectEx";
	data.desc = "Extended Select command.";
	data.copyright = "tbone";
	data.version = "0.4.5";
	data.min_version = "11.5";
	data.default_enable = true;

	var cmd = data.AddCommand();
    cmd.name = "SelectEx";
    cmd.method = "Command_SelectEx";
    cmd.desc = data.desc;
    cmd.label = "SelectEx";
	cmd.template = template;
	///////////////////////////////////////////////////////////////////////////
	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);
	cfg.add('XLog',						DOpus.Create.Vector()).
		val(5).val("Off").val("Exception").val("Error").val("Warning").val("Info").val("Normal").val("Trace").val("Dump").
		des('Console output level. The higher, the more output will be visible in the console window. ');
	cfg.add('AutoSelect',					false).
		des('Enable automatic selection of items.');
	cfg.add('AutoSelect.MakeVisible',		true).
		des('Enable scrolling to automatically selected items.');
	cfg.add('AutoSelect.DeselectNoMatch',	true).
		des('Deselect items before automatic selection is applied (deselects automatically selected first file in folder if enabled e.g.).');
	cfg.add('AutoSelect.List',				DOpus.Create.Vector()).
		des('List of folder names and items to be selected automatically. '+
			'Paths and item names support regex if prefixed with "REGEX=", regular paths will be resolved (for aliases/env-vars).').
		val(';you can use ; or // or # to comment out lines').
		val(';syntax is: [REGEX=]<path> => [REGEX=]<item name>').
		val('').
		val(';standard path (select program files)').
		val('C:\\ => Program Files').
		val('').
		val(';alias for path and regex for item').
		val('/home => REGEX=dopus.exe|dopusrt.exe').
		val('').
		val(';env-var in path and regex for item (all log files)').
		val('%windir% => REGEX=.+\\.log$').
		val('').
		val(';using regex for the path').
		val('REGEX=.*\\\\drivers\\\\etc => hosts');
}
///////////////////////////////////////////////////////////////////////////////
var COMMAND_FAILURE = true;
var COMMAND_USERABORT = true;
var COMMAND_BADPARAMS = true;
var COMMAND_SUCCESS = false;
var fm = new FSMagic();
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);}
///////////////////////////////////////////////////////////////////////////////
function Command_SelectEx(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 (0);
	else if (args["AUTO"].exists)			return		SelectEx_AUTO(data.func.command, data.func.sourcetab, args);
	else if (args["SIMILARMETA"].exists)	return		SelectEx_SIMILARMETA(data.func.command, data.func.sourcetab, args);
	else if (args["SIMILARMETAJS"].exists)	return		SelectEx_SIMILARMETAJS(data.func.command, data.func.sourcetab, args);
	else if (args["FILTERDROP"].exists)		return		SelectEx_FILTERMENU(data.func.dlg, data.func.command, data.func.sourcetab, args, "dropdown");
	else if (args["FILTERLIST"].exists)		return		SelectEx_FILTERMENU(data.func.dlg, data.func.command, data.func.sourcetab, args, "multilist");
	else if (args["FROMCLIP"].exists)		return		SelectEx_FROMCLIP(data.func.command, data.func.sourcetab, args);
	else if (args["FROMFILE"].exists)		return		SelectEx_FROMFILE(data.func.command, data.func.sourcetab, args);
	else if (args["FROMVAR"].exists)		return		SelectEx_FROMVAR(data.func.command, data.func.sourcetab, args);
	else if (args["FROMVARDROP"].exists)	return		SelectEx_FROMVARDROP(data.func.dlg, data.func.command, data.func.sourcetab, args);
	else if (args["ITEM"].exists)			return		SelectEx_ITEM(data.func.command, args, null);
	else if (args["NTH"].exists)			return		SelectEx_NTH(data.func.command, data.func.sourcetab, args);
	else if (args["RANDOM"].exists)			return		SelectEx_RNDLINEAR(data.func.command, data.func.sourcetab, args, true);
	else if (args["LINEAR"].exists)			return		SelectEx_RNDLINEAR(data.func.command, data.func.sourcetab, args, false);
	else if (args["TOCLIP"].exists)			return		SelectEx_TOCLIP(data.func.command, data.func.sourcetab, args);
	else if (args["TOFILE"].exists)			return		SelectEx_TOFILE(data.func.command, data.func.sourcetab, args);
	else if (args["TOVAR"].exists)			return		SelectEx_TOVAR(data.func.command, data.func.sourcetab, args);
	else if (args["MAKEVISIBLE"].exists)	return		SelectEx_MAKEVISIBLE(data.func.command, data.func.sourcetab, args, null);

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

	return result;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_MAKEVISIBLE(cmd, sourcetab, args, item){
	Log("SelectEx_MAKEVISIBLE():","T",1);

	///////////////////////////////////////////////////////////////////////////
	function SwitchCheckboxMode( truefalse, cmd, sourcetab){
		Log('SwitchCheckboxMode():',"T",1);
		var targetState = "off";
		if (truefalse) targetState = "on";
		cmd.RunCommand('Set CheckboxMode='+targetState);
		cmd.Clear();
		sourcetab.Update();
		var abort = 0;
		while ((truefalse != sourcetab.selstats.checkbox_mode) && (abort++ < 100)){
			Log('Setting CheckboxMode failed to set:' + sourcetab.selstats.checkbox_mode + " target:"+targetState,"E");
			DOpus.Delay(10);
			sourcetab.Update();
		}
		if (abort){
			Log('Setting CheckboxMode finally:' + sourcetab.selstats.checkbox_mode,"E");
			Log('Took: '+ abort*10 +' milliseconds!',"E");
		}
		Log("-","T",-1);
		return sourcetab.selstats.checkbox_mode;
	}

	cmd.ClearFiles();
	cmd.deselect = false;
	sourcetab.Update();
	//update tab for changed selection, fetch first selected item
	//and select it once more to make the MAKEVISIBLE switch work
//	for (var iEnum = new Enumerator(sourcetab.selected); !iEnum.atEnd();){
//		var item = iEnum.item(); //iEnum.moveNext();
//		DOpus.Output("    Running SelectEx MAKEVISIBLE.." + item.realpath);
//		cmd.RunCommand('SelectEx ITEM="'+item.realpath+'" EXACT MAKEVISIBLE');
//		break;
//	}
	/////////////////////////
	var wasCheckboxMode = (sourcetab.selstats.checkbox_mode==true);
	var isCheckboxMode = wasCheckboxMode;
	var numSelItems = sourcetab.stats.selitems;
	var numCheItems = sourcetab.stats.checkeditems;

	if (numCheItems+numSelItems==0){
		Log("Aborting, nothing selected","D"); Log("-", "T",-1);
		return COMMAND_SUCCESS;
	}

	var prioCBSelection = args["MAKEVISIBLE"].options["checked"] || false;

	Log("PRIOCHECKED : " + prioCBSelection,"D");
	Log("CHECKBOXMODE: " + isCheckboxMode,"D");

	if (isCheckboxMode && numSelItems && (prioCBSelection==false || numCheItems==0)){
		Log("Disabling checkbox mode to scroll for regular selection (has prio)","D");
		isCheckboxMode = SwitchCheckboxMode( false, cmd, sourcetab);
	}

	Log("Scrolling selected items into view for "+(isCheckboxMode ? "CheckboxMode" : "RegularMode"),"D");

	if (!item){
		var selectedItems = new Enumerator(sourcetab.selected);
		var firstSelected = selectedItems.item();
		item = new String(firstSelected.realpath);
	}
	//cmd.AddLine('Select "'+firstSelected.name+'" MAKEVISIBLE EXACT');
	//cmd.Run();

	Log("item        : " + item,"D");

	args["EXACT"] = {exists:true};
	SelectEx_ITEM(cmd, args, new String(item))

	if (wasCheckboxMode && !isCheckboxMode){
		Log("Turning checkboxes back on","D");
		isCheckboxMode = SwitchCheckboxMode( true, cmd, sourcetab);
	}

	Log("-","T",-1);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_RNDLINEAR(cmd, sourcetab, args, random){
	Log("SelectEx_RNDLINEAR():","T",1);
	var fso = new ActiveXObject("Scripting.FilesystemObject");

	var params = {
		path			: args.Get("PATH", null, false),
		recurse			: args.Get("RECURSE", null, false),
		setVar			: args.Get("SETVAR", null, ""),
		setEnv			: args.Get("SETENV", null, ""),
		folders			: args.Get("FOLDERS", null, null),
		files			: args.Get("FILES", null, null),
		deselectNoMatch	: args.Get("DESELECTNOMATCH", null, false),
		singleFol		: args.Get("SINGLEFOLDER", null, false),
		singleFolMin	: args.Get("SINGLEFOLDERMINCOUNT", null, 1),
		action			: args.Get("ACTION", null, ""),
		itemCount		: args.Get("ITEMCOUNT", null, 1),
		itemCountPerc	: args.Get("ITEMCOUNTPERC", null, null),
		itemCountRND	: args.Get("ITEMCOUNTRND", null, false),
		commands		: args.Get("COMMANDS", null, ""),
		name			: args.Get("NAME", null, null),
		minSize			: args.Get("MINSIZE", null, null),
		maxSize			: args.Get("MAXSIZE", null, null),
		maxSizeTotal	: args.Get("MAXSIZETOTAL", null, null),
		jsFilter		: args.Get("JSFILTER", null, null),
		jsBreak			: args.Get("JSBREAK", null, null),
		copyToColl		: args.Get("COPYTOCOLL", null, null),
		echo			: args.Get("ECHO", null, false)
	}
	///////////////////////////////////////////////////////////////////////////
	function FriendlySizeToBytes(friendlySize){
		var size = parseFloat(friendlySize=friendlySize.toLowerCase());
		if (isNaN(size)) return null;
		if (friendlySize.match(/(\d|\s)(b|bytes?)$/)) ;
		else if (friendlySize.match(/(kb|kilobytes?)$/)) size*=1024;
		else if (friendlySize.match(/(mb|megabytes?)$/)) size*=1024*1024;
		else if (friendlySize.match(/(gb|gigabytes?)$/)) size*=1024*1024*1024;
		else if (friendlySize.match(/(tb|terabytes?)$/)) size*=1024*1024*1024*1024;
		else if (friendlySize.match(/(pb|petabytes?)$/)) size*=1024*1024*1024*1024*1024;
		else if (friendlySize.match(/(eb|exabytes?)$/)) size*=1024*1024*1024*1024*1024*1024;
		else size = null;
		return size;
	}
	///////////////////////////////////////////////////////////////////////////
	function Filter( item, itemSize, nameWild, minSize, maxSize, file, folder, SRFilter){
		if (nameWild && !nameWild.Match(item.name)) return "name";
		if (minSize!==null && minSize>itemSize) return "minsize"; //(!item.is_dir || (item.is_dir && item.got_size))
		if (maxSize!=null &&  maxSize<itemSize) return "maxsize"; //(!item.is_dir || (item.is_dir && item.got_size))
		//if (file!==null && item.is_dir!==false) { DOpus.Output("File:" + file + ", " + item.is_dir); return "file";}
		//if (folder!==null && item.is_dir!==true) return "folder";
		try{ if (SRFilter && SRFilter(item)!==false) return "jsfilter";	}
			catch (e){ return "jsfilter_exception"; }
		return false;
	}
	///////////////////////////////////////////////////////////////////////////
	function AddItemWithFilter(item, itemSize, filteredItemCollections, params, SRFilter){
		var filRes = Filter(item, itemSize, params.name, params.minSize, params.maxSize, params.files, params.folders, SRFilter);
		if (filRes == "jsfilter_exception")
			throw new Error("JSFilter failed, aborting.");
		if (filRes)	return false;
		filteredItemCollections.all.push_back(item);
		if (item.is_dir) filteredItemCollections.dirs.push_back(item);
		else filteredItemCollections.files.push_back(item);
		return true;
	}
	///////////////////////////////////////////////////////////////////////////
	function RegexToWildcardObj(regex){
		if (regex) return DOpus.FSUtil.NewWild(regex,"rf");
		return null;
	}
	///////////////////////////////////////////////////////////////////////////
	function ValidateSizeParameter( paramName, paramValue){
		if (paramValue!==null && (paramValue=FriendlySizeToBytes(paramValue))==null){
			Log(paramName+" malformed.", "W");
			return null;
		}
		return paramValue;
	}
	///////////////////////////////////////////////////////////////////////////
	function GetFilteredItemCollections(sourcetab, params){
		Log("Scanning ["+params.path+"]..", "D");
		var filteredItemCollections = {	all		: DOpus.Create.Vector(),
										files	: DOpus.Create.Vector(),
										dirs	: DOpus.Create.Vector()};
		var SRFilter = null;
		if (params.jsFilter!==null){
			try{
				var SRFilter = new Function("item", params.jsFilter);
			} catch(e){
				Log("Creating function from JSFilter failed: " + e,"X");
				throw new Error("Creating function from JSFilter failed: " + e);
			}
		}
		if (params.path){
			if (!DOpus.FSUtil.Exists(params.path))
				throw "Path ["+params.path+"] not found";
			var iEnum = DOpus.FSUtil.ReadDir(params.path, params.recurse);
			if (iEnum.error!=0 && iEnum.error!=18 && iEnum.error!=2 ) //18 = empty folder, 2=drive root
				throw "ReadDir ["+folderpath+"] failed, fEnum.error ["+iEnum.error+"]";
			while (!iEnum.complete){
				var item = iEnum.next(), itemSize = item.size.cy*10000;
				if ((params.minSize!==null || params.maxSize!==null || params.maxSizeTotal) &&
					item.is_dir && !item.got_size) itemSize = GetFolderSize(item.realpath);
				AddItemWithFilter(item, itemSize, filteredItemCollections, params, SRFilter);
			}
		} else {
			Log("Sourcetab: " + sourcetab.path);
			for (var iEnum = new Enumerator(sourcetab.all); !iEnum.atEnd();){
				var item = iEnum.item(), itemSize = item.size.cy*10000; iEnum.moveNext();
				if ((params.minSize!==null || params.maxSize!==null || params.maxSizeTotal) &&
					item.is_dir && !item.got_size) itemSize = GetFolderSize(item.realpath);
				AddItemWithFilter(item, itemSize, filteredItemCollections, params, SRFilter);
			}
		}
		return filteredItemCollections;
	}
	///////////////////////////////////////////////////////////////////////////
	function SetResultVariables(sourcetab, params, value){
		if (params.setVar) sourcetab.vars.Set(params.setVar, value);
		if (params.setEnv){ var EM = new EnvMagic(); EM.Set(params.setEnv, value); }
	}
	///////////////////////////////////////////////////////////////////////////
	function PickItems(cmd, items, maxItems, maxSizeTotal, jsBreak, random){
		Log("Picking items..","D");
		///////////////////////////////////////////////////////////////////////
		function MaxSizeReached(){
			if (!maxSizeTotal) return false;
			if (item.is_dir && !item.got_size) itemSize = GetFolderSize(item.realpath);
			if (((sizeTotal+itemSize)>maxSizeTotal)) return true;
			return false;
		}
		///////////////////////////////////////////////////////////////////////
		cmd.ClearFiles();

		if (jsBreak){
			try{ var SRBreak = new Function("item", jsBreak); }
			catch(e){
				Log("Creating function from JSBreak failed: " + e,"X");
				throw new Error("Creating function from JSBreak failed: " + e);
			}
		}

		var sizeTotal = 0;
		if (random) {
			var randomsUsed = { "dummy":true };
			var r = "dummy";
			for (var i=0;i<maxItems && items.count;i++){
				r = Math.floor((Math.random()*items.count));
				var item = items(r), itemSize = item.size.cy*10000;
				items.erase(r);
				if (MaxSizeReached()) { i--; continue; }
				if (jsBreak){
					var res = SRBreak(item);
					if (res === true) break; //enough items
					if (res === false) { i--; continue; }; //skip this item
				}
				//select item
				sizeTotal+=itemSize;
				cmd.AddFile(item);
			}
		} else {
			for (var i=0;i<maxItems && i<items.count;i++){
				var item = items(i), itemSize = item.size.cy*10000;
				if (MaxSizeReached()) break;
				if (jsBreak){
					var res = SRBreak(item);
					if (res === true) break; //enough items
					if (res === false) continue; //skip this item
				}
				//select item
				sizeTotal+=itemSize;
				cmd.AddFile(item);
			}
		}
		return cmd;
	}
	///////////////////////////////////////////////////////////////////////////
	function GetNumberOfItemsToSelect(params, items){
		if (params.itemCountPerc && !isNaN(parseInt(params.itemCountPerc,10))) {
			params.itemCountPerc = parseInt(params.itemCountPerc);
			if (params.itemCountPerc>0)
				params.itemCount = items.count*(params.itemCountPerc/100);
		}
		if (params.itemCount > items.count) params.itemCount = items.count;
		if (params.itemCountRND){
			if (params.itemCount>1)
				params.itemCount = Math.floor((Math.random()*params.itemCount)+1);
			else
				params.itemCount = Math.floor((Math.random()*items.count)+1);
		}
		return params.itemCount;
	}
	///////////////////////////////////////////////////////////////////////////
	function JoinItemsToString(collection, separator){
		separator = separator || "\n";
		var itemsSeparated = "";
		for (var iEnum = new Enumerator(collection); !iEnum.atEnd();){
			var item = iEnum.item(); iEnum.moveNext();
			itemsSeparated += item.realpath + (!iEnum.atEnd()?separator:"");
		}
		return itemsSeparated;
	}
	///////////////////////////////////////////////////////////////////////////
	function GetCollectionToPickFrom(filteredItemCollections, params){
		if (params.singleFol && (params.singleFolMin <= filteredItemCollections.dirs.count)){
			params.itemCountRND = false;
			params.itemCount = 1;
			params.itemCountPerc = null;
			return filteredItemCollections.dirs;
		}
		if (params.folders && !params.files)	return filteredItemCollections.dirs;
		if (params.files  && !params.folders)	return filteredItemCollections.files;
		return filteredItemCollections.all;
	}
	///////////////////////////////////////////////////////////////////////////
	function SelectItemsInFiledisplay(params, cmd){
		if (!params.path){
			Log("Selecting items..","D");
			cmd.RunCommand("Select FROMSCRIPT EXACT"+
				(params.deselectNoMatch?" DESELECTNOMATCH":"")+
				(args["MAKEVISIBLE"].exists?" MAKEVISIBLE":"")
				);
			return true;
		}
		return false;
	}
	///////////////////////////////////////////////////////////////////////////
	function SetResults(sourcetab, params, cmd, args){
		var content = null;
		if (params.setVar || params.setEnv || args["TOFILE"].exists)
			content = JoinItemsToString(cmd.files, "\n");
		if (params.setVar || params.setEnv)
			SetResultVariables(sourcetab, params, content);
		if (args["TOFILE"].exists){
			var fm = new FSMagic();
			var file = fm.OpenFile(args["TOFILE"].value, args["APPEND"].exists?"a":"w");
			if (file!==null){
				file.WriteLine(content); file.Close();
			}
		}
		return (content!==null);
	}
	///////////////////////////////////////////////////////////////////////////
	function TriggerFileTypeActions(params, cmd){
		if (params.action){
			Log("Triggering action ["+params.action+"]..","D");
			cmd.RunCommand("FileType ACTION="+params.action);
			return true;
		}
		return false;
	}
	///////////////////////////////////////////////////////////////////////////
	function ExecuteCommands(params, cmd){
		if (params.commands && cmd.files.count){
			Log("Running commands..","D");
			var commands = params.commands.split("\\n");
			for(var c=0;c<commands.length;c++){
				Log("    Cmd: " + commands[c],"D");
				cmd.RunCommand(commands[c]);
			}
			return true;
		}
		return false;
	}
	///////////////////////////////////////////////////////////////////////////
	function EchoItemsToConsole(params, cmd){
		if (params.echo){
			Log("Items ("+cmd.files.count+"):");
			for (var iEnum = new Enumerator(cmd.files); !iEnum.atEnd();){
				var item = iEnum.item(); iEnum.moveNext();
				DOpus.Output(item.realpath);
			}
			return true;
		}
		return false;
	}
	///////////////////////////////////////////////////////////////////////////
	function CopyToCollection(params, cmd){
		if (params.copyToColl!==null){
			Log("Copying to collection ["+params.copyToColl+"]..","D");
			var cmdCol = DOpus.Create.Command();
			cmdCol.AddLine('CreateFolder "coll://'+params.copyToColl+'"');
			cmdCol.AddLine('Copy COPYTOCOLL=member TO "coll://'+params.copyToColl+'"');
			var addedItems = false;
			for (var iEnum = new Enumerator(cmd.files); !iEnum.atEnd();){
				var item = iEnum.item(); iEnum.moveNext();
				if (!DOpus.FSUtil.Exists("coll://"+params.copyToColl+"/"+item.name)){
					cmdCol.AddFile(item);
					addedItems = true;
				}
			}
			//as selected files in source will be used instead (bug?)
			//issue: http://resource.dopus.com/viewtopic.php?f=3&t=24406
			if (addedItems) cmdCol.Run();
			return true;
		}
		return false;
	}
	///////////////////////////////////////////////////////////////////////////
	function GetFolderSize(path){
		var size = fso.GetFolder(path).Size;
		if (!isNaN(parseInt(size,10))) return size;
		return null;
	}
	///////////////////////////////////////////////////////////////////////////
	params.name					= RegexToWildcardObj( params.name);
	params.minSize				= ValidateSizeParameter("MinSize", params.minSize);
	params.maxSize				= ValidateSizeParameter("MaxSize", params.maxSize);
	params.maxSizeTotal			= ValidateSizeParameter("MaxSizeTotal", params.maxSizeTotal);

	PrintParams(params);

	var filteredItemCollections	= GetFilteredItemCollections(sourcetab, params);
	var filteredItemCollection	= GetCollectionToPickFrom(filteredItemCollections, params);

	if (filteredItemCollection.count==0){
		SetResultVariables(sourcetab, params, "");
		Log("No items, aborting","I");
		return COMMAND_FAILURE;
	}

	params.itemCount			= GetNumberOfItemsToSelect(params, filteredItemCollection);
	var pickedItemsCommand		= PickItems(cmd, filteredItemCollection, params.itemCount, params.maxSizeTotal, params.jsBreak, random);
	var voidItemsCopied			= CopyToCollection(params, pickedItemsCommand); //if copytocoll given
	var voidItemsReturned		= SetResults(sourcetab, params, pickedItemsCommand, args); //if variable names given
	var voidItemsSelected		= SelectItemsInFiledisplay(params, pickedItemsCommand); //if no path given
	var voidActionsTriggered	= TriggerFileTypeActions(params, pickedItemsCommand); //if action given
	var voidCommandsExecuted	= ExecuteCommands(params, pickedItemsCommand); //if commands given
	var voidItemsEchoed			= EchoItemsToConsole(params, pickedItemsCommand); //if echo enabled

	Log("Done.","D"); Log("-","T",-1);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function EnvMagic(scope){ //v0.1
	this.scope = scope || "Process";
	try{this.shell=shell} catch(e){this.shell=new ActiveXObject("WScript.Shell")};
	this.env = this.shell.Environment(this.scope);
	///////////////////////////////////////////////////////////////////////////
	this.Set = function (varname, value, scope){
		var env = scope?this.shell.Environment(scope):this.env;
		env(varname) = value;
		return value;
	}
	///////////////////////////////////////////////////////////////////////////
	this.Get = function (varname, scope){
		var env = scope?this.shell.Environment(scope):this.env;
		return env(varname);
	}
	///////////////////////////////////////////////////////////////////////////
	this.Remove = function (varname, scope){
		var env = scope?this.shell.Environment(scope):this.env;
		return env.Remove(varname);
	}
	///////////////////////////////////////////////////////////////////////////
	this.Expand = function (varString){
		return this.shell.ExpandEnvironmentStrings(varString);
	}
}
///////////////////////////////////////////////////////////////////////////////
function PrintParams( params){
	var maxLen = 0;
	for(param in params) if (param.length > maxLen)	maxLen = param.length;
	for(param in params){
		var pad = ""; while (pad.length+param.length<maxLen) pad+=" ";
		Log(param.toUpperCase()+pad+": "+params[param], "D");
	}
}
///////////////////////////////////////////////////////////////////////////////
function OnAfterFolderChange(data){
	if (!data.result) return;
	if (data.action == "refresh" || data.action == "refreshsub") return;
	if (!Script.config["AutoSelect"]) return;

	var args = ArgsMagic(null, {}, template);
	if (Script.Config["AutoSelect.MakeVisible"])
		args["MAKEVISIBLE"] = {exists:true};
	if (Script.Config["AutoSelect.DeselectNoMatch"])
		args["DESELECTNOMATCH"] = {exists:true};
	SelectEx_AUTO(DOpus.Create.Command(), data.tab, args);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_AUTO(cmd, sourcetab, args){
	Log("SelectEx_AUTO(): (" + Script.config["AutoSelect"]+ ")","T",1);

	var list = Script.config["AutoSelect.List"];
	var tabPath = new String(sourcetab.path), selItems = [];

	for(var i=0;i<list.count;i++){
		if (list(i).substring(0,2)=="//"|| list(i).substring(0,1)=="#"||
			list(i).substring(0,1)==";" || list(i)=="") continue;
		var parts = new String(list(i)).split("=>");
		if (parts.length!=2) continue;

		Log("Entry: " + list(i),"D");
		var path = parts[0].trim();
		if (path.substring(0,6)=="REGEX="){
			path = path.substring(6);
		} else {
			path = path!=""?new String(DOpus.FSUtil.Resolve(path)):path;
			path = path.replace(/\\/g,'\\\\')+"$";
		}
		Log("    Path: " + path,"D");
		Log("    TabPath: " + tabPath,"D");
		if (!tabPath.match(new RegExp(path,"i"))){
			Log("    No path match","D");
			continue;
		}

		var item = parts[1].trim();
		selItems[selItems.length] = item;
	}
	if (selItems.length){
		Log("SelItems: " + selItems,"D");
		args["USEPATH"] = {exists:true};
		SelectArrayItems(cmd, sourcetab, args, selItems);
	}
	Log("-","T",-1);
	return;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_FILTERMENU(dlg, cmd, sourcetab, args, type){
	Log("SelectEx_FILTERMENU():","T",1);
	///////////////////////////////////////////////////////////////////////////
	function GetFilterNamesVector(){
		var filtersPath	= DOpus.FSUtil.Resolve("/dopusdata\\filters");
		var fEnum		= DOpus.FSUtil.ReadDir(filtersPath);
		if (fEnum.error!=0 && fEnum.error!=18 && fEnum.error!=2 ) //18 = empty folder, 2=drive root
			throw new Error(0,"ReadDir ["+filtersPath+"] failed, fEnum.error ["+fEnum.error+"]");
		var list = DOpus.Create.Vector();
		while (!fEnum.complete){
			var filterItem = fEnum.next();
			if (filterItem.is_dir == true) continue;
			if (filterItem.ext.toLowerCase() != ".ofi") continue;
			list.push_back(filterItem.name_stem);
		}
		return list;
	}
	///////////////////////////////////////////////////////////////////////////
	function OpenMenu(dlg, type, filters, filterFlags){
		dlg.title = "Select Filters";
		dlg.message = "Check filters to "+filterFlags.replace(",",", ")+" items:"
		dlg.buttons = "Ok|Cancel";
		dlg.choices = filters;
		if (type=="dropdown")	dlg.menu = 0;
		if (type=="multilist")	dlg.list = 0;
		dlg.Show();
		return dlg.result;
	}
	///////////////////////////////////////////////////////////////////////////
	function AddSelection(cmd, filterName, filterFlags){
		var cmdLine = 'Select "'+filterName+'" FILTER FILTERFLAGS="'+filterFlags+'"'+
						(args["MAKEVISIBLE"].exists?' MAKEVISIBLE':'')+
						(args["PT"].exists?' '+args["PT"].value:'')
						;
		cmd.AddLine(cmdLine);
		Log("Command: " + cmdLine,"D");
	}
	///////////////////////////////////////////////////////////////////////////

	Log("DESELECTNOMATCH: " + args["DESELECTNOMATCH"].exists,"D");
	Log("MAKEVISIBLE    : " + args["MAKEVISIBLE"].exists,"D");
	Log("PT             : " + args["PT"].value,"D");

	cmd.deselect = false;
	if (args["DESELECTNOMATCH"].exists){
		Log("cmd.AddLine(Select NONE);","D");
		cmd.AddLine('Select NONE');
	}

	if (type=="dropdown")	var filterFlags = args["FILTERDROP"].value;
	if (type=="multilist")	var filterFlags = args["FILTERLIST"].value;

	var filters = GetFilterNamesVector();
	if (!filters.count){
		Log("No filters found.","X"); Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	var result = OpenMenu(dlg, type, filters, filterFlags);
	if (result==0){
		Log("User abort.","T",-1);
		return COMMAND_USERABORT;
	}

	if (type=="multilist")
		for(var c=0;c<dlg.choices.count;c++)
			if (dlg.list(c)) AddSelection(cmd, dlg.choices(c), filterFlags);

	if (type=="dropdown")
		AddSelection(cmd, dlg.choices(result-1), filterFlags);

	cmd.AddLine("//prevent exception if no line added");
	cmd.Run();

	Log("Done.","T",-1);
	return;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_FROMVARDROP(dlg, cmd, sourcetab, args){
	Log("SelectEx_FROMVARDROP():","T",1);
	///////////////////////////////////////////////////////////////////////////
	function GetVarNamesVector(){
		var list = DOpus.Create.Vector();
		//var varNameFull = "Script.SelectEx.StoredSelection."+varName;
		for (enumVarNames = new Enumerator(DOpus.Vars); !enumVarNames.atEnd();){
			var item = new String(enumVarNames.item()); enumVarNames.moveNext();
			if (item.indexOf("Script.SelectEx.StoredSelection.")==-1) continue;
			item = item.replace("Script.SelectEx.StoredSelection.","");
			list.push_back(item);
		}
		return list;
	}
	///////////////////////////////////////////////////////////////////////////
	function OpenMenu(dlg, varNames){
		//dlg.title = "Select Filters";
		//dlg.message = "Check filters to "+filterFlags.replace(",",", ")+" items:"
		//dlg.buttons = "Ok|Cancel";
		dlg.choices = varNames;
		dlg.menu = 0;
		//if (type=="multilist")	dlg.list = 0;
		dlg.Show();
		return dlg.result;
	}
	///////////////////////////////////////////////////////////////////////////

	Log("DESELECTNOMATCH: " + args["DESELECTNOMATCH"].exists,"D");
	Log("MAKEVISIBLE    : " + args["MAKEVISIBLE"].exists,"D");
	Log("PT             : " + args["PT"].value,"D");

	cmd.deselect = false;
	if (args["DESELECTNOMATCH"].exists){
		Log("cmd.AddLine(Select NONE);","D");
		cmd.AddLine('Select NONE');
	}

	var varNames = GetVarNamesVector();
	if (!varNames.count){
		Request("No memorized selections found.")
		Log("No memorized selections found.","X"); Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	var result = OpenMenu(dlg, varNames);
	if (result==0){
		Log("User abort.","T",-1);
		return COMMAND_USERABORT;
	}

	args["FROMVAR"].exists = true;
	args["FROMVAR"].value = dlg.choices(result-1);
	var result = SelectEx_FROMVAR(cmd, sourcetab, args);

	Log("Done.","T",-1);
	return result;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_SIMILARMETA(cmd, sourcetab, args){
	Log("SelectEx_SIMILARMETA():","T",1);
	//"metadata.image.picheight;metadata.image.picwidth"

	var metas = args.Get("SIMILARMETA", "", "").trim().split(";");
	Log("SIMILARMETA: " + metas,"D");
	Log("MAKEVISIBLE: " + args["MAKEVISIBLE"].exists,"D");
	for (var i=0;i<metas.length;i++){
		var meta = ""
		var parts = metas[i].split(".");
		for (var p=0;p<parts.length;p++)
			meta += parts[p].trim()+((p+1)<parts.length?'"]["':'');
		metas[i] = '["'+meta+'"]';
	}
	if (!metas || (metas && !metas.length)){
		Log("Parsing meta properties failed: " + e,"E");
		Log("-","T",-1);
		return COMMAND_FAILURE;
	}
	var result = SelectEx_SIMILAR(cmd, sourcetab, args, metas, null);
	Log("-","T",-1);
	return result;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_SIMILARMETAJS(cmd, sourcetab, args){
	Log("SelectEx_SIMILARMETAJS():","T",1);
	//"return selItem.name.left(8)==item.name.left(8);"

	var jsCompare = args.Get("SIMILARMETAJS", "", null);
	Log("SIMILARMETAJS: " + jsCompare,"D");
	Log("MAKEVISIBLE  : " + args["MAKEVISIBLE"].exists,"D");
	try{
		jsCompare = new Function("selItem", "item", jsCompare);
	} catch(e){
		Log("Creating function failed: " + e,"X");
		Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	var result = SelectEx_SIMILAR(cmd, sourcetab, args, null, jsCompare);
	Log("-","T",-1);
	return result;
}
///////////////////////////////////////////////////////////////////////////
function distance(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;
	}
}
///////////////////////////////////////////////////////////////////////////
//work in progess
function dis(selStr, str) {
	selStr = selStr.toLowerCase().replace(/[#0123456789\.\-\(\)]/g,"");
	str = str.toLowerCase().replace(/[#0123456789\.\-\(\)]/g,"");
	selStr = selStr.toLowerCase().replace(/^|\sthe\s|$/g,"");
	str = str.toLowerCase().replace(/^|\sthe\s|$/g,"");
	//DOpus.Output(str); return false;

	var selItemWords = new String(selStr).split(" "), selItemWords2 = [];
	var itemWords = new String(str).split(" "), itemWords2 = [];

	for(var i=0;i<itemWords.length;i++){
		if (itemWords[i].length<3) continue;
		itemWords2[itemWords2.length]=itemWords[i];
	}
	for(var i=0;i<selItemWords.length;i++){
		if (selItemWords[i].length<3) continue;
		selItemWords2[selItemWords2.length]=selItemWords[i];
	}

	if (!itemWords2.length) return 0;
	var matches = 0, distance, cacheID="";
	var cache = [];
	for(var i=0;i<itemWords2.length;i++){
		var match = false;
		//DOpus.Output("itemWords2[i]="+itemWords2[i]);
		//DOpus.Output("    selStr="+selStr);
		//DOpus.Output("    ="+selStr.search(new RegExp('(^| |_|\.)'+itemWords2[i]+'($| |_|\.)')));
		//if (selStr.search('(^| |_|\.)'+itemWords2[i]+'($| |_|\.)')==-1)
			//continue;
		for(var ii=0;ii<selItemWords2.length;ii++){
			cacheID = ""+selItemWords2[ii]+" # "+itemWords2[i];
			if (cache[cacheID] == undefined){
				distance = this.distance( selItemWords2[ii], itemWords2[i]);
				cache[cacheID] = distance;
			}
			else {
				distance = cache[cacheID];
				//DOpus.Output("Cache USE!: " + selItemWords2[ii]+" # "+itemWords2[i]);
			}
			if (distance > 0.9) {
				match = true;
				break;
			}
		}
		if (match)
			matches++;
		//DOpus.Output("itemWords2[i]="+itemWords2[i]);
		//DOpus.Output("    selStr="+selStr);

	}
	var perc = (matches*100)/itemWords.length;
	//var perc = (itemWords.length*100)/matches;
//DOpus.Output(selStr + " " + perc.toFixed(2));
	if (perc>15){

		return true;
	}
	return false;

	//if (matches != itemWords.length) return 0;
	return matches;
}

///////////////////////////////////////////////////////////////////////////////
function SelectEx_SIMILAR(cmd, sourcetab, args, metas, jsCompare){
	Log("SelectEx_SIMILAR():","T",1);

	///////////////////////////////////////////////////////////////////////////
	var selFilesEnum = new Enumerator(sourcetab.selected_files), selItem = null;
	if (!selFilesEnum.atEnd())
		selItem = selFilesEnum.item();

	if (!selItem){
		Log("No item selected or passed.","W");
		//Log("-","T",-1);
		//return COMMAND_FAILURE;
	}

	if (metas){
		var selItemMetas = []
		for (var i=0;i<metas.length;i++)
			selItemMetas[i] = new String(eval("selItem"+metas[i])).toLowerCase();
	}

	cmd.ClearFiles();
	var enumFiles = new Enumerator(sourcetab.all), selFilesCount = 0;
	while (!enumFiles.atEnd()) {
		var item = enumFiles.item();
		try {
			var match = true;
			if (metas) for (var i=0;i<metas.length;i++){
				if (selItemMetas[i] != new String(eval("item"+metas[i])).toLowerCase()) {
					match = false;
					break; }
			}
			if (jsCompare && !jsCompare(selItem, item))
				match = false;

			if (match) cmd.AddFile(item);
		} catch(e){
			Log("Comparing failed: " + e,"X");
			Log("-","T",-1);
			return COMMAND_FAILURE;
		}
		enumFiles.moveNext();
	}
	cmd.RunCommand(	"Select FROMSCRIPT"+
					(args["MAKEVISIBLE"].exists?' MAKEVISIBLE':'')+
					(args["DESELECTNOMATCH"].exists?' DESELECTNOMATCH':'')+
					(args["PT"].exists?' '+args["PT"].value:'')
					);

	Log("Done.","D"); Log("-","T",-1);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_ITEM(cmd, args, item){
	Log("SelectEx_ITEM():","T",1);

	item = item || args["ITEM"].value;
	Log("ITEM            : " + item,"D");
	Log("MAKEVISIBLE     : " + args["MAKEVISIBLE"].exists,"D");
	Log("DESELECTNOMATCH : " + args["DESELECTNOMATCH"].exists,"D");
	Log("EXACT           : " + args["EXACT"].exists,"D");
	Log("USEPATH         : " + args["USEPATH"].exists,"D");
	Log("PT              : " + args["PT"].value,"D");

	if (!item){
		Log("No item/path given.","X");
		Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	var cmdLineEnd =	(args["DESELECTNOMATCH"].exists?' DESELECTNOMATCH':'')+
						(args["MAKEVISIBLE"].exists?' MAKEVISIBLE':'')+
						(args["EXACT"].exists?' EXACT':'')+
						(args["PT"].exists?' '+args["PT"].value:'')

	var parent = item.getParentPart();
	if (!args["USEPATH"].exists){
		item = item.getFilePart();
		parent = "";
	}

	/*if (!parent && args["USEPATH"].exists){
		DOpus.Output("E   No path given.");
		return COMMAND_FAILURE;
	}*/

	if (parent) {
		//select with full path
		cmd.ClearFiles();
		Log("item            : " + item,"D");
		cmd.AddFile(item);
		var cmdline = 'SELECT FROMSCRIPT' + cmdLineEnd;
		Log("command         : " + cmdline,"D");
		cmd.RunCommand(cmdline);
	} else {
		//try to select what matches by name
		var cmdline = 'SELECT "'+item+'"' + cmdLineEnd
		Log("command         : " + cmdline,"D");
		cmd.RunCommand(cmdline);
	}

	Log("-","T",-1);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_NTH(cmd, sourcetab, args){
	Log("SelectEx_NTH():","T",1);

	var nth = parseInt(args["NTH"].value), range = "";
	Log("NTH    : " + nth,"D");
	if (!nth){
		Log("No 'nth' given.","X");
		Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	cmd.ClearFiles();
	for(var i=1;i<=sourcetab.all.count;i=i+nth)
		range += i+",";

	var cmdline = 'SELECT RANGE="'+range+'"'+
					(args["DESELECTNOMATCH"].exists?' DESELECTNOMATCH':'')+
					(args["MAKEVISIBLE"].exists?' MAKEVISIBLE':'')+
					(args["EXACT"].exists?' EXACT':'')+
					(args["PT"].exists?' '+args["PT"].value:'');

	Log("command: " + cmdline,"D");
	cmd.RunCommand(cmdline);
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_FROMCLIP(cmd, sourcetab, args){
	Log("SelectEx_FROMCLIP():","T",1);

	var TM = new TextMagic();
	var selItems = TM.TextToFilePaths( DOpus.GetClip("text") );
	var result = SelectArrayItems(cmd, sourcetab, args, selItems);
	Log("-","T",-1);
	return result;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_FROMFILE(cmd, sourcetab, args){
	Log("SelectEx_FROMFILE():","T",1);
	var TM = new TextMagic();
	var filePath = args["FROMFILE"].value;

	Log("FROMFILE            : " + filePath,"D");

	var fm = new FSMagic();
	var file = fm.OpenFile(filePath, "r", "try");
	if (file === null){
		Log("Failure opening file ["+filePath+"]","X");
		Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	var selItems = [];
	while(!file.AtEndOfStream){
		var line = file.ReadLine();
		if (line=="") continue;
		line = TM.CleanFilePath(line);
		selItems[selItems.length] = line;
	}
	file.Close();

	var result = SelectArrayItems(cmd, sourcetab, args, selItems);
	Log("-","T",-1);
	return result;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_FROMVAR(cmd, sourcetab, args){
	Log("SelectEx_FROMVAR():","T",1);
	var vm = new VarMagic();

	var varName = args["FROMVAR"].value;
	if (varName == "") varName = "Default";
	var varNameFull = "Script.SelectEx.StoredSelection."+varName;
	Log("FROMVAR: " + varName,"D");
	var selVar = vm.GetCreateVar(DOpus, varNameFull, null, null, false);
	if (selVar === null){
		Log("Stored selection ["+varName+"] not found.","X");
		Log("-","T",-1);
		return COMMAND_FAILURE;
	}
	var selItems = vm.VectorToArray(selVar.value);
	Log("items  : " + selItems.length,"D");

	var result = SelectArrayItems(cmd, sourcetab, args, selItems);
	Log("-","T",-1);
	return result;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_TOCLIP(cmd, sourcetab, args){
	Log("SelectEx_TOCLIP():","T",1);

	Log("APPEND: " + args["APPEND"].exists,"D");
	Log("items : " + sourcetab.selected.count,"D");

	if (!sourcetab.selected.count){
		Log("No selection given, aborting.","E"); Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	var clip = "";
	if (args["APPEND"].exists){
		clipContent = DOpus.GetClip("text");
		clip=new String(clipContent);
		if (clipContent!="") clip+="\n";
	}

	for (var iEnum = new Enumerator(sourcetab.selected); !iEnum.atEnd();){
		var item = iEnum.item(); iEnum.moveNext();
		clip+=item.realpath;
		if (!iEnum.atEnd()) clip+="\n";
	}

	DOpus.SetClip(clip);

	Log("-","T",-1);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_TOFILE(cmd, sourcetab, args){
	Log("SelectEx_TOFILE():","T",1);

	var filePath = args["TOFILE"].value;
	Log("TOFILE: " + filePath,"D");
	Log("APPEND: " + args["APPEND"].exists,"D");
	Log("items : " + sourcetab.selected.count,"D");

	if (!sourcetab.selected.count || !filePath){
		Log("No selection or no file given, aborting.","E"); Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	var fm = new FSMagic();
	var file = fm.OpenFile(filePath, args["APPEND"].exists?"a":"w");
	if (file === null){
		Log("Failure opening file ["+filePath+"]","X");
		Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	for (var iEnum = new Enumerator(sourcetab.selected); !iEnum.atEnd();){
		var item = iEnum.item(); iEnum.moveNext();
		var line = new String(item.realpath);
		try{file.WriteLine(line);}catch(e){
			line = line.replace(/[^ -~]/ig,''); //printable chars only
			file.WriteLine(line);
		}
	}
	file.Close();

	Log("-","T",-1);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function SelectEx_TOVAR(cmd, sourcetab, args){
	Log("SelectEx_TOVAR():","T",1);
	var vm = new VarMagic();

	var varName = args["TOVAR"].value;
	if (varName == "") varName = "Default";
	var varNameFull = "Script.SelectEx.StoredSelection."+varName;
	Log("TOVAR : " + varName,"D");
	Log("APPEND: " + args["APPEND"].exists,"D");
	Log("items : " + sourcetab.selected.count,"D");

	if (!sourcetab.selected.count){
		Log("No selection, aborting.","E"); Log("-","T",-1);
		return COMMAND_FAILURE;
	}

	var selection = vm.GetCreateVar(DOpus, varNameFull, DOpus.Create.Vector(), true, true).value;
	if (!args["APPEND"].exists)	selection.clear();
	for (var iEnum = new Enumerator(sourcetab.selected); !iEnum.atEnd();){
		var item = iEnum.item(); iEnum.moveNext();
		selection.push_back(item.realpath);
	}

	Log("-","T",-1);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function SelectArrayItems(cmd, sourcetab, args, selItems){
	Log("SelectArrayItems():","T",1);
	cmd.ClearFiles();
	var cmd = DOpus.Create.Command();
	cmd.SetSourceTab(sourcetab);
	cmd.deselect = false;
	cmd.ClearFiles();

	if (!selItems.length){
		Log("No usable content (no item?), aborting.","E");
		Log("-","T",-1);
		return COMMAND_FAILURE; //no valid clipboard content
	}

	var flatView		= cmd.IsSet("FLATVIEW=on");
	var selItemsBefore	= sourcetab.selected.count;
	var selItemsDone	= 0;
	var madeVisible		= null;

	Log("Params:","D");
	Log("    SKIPITEMSWITHPATH   : " + args["SKIPITEMSWITHPATH"].exists,"D");
	Log("    SKIPITEMSWITHOUTPATH: " + args["SKIPITEMSWITHOUTPATH"].exists,"D");
	Log("    USEPATH             : " + args["USEPATH"].exists,"D");
	Log("    MAKEVISIBLE         : " + args["MAKEVISIBLE"].exists,"D");
	Log("    DESELECTNOMATCH     : " + args["DESELECTNOMATCH"].exists,"D");
	Log("    EXACT               : " + args["EXACT"].exists,"D");
	Log("    GO                  : " + args["GO"].exists,"D");
	Log("    PT                  : " + args["PT"].value,"D");
	Log("    flatview            : " + flatView,"D");

	Log("Selecting items..","D");
	cmd.AddLine('//prevent no line added expection');

	if (args["DESELECTNOMATCH"].exists){
		Log("    cmd.AddLine(Select NONE);","D");
		cmd.AddLine('Select NONE');
	}

	for(var i=0;i<selItems.length;i++){
		var item = new String(selItems[i]), parent = "";
		var regexp = false;
		if (item.substring(0,6)=="REGEX="){
			item = item.substring(6);
			regexp = true;
		} else {
			parent = new String(item).getParentPart();
			item = new String(item).getFilePart();
		}

		if (parent && args["SKIPITEMSWITHPATH"].exists) continue;
		if (!parent && args["SKIPITEMSWITHOUTPATH"].exists) continue;
		Log("    item ["+item+"], parent ["+parent+"]","D");
		selItemsDone++;

		if (args["GO"].exists && parent){
			args["GO"].exists = false;
			if (!DOpus.FSUtil.ComparePath(parent,sourcetab.path)){
				var cmdline =	'Go "'+parent+'"'+
								(args["GOPT"].exists?' '+args["GOPT"].value:'');
				Log("    cmd.RunCommand("+cmdline+");","D");
				cmd.RunCommand(cmdline);
				sourcetab.Update();
			}
		}

		if (!args["USEPATH"].exists)
			parent = ""; //not considerung fullpaths by default
		if (parent)	parent = parent.rTrim("\\\\")+"\\";

		if (flatView || regexp){
			if (parent && !regexp){ //fullpath works in flatview with AddFile() and SELECT FROMSCRIPT
				var file = parent.rTrim("\\\\")+"\\" + item;
				Log("    AddFile("+file+");","D");
				cmd.AddFile(file);
				}
			else {
				//standalone itemname cannot be selected like a fullpath in flatview
				//so add a specific SELECT command for standalone itemname(s)
				var cmdline = 'SELECT "'+item+'"'+
								(regexp?' REGEXP':'')+
								(args["MAKEVISIBLE"].exists && !madeVisible?' MAKEVISIBLE':'')+
								(args["EXACT"].exists?' EXACT':'')+
								(args["PT"].exists?' '+args["PT"].value:'')
				Log('    AddLine('+cmdline+');',"D");
				cmd.AddLine(cmdline);
				if (args["MAKEVISIBLE"].exists) madeVisible = true;
			}
		} else {
			if (parent); //fullpath does not require special handling in non-flatview
			else {
				//standalone itemname does not work in non-flatview with AddFile() and
				//SELECT FROMSCRIPT, use the current source path to build a fullpath
				parent = new String(sourcetab.path);
			}
			var file = parent.rTrim("\\\\")+"\\" + item;
			Log("    AddFile("+file+");","D");
			cmd.AddFile(file);
		}
	}

	Log("cmd.Run()","D");
	cmd.Run(); //select standalone itemnames in flatview

	var cmdLine = 'Select FROMSCRIPT'+
						(args["EXACT"].exists?' EXACT':'')+
						(args["MAKEVISIBLE"].exists && !madeVisible?' MAKEVISIBLE':'')+
						(args["PT"].exists?' '+args["PT"].value:'');
	Log("cmd.RunCommand("+cmdLine+")","D");
	cmd.RunCommand(cmdLine);

	Log("Results:","D",1);
	if ((selItemsBefore+selItemsDone) != sourcetab.selected.count){
		Log("Less/more items selected than given or some ","I");
		Log("matching items were already selected before.","I");
	}

	Log("items total         : " + selItems.length,"D");
	Log("items filtered      : " + selItemsDone,"D");
	Log("selected before     : " + selItemsBefore,"D");
	Log("selected after      : " + sourcetab.selected.count,"D",-1);

	Log("-","T",-1);
	return COMMAND_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
function VarMagic(){
	///////////////////////////////////////////////////////////////////////////
	this.VectorToArray = function(vector){
		var a = new Array();
		for(var v=0;v<vector.length;v++)
			a[a.length] = vector(v);
		return a;
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetCreateVar = function(origin, name, iniValue, persist, create){
		Log("GetCreateVar():","T",1);
		persist = persist || false;
		create = create || false;
		Log("name     : " + name,"D");
		Log("ini-value: " + iniValue,"D");
		Log("persist  : " + persist,"D");
		Log("create   : " + persist,"D");
		if (!origin.Vars.Exists(name)){
			if (create) origin.Vars.Set( name, iniValue);
			else{
				Log("<- null","T",-1);
				return null;
			}
		}
		var doVar = origin.Vars(name);
		if (persist) doVar.persist = true; else doVar.persist = false;
		Log("-","T",-1);
		return doVar;
	}
}
///////////////////////////////////////////////////////////////////////////////
function TextMagic(){
	this.version = 0.2;
	///////////////////////////////////////////////////////////////////////////
	this.TextToFilePaths = function( text ){
		var lineEnding = this.GetLineEndingOfText(text);
		if (lineEnding!=""){
			var itemNames = text.split(lineEnding);
		} else
			var itemNames = new Array(text);
		return this.CleanFilePaths(itemNames)
	}
	///////////////////////////////////////////////////////////////////////////
	this.TextToDOItems = function( text ){
		var items = [];
		var filePaths = this.TextToFilePaths(text);
		for(var i=0;i<filePaths.length;i++){
			if (DOpus.FSUtil.Exists(filePaths[i]))
				items[items.length] = DOpus.FSUtil.GetItem(filePaths[i]);
		}
		return items;
	}
	///////////////////////////////////////////////////////////////////////////
	this.GetLineEndingOfText = function(text){
		var lineEndings = ["\r\n","\n\r","\n","\r"];
		var lineEnding = "";
		for(var l=0;l<lineEndings.length;l++){
			if (text.indexOf(lineEndings[l])!=-1){
				lineEnding = lineEndings[l];
				break;
			}
		}
		return lineEnding;
	}
	///////////////////////////////////////////////////////////////////////////
	this.CleanFilePath = function( pathOrName){
		pathOrName = pathOrName.trim();
		pathOrName = pathOrName.trim('"');
		pathOrName = pathOrName.replace(/[\?]/g,"");
		return pathOrName;
	}
	///////////////////////////////////////////////////////////////////////////
	this.CleanFilePaths = function( namesUnclean ){
		var itemsCleaned = new Array();
		for(var c=0;c<namesUnclean.length;c++){
			var newName = this.CleanFilePath(namesUnclean[c]);
			if (newName!="")
				itemsCleaned[itemsCleaned.length] = newName;
		}
		return itemsCleaned;
	}
}
///////////////////////////////////////////////////////////////////////////////
function Log(text, lvl, ind){ //XLog v0.3
	var lvs={o:0,x:1,e:2,w:3,i:4,n:5,t:6,d:7},i=["","X","E","W","I","","",""];
	try{XLog;}		catch(e){ var v=DOpus.Vars; if (v.Exists("XLog"))
	try{XLogForce;}	catch(e){ XLog=v.Get("XLog"); }}
	try{XLog;}		catch(e){ var c=Script.Config; if(c.XLog) XLog=c.XLog; }
	try{XLog;}		catch(e){ 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!="-") DOpus.Output(pad+text,(lvl==1||lvl==2)?1:0);
	ind = (ind!==undefined?ind:0); XLog.I+=ind;
	if (XLog.I<0) throw new Error("XLog indent went sub-zero.");
}
///////////////////////////////////////////////////////////////////////////////
function FSMagic(){
	this.version = 0.31;
	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.OpenFile = function(filePath, mode, encoding){
		mode = mode || "r"; encoding = encoding || "unicode";
		var testEncoding = (encoding=="try"?true:false);
		var encodings = {ascii:0,unicode:-1,def:-2}, modes = {r:1,w:2,a:8};
		try{
			if (mode=="w" && this.fso.FileExists(filePath)) this.fso.DeleteFile(filePath);
			if (mode=="r" && testEncoding) encoding="ascii";
			var file = this.fso.OpenTextFile(filePath, modes[mode], true, encodings[encoding]);
			if (testEncoding && mode!="w" && !file.AtEndOfStream){
				var line = file.ReadLine();
				if (line.indexOf("")==0) {//utf8 bom
					Log("Unsupported UTF8 file detected, convert to UTF16-LE or UNICODE first (with notepad maybe).", "X");
					file.Close(); return null;
				}
				if (line.indexOf("þÿ")==0) {//utf16 be bom
					Log("Unsupported UTF16-BE file detected, convert to UTF16-LE or UNICODE first (with notepad maybe).", "X");
					file.Close(); return null;
				}
				if (line.indexOf("ÿþ") == 0) encoding="unicode"; //utf16 le bom
				file.Close(); //close and reopen file, since we cannot rewind the textstream in case
				//it is ascii and for unicode we need to reopen it anyway
				var file = this.fso.OpenTextFile(filePath, modes[mode], true, encodings[encoding]);
			}
			return file;
		} catch(e){
			Log("Error opening file ["+filePath+"]: " + e, "D");
			return null;
		}
	}
	///////////////////////////////////////////////////////////////////////////
	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 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 DumpObject(o, name, upperCaseProps, self, level){
	this.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('http://resource.dopus.com/viewtopic.php?f=35&t=23179');}
	else
		cmd.RunCommand('ScriptWizard ABOUT WIN='+data.window+' FILE="'+Script.File+'"');
}
//MD5 = "d0056769cb24969bb39b64721d12a3b5"; DATE = "2015.06.11 - 22:39:36"