/******************************************************************************
	NintendoWare for CTR Maya Plugin

	File:         NW4C_SetAnimRange.mel
	Description:  set animation range
	Date:         2010/08/30
	Author:       Takashi Endo

	Copyright 2010 Nintendo Co., Ltd. All rights reserved.
*****************************************************************************/

// GetDagList GetAnimRangeList UpdateView SetEditorCurrent
// CreateAnimRangeNode AddAnimRangeAttr
// ImportAnimRange ExportAnimRange
// DropAnimRange

/******************************************************************************
	confirm dialog check window
******************************************************************************/
proc int ConfirmDialogCheckWin(string $parent, string $msg)
{
	$msg += "Are you sure ?";
	string $ret;
	if (`window -q -ex $parent`)
	{
		$ret = `confirmDialog -t "Confirm" -p $parent
			-m $msg -ma "center"
			-b "Yes" -b "No" -db "No" -ds "No"`;
	}
	else
	{
		$ret = `confirmDialog -t "Confirm"
			-m $msg -ma "center"
			-b "Yes" -b "No" -db "No" -ds "No"`;
	}
	return ($ret == "Yes");
}

/******************************************************************************
	get window name string
******************************************************************************/
proc string GetWindowNameString()
{
	return "nw4cSetAnimRange_Win";
}

/******************************************************************************
	do error
******************************************************************************/
proc DoError(string $msg)
{
	catch(`error $msg`);
}

/******************************************************************************
	get number of clip
******************************************************************************/
proc int GetNumberOfClip()
{
	return 50;
}

/******************************************************************************
	string array found
******************************************************************************/
proc int IsStringInArray(string $item, string $list[])
{
	string $listItem;
	for ($listItem in $list)
	{
		if ($item == $listItem)
		{
			return true;
		}
	}
	return false;
}

/******************************************************************************
	float to int
******************************************************************************/
proc int FloatToInt(float $f)
{
	int $n = (int)$f;
	float $m = $f - $n;
	if ($m <= -0.5)
	{
		$n--;
	}
	else if ($m >= 0.5)
	{
		$n++;
	}
	return $n;
}

/******************************************************************************
	get attr title list
******************************************************************************/
proc string[] GetAttrTitleList(string $animRange)
{
	int $i;
	int $no = GetNumberOfClip();
	string $list[];
	for ($i = 0; $i < $no; ++$i)
	{
		$list[$i] = `getAttr ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]")`;
	}
	return $list;
}

/******************************************************************************
	get default animation range title
******************************************************************************/
proc string GetDefaultAnimRangeTitle(int $i)
{
	//return "";
	string $str = $i;
	while (size($str) < 2)
	{
		$str = "0" + $str;
	}
	return ("default" + $str);
}

/******************************************************************************
	get unique animation range title
******************************************************************************/
proc string GetUniqueAnimRangeTitle(string $animRange, int $i)
{
	string $list[] = GetAttrTitleList($animRange);
	string $str = GetDefaultAnimRangeTitle($i);
	if ($str == $list[$i])
	{
		return $str;
	}
	if (!IsStringInArray($str, $list))
	{
		return $str;
	}

	int $idx, $j;
	int $no = GetNumberOfClip();
	for ($idx = 0; $idx < $no; ++$idx)
	{
		$str = GetDefaultAnimRangeTitle($idx);
		for ($j = 0; $j < $no; ++$j)
		{
			if ($i == $j)
			{
				continue;
			}
			if ($str == $list[$j])
			{
				break;
			}
		}
		if ($j >= $no)
		{
			break;
		}
	}
	return $str;
}

/******************************************************************************
	add animation range attr
******************************************************************************/
global proc nw4cSetAnimRange_AddAnimRangeAttr(string $animRange)
{
	int $i;
	int $no = GetNumberOfClip();

	// merge cmdl
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeMergeCmdlFlag"`)
	{
		addAttr -at "bool" -k 0 -ln "nw4c_AnimRangeMergeCmdlFlag" -h 1 -dv 0 $animRange;
	}
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeMergeCmdlPath"`)
	{
		addAttr -dt "string" -k 0 -ln "nw4c_AnimRangeMergeCmdlPath" -h 1 $animRange;
	}

	// custom opts
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeEnableCustomOpts"`)
	{
		addAttr -at "bool" -k 0 -ln "nw4c_AnimRangeEnableCustomOpts" -h 1 -dv 0 $animRange;
	}
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeCompressNode"`)
	{
		addAttr -at "enum" -k 0 -ln "nw4c_AnimRangeCompressNode"
			-en "None=0:CullUseless=1:CullUninfluential=2:UniteCompressible=3:UniteAll=4:UniteBelow=5" -h 1 -dv 0 $animRange;
	}
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeCompressMaterial"`)
	{
		addAttr -at "bool" -k 0 -ln "nw4c_AnimRangeCompressMaterial" -h 1 -dv 0 $animRange;
	}
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeOptimizePrimitive"`)
	{
		addAttr -at "bool" -k 0 -ln "nw4c_AnimRangeOptimizePrimitive" -h 1 -dv 0 $animRange;
	}
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeDisableSkeletalModelSimplification"`)
	{
		addAttr -at "bool" -k 0 -ln "nw4c_AnimRangeDisableSkeletalModelSimplification" -h 1 -dv 0 $animRange;
	}

	// animation range
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeEnable"`)
	{
		addAttr -at "bool" -k false -ln "nw4c_AnimRangeEnable" -h 1 -dv false -m $animRange;
		setAttr -s $no ($animRange + "." + "nw4c_AnimRangeEnable");
		for ($i = 0; $i < $no; ++$i)
		{
			setAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]") false;
		}
	}
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeLoop"`)
	{
		addAttr -at "bool" -k false -ln "nw4c_AnimRangeLoop" -h 1 -dv false -m $animRange;
		setAttr -s $no ($animRange + "." + "nw4c_AnimRangeLoop");
		for ($i = 0; $i < $no; ++$i)
		{
			setAttr ($animRange + "." + "nw4c_AnimRangeLoop" + "[" + $i + "]") false;
		}
	}
	if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeName"`)
	{
		addAttr -dt "string" -k false -ln "nw4c_AnimRangeName" -h 1 -m $animRange;
		setAttr -s $no ($animRange + "." + "nw4c_AnimRangeName");
		for ($i = 0; $i < $no; ++$i)
		{
			setAttr -typ "string" ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]")
				`GetDefaultAnimRangeTitle $i`;
		}
	}
	else // for old version
	{
		for ($i = 0; $i < $no; ++$i)
		{
			if (`getAttr ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]")` == "")
			{
				setAttr -typ "string" ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]")
					`GetUniqueAnimRangeTitle $animRange $i`;
			}
		}
	}
	for ($i = 0; $i < $no; ++$i)
	{
		if (!`attributeQuery -n $animRange -ex ("nw4c_AnimRange" + $i)`)
		{
			addAttr -at "short" -k true -ln ("nw4c_AnimRange" + $i) -h 1
				-dv ($i * (-1)) -min ($i * (-1)) -max ($i * (-1)) $animRange;
		}
	}
}

/******************************************************************************
	parent animation range
******************************************************************************/
proc string ParentAnimRange(string $wName, string $animRange, string $dag)
{
	string $list[] = `ls $animRange`;

	string $sel[] = `ls -sl`;
	int $i, $j = -1;
	for ($i = 0; $i < size($sel); ++$i)
	{
		if ($list[0] == $sel[$i])
		{
			$j = $i;
			break;
		}
	}

	nameField -e -o $list[0] ($wName + "AnimRangeNameWork");
	if ($dag != "")
	{
		catch(`parent $list[0] $dag`);
	}
	else
	{
		catch(`parent -w $list[0]`);
	}
	$list[0] = `nameField -q -o ($wName + "AnimRangeNameWork")`;
	$list = `ls $list[0]`;

	if ($j >= 0)
	{
		$sel[$j] = $list[0];
	}
	if (size($sel))
	{
		select -r $sel;
	}
	else
	{
		select -cl;
	}
	return $list[0];
}

/******************************************************************************
	create animation range node
******************************************************************************/
proc string CreateAnimRangeNode(string $wName, string $dag)
{
	string $animRange = "";
	string $sel[] = `ls -l -sl`;
	$animRange = `createNode "transform" -n "nw4c_AnimRangeCtrl"`;
	toggle -te -st true $animRange; // template = true (same as next line ?)
	setAttr -l true ($animRange + ".template");
	string $keyAttrList[] = `listAnimatable $animRange`;
	string $keyAttr;
	for ($keyAttr in $keyAttrList)
	{
		setAttr -k false $keyAttr;
	}
	nw4cSetAnimRange_AddAnimRangeAttr($animRange);

	if (size($sel))
	{
		select -r $sel;
	}
	else
	{
		select -cl;
	}

	if ($dag != "")
	{
		if (`objExists $dag`)
		{
			$animRange = ParentAnimRange($wName, $animRange, $dag);
		}
	}
	return $animRange;
}

/******************************************************************************
	is animation range
******************************************************************************/
proc int IsAnimRange(string $animRange)
{
	if (`objExists $animRange`)
	{
		if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeEnable"`)
		{
			return false;
		}
//		int $i = 0;
//		int $no = GetNumberOfClip();
////		for ($i = 0; $i < $no; ++$i)
//		for ($i = 0; $i < 1; ++$i)
//			if (!`attributeQuery -n $animRange -ex ("nw4c_AnimRange" + $i)`)
//				break;
////		if ($i < $no)
//		if ($i < 1)
//			return false;
//
//		if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeLoop"`)
//			return false;
//		if (!`attributeQuery -n $animRange -ex "nw4c_AnimRangeName"`)
//			return false;
		return true;
	}
	return false;
}

/******************************************************************************
	delete animation range node
******************************************************************************/
proc DeleteAnimRangeNode(string $node)
{
	catch(`delete $node`);
}

/******************************************************************************
	enable key change script
******************************************************************************/
proc EnableKeyChangeScript(string $wName, string $animRange, int $i, int $en)
{
	if ($en)
	{
		scriptJob -p ($wName + "ClipStart" + $i) -rp
			-ac ($animRange + "." + "nw4c_AnimRange" + $i)
			("nw4cSetAnimRange_OnKeyChange " + $wName + " " + $i);
		scriptJob -p ($wName + "ClipEnable" + $i) -rp
			-ac ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]")
			("nw4cSetAnimRange_OnEnableChange " + $wName + " " + $i);
	}
	else
	{
		scriptJob -p ($wName + "ClipStart" + $i) -rp
			-ac ($animRange + "." + "nw4c_AnimRange" + $i) "";
		scriptJob -p ($wName + "ClipEnable" + $i) -rp
			-ac ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]") "";
		scriptJob -p ($wName + "ClipLoop" + $i) -rp
			-ac ($animRange + "." + "nw4c_AnimRangeLoop" + "[" + $i + "]") ""; // added (2006/04/10)
	}
}

/******************************************************************************
	get time range from key
******************************************************************************/
proc float[] GetTimeRangeFromKey(string $animRange, int $i)
{
	float $ret[], $f[];
	int $n = `keyframe -q -kc ($animRange + "." + "nw4c_AnimRange" + $i)`;
	if ($n)
	{
		$ret[0] = `findKeyframe -w "first" ($animRange + "." + "nw4c_AnimRange" + $i)`;
		$ret[1] = `findKeyframe -w "last" ($animRange + "." + "nw4c_AnimRange" + $i)`;
	}
	else
	{
		$ret[0] = 0;
		$ret[1] = 0;
	}
	return $ret;
}

/******************************************************************************
	set time range to key
******************************************************************************/
proc SetTimeRangeToKey(string $wName, string $animRange, int $i, float $s, float $e)
{
	EnableKeyChangeScript($wName, $animRange, $i, false);
	string $attr = "nw4c_AnimRange" + $i;
	cutKey -cl -at $attr $animRange;
	if ($s != $e)
	{
		setKeyframe -bd false -hi none -cp false -s false -at $attr
			-t $s -v (-$i) -itt "flat" -ott "step" $animRange; // start
	}
		setKeyframe -bd false -hi none -cp false -s false -at $attr
			-t $e -v (-$i) -itt "flat" -ott "step" $animRange; // end
	EnableKeyChangeScript($wName, $animRange, $i, true);
}

/******************************************************************************
	display time range
******************************************************************************/
proc DisplayTimeRange(string $wName, int $i, float $s, float $e)
{
	floatField -e -v $s ($wName + "ClipStart" + $i);
	floatField -e -v $e ($wName + "ClipEnd" + $i);
	// changed from original (2006/04/10)
	//text -e -l (`FloatToInt $e` - `FloatToInt $s`) ($wName + "ClipSpan" + $i);
	int $frameSize = `FloatToInt $e` - `FloatToInt $s`;
	if (!`checkBox -q -v ($wName + "ClipLoop" + $i)` || $frameSize == 0)
	{
		++$frameSize;
	}
	text -e -l $frameSize ($wName + "ClipSpan" + $i);
}

/******************************************************************************
	connect animation range control
******************************************************************************/
proc ConnectAnimRangeControl(string $wName, string $animRange)
{
	//trace "connect";
	connectControl ($wName + "MergeCmdlFlag") ($animRange + "." + "nw4c_AnimRangeMergeCmdlFlag");
	connectControl ($wName + "MergeCmdlPath") ($animRange + "." + "nw4c_AnimRangeMergeCmdlPath");

	connectControl -in 2 ($wName + "EnableCustomOpts") ($animRange + "." + "nw4c_AnimRangeEnableCustomOpts");
	connectControl -in 2 ($wName + "CompressNode") ($animRange + "." + "nw4c_AnimRangeCompressNode");
	connectControl -in 2 ($wName + "CompressMaterial") ($animRange + "." + "nw4c_AnimRangeCompressMaterial");
	connectControl -in 2 ($wName + "OptimizePrimitive") ($animRange + "." + "nw4c_AnimRangeOptimizePrimitive");
	connectControl -in 2 ($wName + "DisableSkeletalModelSimplification") ($animRange + "." + "nw4c_AnimRangeDisableSkeletalModelSimplification");

	float $f[];
	int $no = GetNumberOfClip();
	int $i;
	for ($i = 0; $i < $no; ++$i)
	{
		connectControl ($wName + "ClipEnable" + $i) ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]");
		connectControl ($wName + "ClipLoop" + $i) ($animRange + "." + "nw4c_AnimRangeLoop" + "[" + $i + "]");
		connectControl ($wName + "ClipName" + $i) ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]");

		// no attr-change-event from anim-editor (Maya bugfix)
		connectControl ($wName + "ClipAttr" + $i) ($animRange + "." + "nw4c_AnimRange" + $i);

		$f = GetTimeRangeFromKey($animRange, $i);
		DisplayTimeRange($wName, $i, $f[0], $f[1]);
		nw4cSetAnimRange_OnEnableChange($wName, $i);

		// link script
		EnableKeyChangeScript($wName, $animRange, $i, true);
		floatField -e -cc ("nw4cSetAnimRange_OnKeyChangeUI " + $wName + " " + $i + " s") ($wName + "ClipStart" + $i);
		floatField -e -cc ("nw4cSetAnimRange_OnKeyChangeUI " + $wName + " " + $i + " e") ($wName + "ClipEnd" + $i);
	}
}

/******************************************************************************
	get current dag
******************************************************************************/
proc string GetCurrentDag(string $wName)
{
	if (`window -ex $wName`)
	{
		if (`nameField -q -en ($wName + "DagName")`)
		{
			string $dag = `nameField -q -o ($wName + "DagName")`;
			if ($dag != "")
			{
				if (`objExists $dag`)
				{
					return $dag;
				}
			}
		}
	}
	return "";
}

/******************************************************************************
	get current animation range
******************************************************************************/
proc string GetCurrentAnimRange(string $wName)
{
	if (`window -ex $wName`)
	{
		//if (`nameField -q -en ($wName + "AnimRangeName")`)
		if (`nameField -q -en ($wName + "AnimRangeNameMaster")`)
		{
			string $animRange = `nameField -q -o ($wName + "AnimRangeName")`;
			if ($animRange != "")
			{
				if (`objExists $animRange`)
				{
					return $animRange;
				}
			}
		}
	}
	return "";
}

/******************************************************************************
	save title list
******************************************************************************/
proc SaveTitleList(string $wName, string $animRange)
{
	int $i;
	int $no = GetNumberOfClip();
	string $list[] = GetAttrTitleList($animRange);
	textScrollList -e -ra ($wName + "_ClipNameList");
	for ($i = 0; $i < $no; ++$i)
	{
		textScrollList -e -a (" " + $list[$i]) ($wName + "_ClipNameList");	// add header space for null string
	}
}

/******************************************************************************
	restore title list
******************************************************************************/
proc RestoreTitleList(string $wName, string $animRange, int $i)
{
	string $org[] = `textScrollList -q -ai ($wName + "_ClipNameList")`;
	string $str = "";
	if (size($org[$i]) > 1)
	{
		$str = substring($org[$i], 2, size($org[$i]));						// remove header space for null string
	}
	setAttr -typ "string" ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]") $str;
}

/******************************************************************************
	merge cmdl flag CB
******************************************************************************/
global proc nw4cSetAnimRange_MergeCmdlFlagCB(string $wName)
{
	string $flagCtrl = $wName + "MergeCmdlFlag";
	int $enable = false;
	if (`control -q -en $flagCtrl`)
	{
		$enable = `checkBox -q -v $flagCtrl`;
	}
	control -e -en $enable ($wName + "MergeCmdlPath");
	control -e -en $enable ($wName + "MergeCmdlBrowser");
}

/******************************************************************************
	merge cmdl browser CB
******************************************************************************/
global proc nw4cSetAnimRange_MergeCmdlBrowserCB(string $wName)
{
	string $pathCtrl = $wName + "MergeCmdlPath";
	string $curPath = `textField -q -tx $pathCtrl`;
	if (size($curPath) > 0)
	{
		$curPath = dirname($curPath);
		$curPath = (`filetest -d $curPath`) ? ($curPath + "/") : "";
		//NW4C_SetCurDirFromFile($curPath);
		//trace ("cur: " + $curPath);
	}
	string $newPath = `fileDialog -dm ($curPath + "*.cmdl")`;
	if (size($newPath) > 0)
	{
		textField -e -tx $newPath $pathCtrl;
		// set attr direct
		// because connectControl is not effective for change in mel
		string $animRange = GetCurrentAnimRange($wName);
		if ($animRange != "")
		{
			setAttr -typ "string" ($animRange + "." + "nw4c_AnimRangeMergeCmdlPath") $newPath;
		}
	}
}

/******************************************************************************
	enable custom opts callback
******************************************************************************/
global proc nw4cSetAnimRange_EnableCustomOptsCB(string $wName)
{
	int $enable = false;
	if (`control -q -en ($wName + "EnableCustomOpts")`)
	{
		$enable = `checkBoxGrp -q -v1 ($wName + "EnableCustomOpts")`;
	}
	string $label = "Custom Options";
	control -e -en $enable ($wName + "CompressNode");
	control -e -en $enable ($wName + "CompressMaterial");
	control -e -en $enable ($wName + "OptimizePrimitive");
	control -e -en $enable ($wName + "DisableSkeletalModelSimplification");
	frameLayout -e -l $label ($wName + "CustomOptsLayout");
}

/******************************************************************************
	set editor current
******************************************************************************/
proc SetEditorCurrent(string $wName, string $animRange)
{
	int $enable = ($animRange != "");

	if ($enable)
	{
		nameField -e -en true -o $animRange ($wName + "AnimRangeNameMaster");
		nameField -e -en true -o $animRange ($wName + "AnimRangeName");
		nw4cSetAnimRange_AddAnimRangeAttr($animRange);
		layout -e -en true ($wName + "Editor");
		ConnectAnimRangeControl($wName, $animRange);
		SaveTitleList($wName, $animRange);
	}
	else
	{
		nameField -e -en false ($wName + "AnimRangeNameMaster");
		nameField -e -en false ($wName + "AnimRangeName");
		layout -e -en false ($wName + "Editor");
	}

	control -e -en $enable ($wName + "MergeCmdlFlag");
	nw4cSetAnimRange_MergeCmdlFlagCB($wName);

	string $optsLayout = $wName + "CustomOptsLayout";
	control -e -en $enable ($wName + "EnableCustomOpts");
	if (!$enable)
	{
		//frameLayout -e -cl true $optsLayout;
	}
	nw4cSetAnimRange_EnableCustomOptsCB($wName);
}

/******************************************************************************
	is special root node
******************************************************************************/
proc int IsSpecialRootNode(string $node)
{
	string $type = nodeType($node);
	string $childs[] = `listRelatives -pa -s $node`;
	if (size(`ls -cameras -lights -typ environmentFog $childs`) > 0 ||
		$type == "lookAt")
	{
		return true;
	}
	return false;
}

/******************************************************************************
	get dag list
******************************************************************************/
proc string[] GetDagList()
{
	string $works[] = `ls -as`;
	string $exlist[] = { "persp", "top", "front", "side" };
	$works = stringArrayRemove($exlist, $works);

	string $list[];
	string $item;
	for ($item in $works)
	{
		if (!IsSpecialRootNode($item))
		{
			$list[size($list)] = $item;
		}
	}
	if (size($list))
	{
		$list = `sort $list`;
	}
	return $list;
}

/******************************************************************************
	get animation range list
******************************************************************************/
proc string[] GetAnimRangeList()
{
	string $list[] = `ls -tr -tm`; // transform & templated
	string $retList[];
	string $item;
	for ($item in $list)
	{
		if (IsAnimRange($item))
		{
			$retList[size($retList)] = $item;
		}
	}
	if (size($retList))
	{
		$retList = `sort $retList`;
	}
	return $retList;
}

/******************************************************************************
	get animation range from dag
******************************************************************************/
proc string GetAnimRangeFromDag(string $dag)
{
	string $ret = "";
	if (`objExists $dag`)
	{
		string $list[] = `listRelatives -pa -typ "transform" $dag`;
		string $item;
		for ($item in $list)
		{
			if (IsAnimRange($item))
			{
				$ret = $item;
				break;
			}
		}
	}
	return $ret;
}

/******************************************************************************
	get dag from animation range
******************************************************************************/
proc string GetDagFromAnimRange(string $animRange)
{
	string $ret = "";
	if (`objExists $animRange`)
	{
		string $list[] = `listRelatives -pa -p -typ "transform" $animRange`;
		string $item;
		if ($list[0] != "")
		{
			string $dags[] = GetDagList();
			if (size($dags))
			{
				if (IsStringInArray($list[0], $dags))
				{
					$ret = $list[0];
				}
			}
		}
	}
	return $ret;
}

/******************************************************************************
	relation dag to animation range list
******************************************************************************/
proc RelationDagToAnimRangeList(string $wName, string $dag)
{
	string $animRange = GetAnimRangeFromDag($dag);
	if ($animRange != "")
	{
		SetEditorCurrent($wName, $animRange);
		nw4cSetAnimRange_UpdateAnimRangeList($wName, 0);
	}
	else
	{
		SetEditorCurrent($wName, "");
		textScrollList -e -da ($wName + "AnimRangeList");
	}
}

/******************************************************************************
	relation animation range to dag list
******************************************************************************/
proc RelationAnimRangeToDagList(string $wName, string $animRange)
{
	string $dag = GetDagFromAnimRange($animRange);
	if ($dag != "")
	{
		nameField -e -en true -o $dag ($wName + "DagName");
		nw4cSetAnimRange_UpdateDagList($wName);
	}
	else
	{
		nameField -e -en false ($wName + "DagName");
		textScrollList -e -da ($wName + "DagList");
	}
}

/******************************************************************************
	quick sort
******************************************************************************/
proc QuickSort(string $a[], int $idx[], int $left, int $right, string $compare)
{
	int $i, $j, $t;
	string $s;
	if ($left < $right)
	{
		$s = $a[$idx[($left + $right) / 2]];
		$i = $left - 1;
		$j = $right + 1;
		while (1)
		{
			while(eval($compare + " \"" + $a[$idx[++$i]] + "\" \"" + $s + "\"") < 0)
				;
			while(eval($compare + " \"" + $a[$idx[--$j]] + "\" \"" + $s + "\"") > 0)
				;
			if ($i >= $j)
			{
				break;
			}
			$t = $idx[$i];
			$idx[$i] = $idx[$j];
			$idx[$j] = $t;
		}
		QuickSort($a, $idx, $left, ($i - 1), $compare);
		QuickSort($a, $idx, ($j + 1), $right, $compare);
	}
}

/******************************************************************************
	quick sort string array
******************************************************************************/
proc string[] QsortStringArray(string $array[], string $compare)
{
	int $sz = size($array);
	if ($sz <= 1)
	{
		return $array;
	}

	int $i, $idx[];
	for ($i = ($sz - 1); $i >= 0; --$i)
	{
		$idx[$i] = $i;
	}
	QuickSort($array, $idx, 0, ($sz - 1), $compare);

	// string list
	string $retList[];
	for ($i = ($sz - 1); $i >= 0; --$i)
	{
		$retList[$i] = $array[$idx[$i]];
	}
	return $retList;
}

/******************************************************************************
	merge float range array
******************************************************************************/
proc MergeFloatRangeArray(float $s[], float $e[], float $sf[], float $ef[])
{
	int $chk;
	int $i, $j;

	if (!size($s) || !size($e) || (size($s) != size($e)))
	{
		return;
	}

	while(1)
	{
		clear($sf);
		clear($ef);
		$chk = 0;
		$sf[0] = $s[0];
		$ef[0] = $e[0];
		for ($i = 1; $i < size($s); ++$i)
		{
			for ($j = 0; $j < size($sf); ++$j)
			{
				if ($sf[$j] <= $s[$i] && $e[$i] <= $ef[$j])
				{
					$chk = 1;
				}
				else if ($sf[$j] <= $s[$i] && $s[$i] <= ($ef[$j] + 1))
				{
					$ef[$j] = $e[$i];
					$chk = 1;
				}
				else if (($sf[$j] - 1) <= $e[$i] && $e[$i] <= $ef[$j])
				{
					$sf[$j] = $s[$i];
					$chk = 1;
				}
				else if ($sf[$j] > $s[$i] && $e[$i] > $ef[$j])
				{
					$sf[$j] = $s[$i];
					$ef[$j] = $e[$i];
					$chk = 1;
				}
				else
				{
					continue;
				}
				break;
			}
			if ($j >= size($sf))
			{
				$sf[size($sf)] = $s[$i];
				$ef[size($ef)] = $e[$i];
			}
		}
		if (!$chk)
		{
			break;
		}

		clear($s);
		clear($e);
		for ($j = 0; $j < size($sf); ++$j)
		{
			$s[$j] = $sf[$j];
			$e[$j] = $ef[$j];
		}
	}
	string $array[];
	for ($i = 0; $i < size($sf); ++$i)
	{
		$array[$i] = $sf[$i] + "," + $ef[$i];
	}
	$array = QsortStringArray($array, "nw4cSetAnimRange_CompareFloatRange");
	string $tokBuf[];
	for ($i = 0; $i < size($sf); ++$i)
	{
		tokenize $array[$i] "," $tokBuf;
		$sf[$i] = (float)$tokBuf[0];
		$ef[$i] = (float)$tokBuf[1];
	}
}

/******************************************************************************
	enable change CB
******************************************************************************/
global proc nw4cSetAnimRange_OnEnableChange(string $wName, int $i)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}
	int $en = `getAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]")`;
	floatField -e -en $en ($wName + "ClipStart" + $i);
	floatField -e -en $en ($wName + "ClipEnd" + $i);
	checkBox -e -en $en ($wName + "ClipLoop" + $i);
	textField -e -en $en ($wName + "ClipName" + $i);
	button -e -en $en ($wName + "ClipNo" + $i);
}

/******************************************************************************
	key change CB
******************************************************************************/
global proc nw4cSetAnimRange_OnKeyChange(string $wName, int $i)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}
	float $f[] = GetTimeRangeFromKey($animRange, $i);
	DisplayTimeRange($wName, $i, $f[0], $f[1]);
}

/******************************************************************************
	key change add key CB
******************************************************************************/
global proc nw4cSetAnimRange_OnKeyChangeAddKey(string $wName)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}
	string $list[] = `keyframe -q -sl -n $animRange`;
	if (size($list))
	{
		int $i;
		int $no = GetNumberOfClip();
		for ($i = 0; $i < $no; ++$i)
		{
			$list = `keyframe -q -sl -n ($animRange + "." + "nw4c_AnimRange" + $i)`;
			if (size($list))
			{
				nw4cSetAnimRange_OnKeyChange($wName, $i);
			}
		}
	}
}

/******************************************************************************
	key change UI CB
******************************************************************************/
global proc nw4cSetAnimRange_OnKeyChangeUI(string $wName, int $i, string $which)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}
	float $s = `floatField -q -v ($wName + "ClipStart" + $i)`;
	float $e = `floatField -q -v ($wName + "ClipEnd" + $i)`;
	float $f[] = GetTimeRangeFromKey($animRange, $i);

	if ($which == "s")
	{
		if ($f[0] != $s)
		{
			if ($s >= $e)
			{
				//$e = $s + 1;
				$e = $s; // if allow s = e // changed from original (2006/03/07)
			}
		}
	}
	else
	{
		if ($f[1] != $e)
		{
			if ($s >= $e)
			{
				//$s = $e - 1;
				$s = $e; // if allow s = e // changed from original (2006/03/07)
			}
		}
	}

	DisplayTimeRange($wName, $i, $s, $e);
	//if ($f[0] != $s || $f[1] != $e)
	if ($f[0] != $s || $f[1] != $e ||
		`keyframe -q -kc ($animRange + "." + "nw4c_AnimRange" + $i)` == 0) // changed from original (2006/04/07)
	{
		SetTimeRangeToKey($wName, $animRange, $i, $s, $e);
	}
}

/******************************************************************************
	select dag list CB
******************************************************************************/
global proc nw4cSetAnimRange_OnSelectDagList(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	string $sel[] = `textScrollList -q -si ($wName + "DagList")`;
	if (size($sel))
	{
		nameField -e -en true -o $sel[size($sel) - 1] ($wName + "DagName");
		RelationDagToAnimRangeList($wName, $sel[size($sel) - 1]);
	}
}

/******************************************************************************
	double click dag list CB
******************************************************************************/
global proc nw4cSetAnimRange_OnDblClkDagList(string $wName)
{
	string $dag = GetCurrentDag($wName);
	if ($dag != "")
	{
		select -r $dag;
	}
}

/******************************************************************************
	select animation range list CB
******************************************************************************/
global proc nw4cSetAnimRange_OnSelectAnimRangeList(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	string $sel[] = `textScrollList -q -si ($wName + "AnimRangeList")`;
	if (size($sel))
	{
		SetEditorCurrent($wName, $sel[size($sel) - 1]);
		RelationAnimRangeToDagList($wName, $sel[size($sel) - 1]);
	}
}

/******************************************************************************
	double click animation range list CB
******************************************************************************/
global proc nw4cSetAnimRange_OnDblClkAnimRangeList(string $wName)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange != "")
	{
		select -r $animRange;
	}
}

/******************************************************************************
	dag list menu CB
******************************************************************************/
global proc nw4cSetAnimRange_OnMenuDagList(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	string $sel[] = `textScrollList -q -si ($wName + "DagList")`;
	int $en = false;
	if (size($sel))
	{
		if (`objExists $sel[size($sel) - 1]`)
		{
			if (GetAnimRangeFromDag($sel[size($sel) - 1]) == "")
			{
				$en = true;
			}
		}
	}
	menuItem -e -en $en ($wName + "DagListMenuItem1");
}

/******************************************************************************
	animation range list menu CB
******************************************************************************/
global proc nw4cSetAnimRange_OnMenuAnimRangeList(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	string $sel[] = `textScrollList -q -si ($wName + "AnimRangeList")`;
	int $en = false;
	string $animRange;
	if (size($sel))
	{
		$animRange = $sel[size($sel) - 1];
		if (`objExists $animRange`)
		{
			$en = true;
		}
	}
	menuItem -e -en $en ($wName + "AnimRangeListMenuItem2");
	menuItem -e -en $en ($wName + "AnimRangeListMenuItem5");

	int $con = $en;
	if ($en)
	{
		if (GetDagFromAnimRange($animRange) != "")
		{
			$en = false;
		}
		else
		{
			$con = false;
		}
	}
	if ($en)
	{
		$sel = `textScrollList -q -ai ($wName + "DagList")`;
		string $list[];
		string $dag;
		if (size($sel))
		{
			for ($dag in $sel)
			{
				if (`objExists $dag`)
				{
					if (GetAnimRangeFromDag($dag) == "")
					{
						$list[size($list)] = $dag;
					}
				}
			}
		}
		if (size($list))
		{
			popupMenu -e -dai ($wName + "AnimRangeListMenuItem3");
			setParent -menu ($wName + "AnimRangeListMenuItem3");
			for ($dag in $list)
			{
				menuItem -l $dag -c ("nw4cSetAnimRange_AttachAnimRange " + $wName + " " + $dag);
			}
		}
		else
		{
			$en = false;
		}
	}
	menuItem -e -en $en ($wName + "AnimRangeListMenuItem3");
	menuItem -e -en $con ($wName + "AnimRangeListMenuItem4");
}

/******************************************************************************
	create animation range
******************************************************************************/
global proc nw4cSetAnimRange_CreateAnimRange(string $wName, string $mode)
{
	if (!`window -ex $wName`)
	{
		return;
	}
	string $dag;
	if ($mode == "a")
	{
		string $sel[] = `textScrollList -q -si ($wName + "DagList")`;
		if (size($sel))
		{
			$dag = $sel[size($sel) - 1];
		}
	}
	string $animRange = CreateAnimRangeNode($wName, $dag);
	SetEditorCurrent($wName, $animRange);
}

/******************************************************************************
	duplicate animation range
******************************************************************************/
global proc nw4cSetAnimRange_DuplicateAnimRange(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	string $sel[] = `textScrollList -q -si ($wName + "AnimRangeList")`;
	if (size($sel))
	{
		if (`objExists $sel[size($sel) - 1]`)
		{
			string $list[] = `ls -l -sl`;
				string $cpy[] = `duplicate $sel[size($sel) - 1]`;;
				if (`copyKey $sel[size($sel) - 1]`)
				{
					pasteKey $cpy[0];
				}
			if (size($list))
			{
				select -r $list;
			}
			else
			{
				select -cl;
			}

			$sel = `listRelatives -pa -p $cpy[0]`;
			if (size($sel))
			{
				$cpy[0] = ParentAnimRange($wName, $cpy[0], "");
			}

			SetEditorCurrent($wName, $cpy[0]);
		}
	}
}

/******************************************************************************
	delete animation range control
******************************************************************************/
global proc nw4cSetAnimRange_DeleteAnimRangeCtrl(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}
	string $sel[] = `textScrollList -q -si ($wName + "AnimRangeList")`;
	if (size($sel))
	{
		if (!ConfirmDialogCheckWin($wName, "Delete " + $sel[size($sel) - 1] + ".\n"))
		{
			return;
		}
		DeleteAnimRangeNode($sel[size($sel) - 1]);
	}
}

/******************************************************************************
	attach animation range
******************************************************************************/
global proc nw4cSetAnimRange_AttachAnimRange(string $wName, string $dag)
{
	if (!`window -ex $wName`)
	{
		return;
	}
	string $sel[] = `textScrollList -q -si ($wName + "AnimRangeList")`;
	if (size($sel))
	{
		if (`objExists $sel[size($sel) - 1]`)
		{
			if (`objExists $dag`)
			{
				$sel[size($sel) - 1] = ParentAnimRange($wName, $sel[size($sel) - 1], $dag);
			}
		}
	}
}

/******************************************************************************
	dettach animation range
******************************************************************************/
global proc nw4cSetAnimRange_DeattachAnimRange(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}
	string $sel[] = `textScrollList -q -si ($wName + "AnimRangeList")`;
	if (size($sel))
	{
		if (`objExists $sel[size($sel) - 1]`)
		{
			$sel[size($sel) - 1] = ParentAnimRange($wName, $sel[size($sel) - 1], "");
		}
	}
}

/******************************************************************************
	file menu CB
******************************************************************************/
global proc nw4cSetAnimRange_OnMenuFile(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}
	int $en = false;
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange != "")
	{
		$en = true;
	}
	menuItem -e -en $en ($wName + "FileMenuItem1");
	menuItem -e -en $en ($wName + "FileMenuItem2");
}

/******************************************************************************
	get enabled time range array
******************************************************************************/
proc GetEnabledTimeRangeArray(string $animRange, float $sf[], float $ef[])
{
	int $i;
	float $s[], $e[], $f[];
	int $no = GetNumberOfClip();
	for ($i = 0; $i < $no; ++$i)
	{
		if (`getAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]")`)
		{
			$f = GetTimeRangeFromKey($animRange, $i);
			//if ($f[0] < $f[1])
			if ($f[0] <= $f[1]) // if allow s = e // changed from original (2006/03/07)
			{
				$s[size($s)] = $f[0];
				$e[size($e)] = $f[1];
			}
		}
	}
	clear($sf);
	clear($ef);
	if (size($s))
	{
		MergeFloatRangeArray($s, $e, $sf, $ef);
	}
}

/******************************************************************************
	make playback info
******************************************************************************/
proc MakePlaybackInfo(string $wName, string $animRange)
{
	int $i, $j, $l;
	float $f[], $sf[], $ef[];
	int $no = GetNumberOfClip();
	int $loop = `intField -q -v ($wName + "Loop")`;
	if ($loop <= 0)
	{
		$loop = 1;
	}

	for ($i = 0; $i < $no; ++$i)
	{
		if (`getAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]")`)
		{
			$f = GetTimeRangeFromKey($animRange, $i);
			$f[0] = (float)FloatToInt($f[0]);
			$f[1] = (float)FloatToInt($f[1]);
			if ($f[0] < $f[1])
			{
				if (`getAttr ($animRange + "." + "nw4c_AnimRangeLoop" + "[" + $i + "]")`)
				{
					$l = $loop;
				}
				else
				{
					$l = 1;
				}
				for ($j = 0; $j < $l; ++$j)
				{
					$sf[size($sf)] = $f[0];
					$ef[size($ef)] = $f[1];
				}
			}
		}
	}

	if (`window -ex ($wName + "AnimRange")`)
	{
		deleteUI ($wName + "AnimRange");
	}
	window ($wName + "AnimRange");
	formLayout;
	textScrollList ($wName + "sList");
	textScrollList ($wName + "eList");

	for ($i = 0; $i < size($sf); ++$i)
	{
		textScrollList -e -a ((string)$sf[$i]) ($wName + "sList");
		textScrollList -e -a ((string)$ef[$i]) ($wName + "eList");
	}
	if (size($sf))
	{
		if (`play -q -f`)
		{
			$i = 0;
		}
		else
		{
			$i = `size($sf)` - 1;
		}
		intField -v $i ($wName + "Pointer");
		floatField -v `playbackOptions -q -min` ($wName + "OrgMin"); // backup
		floatField -v `playbackOptions -q -max` ($wName + "OrgMax"); // backup
		textField -tx `playbackOptions -q -l` ($wName + "Looping"); // backup
		playbackOptions -min $sf[$i] -max $ef[$i] -l "once";
		if (`play -q -f`)
		{
			currentTime $sf[$i];
		}
		else
		{
			currentTime $ef[$i];
		}
	}
	else
	{
		play -st false;
	}
}

/******************************************************************************
	update playback button
******************************************************************************/
proc UpdatePlaybackButton(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	int $en0 = true, $en1 = true;
	int $cmd0 = 1, $cmd1 = 2;
	int $playFlag = `isTrue "playingBack"`;
	int $animRangePlayFlag = `window -ex ($wName + "AnimRange")`;

	if ($playFlag || $animRangePlayFlag)
	{
		if (!`checkBox -q -v ($wName + "PlaybackContinuous")`)
		{
			$en0 = $playFlag;
			$en1 = 0;
			$cmd0 = 0; // stop
		}
		else
		{
			$en0 = 0;
			$en1 = $playFlag;
			$cmd1 = 0; // stop
		}
	}

	string $img0 = ($cmd0) ?
		"nw4cSetAnimRange_Play.bmp" : "nw4cSetAnimRange_Stop.bmp";
	string $img1 = ($cmd1) ?
		"nw4cSetAnimRange_PlayLoop.bmp" : "nw4cSetAnimRange_Stop.bmp";
	string $ann0 = ($cmd0) ? "AnimRange Once" : "Stop";
	string $ann1 = ($cmd1) ? "AnimRange Continuous" : "Stop";

	symbolButton -e -en $en0 -i $img0 -w 26 -h 26 -ann $ann0
		-c ("nw4cSetAnimRange_OnPlaybackButton " + $wName + " " + $cmd0 + ";")
		($wName + "PlayBtn0");
	symbolButton -e -en $en1 -i $img1 -w 26 -h 26 -ann $ann1
		-c ("nw4cSetAnimRange_OnPlaybackButton " + $wName + " " + $cmd1 + ";")
		($wName + "PlayBtn1");
}

/******************************************************************************
	playback condition
******************************************************************************/
global proc int nw4cSetAnimRange_PlaybackCondition(string $wName)
{
	string $cmd;
	string $animRange;
	int $ret = false;
	int $i, $no;

	if (`isTrue "playingBack"`)
	{
		if (!`window -ex $wName`)
		{
			return true;
		}
		if (`checkBox -q -v ($wName + "PlaybackEnable")`)
		{
			$animRange = GetCurrentAnimRange($wName);
			if ($animRange != "")
			{
				layout -e -en false ($wName + "Pane");
				intField -e -en false ($wName + "Loop");
				MakePlaybackInfo($wName, $animRange);
			}
			checkBox -e -v false ($wName + "PlaybackEnable");
		}
		$ret = true;
	}
	else
	{
		if (`window -ex ($wName + "AnimRange")`)
		{
			if (`floatField -ex ($wName + "OrgMin")`)
			{
				if (`window -ex $wName`)
				{
					if (!`checkBox -q -v ($wName + "PlaybackStop")`)
					{
						int $fwd = `play -q -f`;
						string $s[] = `textScrollList -q -ai ($wName + "sList")`;
						string $e[] = `textScrollList -q -ai ($wName + "eList")`;
						if (size($s))
						{
							$i = `intField -q -v ($wName + "Pointer")`;
							if ($fwd)
							{
								++$i;
								if ($i >= size($s))
								{
									if (`checkBox -q -v ($wName + "PlaybackContinuous")`)
									{
										$i = 0;
									}
								}
							}
							else
							{
								$i--;
								if ($i < 0)
								{
									if (`checkBox -q -v ($wName + "PlaybackContinuous")`)
									{
										$i = size($s) - 1;
									}
								}
							}
							if (0 <= $i && $i < size($s))
							{
								intField -e -v $i ($wName + "Pointer");
								playbackOptions -min $s[$i] -max $e[$i];
								if ($fwd)
								{
									currentTime $s[$i];
								}
								else
								{
									currentTime $e[$i];
								}
								play -f $fwd;
								return true;
							}
						}

						float $max1;
						if ($fwd)
						{
							$max1 = `playbackOptions -q -max`;
						}
						else
						{
							$max1 = `playbackOptions -q -min`;
						}
						// assistance "move to playback end" (Maya bugfix)
						currentTime $max1;
					}
				}
				playbackOptions -min `floatField -q -v ($wName + "OrgMin")` -max `floatField -q -v ($wName + "OrgMax")`;
				playbackOptions -l (`textField -q -tx ($wName + "Looping")`);
			}
			deleteUI ($wName + "AnimRange");
		}

		if (!`window -ex $wName`)
		{
			evalDeferred("nw4cSetAnimRange_PlaybackExit " + $wName);
		}
		else
		{
			if (!`layout -q -en ($wName + "Pane")`)
			{
				layout -e -en true ($wName + "Pane");
				intField -e -en true ($wName + "Loop");
				$animRange = GetCurrentAnimRange($wName);
				SetEditorCurrent($wName, $animRange);
			}
		}
	}

	UpdatePlaybackButton($wName);

	return $ret;
}

/******************************************************************************
	playback exit
******************************************************************************/
global proc nw4cSetAnimRange_PlaybackExit(string $wName)
{
	string $cnd[] = `scriptJob -lc`;
	if (IsStringInArray(($wName + "PlaybackCondition"), $cnd))
	{
		condition -del ($wName + "PlaybackCondition");
	}
}

/******************************************************************************
	compare float range
******************************************************************************/
global proc int nw4cSetAnimRange_CompareFloatRange(string $str1, string $str2)
{
	string $tokBuf1[], $tokBuf2[];
	tokenize $str1 "," $tokBuf1;
	tokenize $str2 "," $tokBuf2;
	float $t1 = (float)$tokBuf1[0];
	float $t2 = (float)$tokBuf2[0];
	if ($t1 < $t2)
	{
		return -1;
	}
	if ($t1 > $t2)
	{
		return 1;
	}
	$t1 = (float)$tokBuf1[1];
	$t2 = (float)$tokBuf2[1];
	if ($t1 < $t2)
	{
		return -1;
	}
	if ($t1 > $t2)
	{
		return 1;
	}
	return 0;
}

/******************************************************************************
	substring title
******************************************************************************/
proc string SubstringTitle(string $str)
{
	string $retStr = "";
	int $sz = size($str);
	if ($sz >= 10)
	{
		string $ex = `match "^[^,]+,[^,]+,[^,]+,[^,]+,[^,]+," $str`;
		int $len = size($ex);
		if ($sz > $len)
		{
			$retStr = substring($str, $len + 1, size($str));
		}
	}
	return $retStr;
}

/******************************************************************************
	compare name
******************************************************************************/
global proc int nw4cSetAnimRange_CompareName(string $str1, string $str2)
{
	string $tokBuf1[], $tokBuf2[];
	tokenize($str1, ",", $tokBuf1);
	$tokBuf1[5] = SubstringTitle($str1);
	tokenize($str2, ",", $tokBuf2);
	$tokBuf2[5] = SubstringTitle($str2);
	float $s1 = (float)$tokBuf1[2];
	float $s2 = (float)$tokBuf2[2];
	float $e1 = (float)$tokBuf1[3];
	float $e2 = (float)$tokBuf2[3];
	if ($s1 != $e1 && $s2 == $e2)
	{
		return -1;
	}
	if ($s1 == $e1 && $s2 != $e2)
	{
		return 1;
	}
	return `strcmp $tokBuf1[5] $tokBuf2[5]`;
}

/******************************************************************************
	compare time range
******************************************************************************/
global proc int nw4cSetAnimRange_CompareTimeRange(string $str1, string $str2)
{
	// 0 no
	// 1 enable
	// 2 start
	// 3 end
	// 4 loop
	// 5 name
	string $tokBuf1[], $tokBuf2[];
	int $n;
	$n = tokenize($str1, ",", $tokBuf1);
	if ($n < 4)
	{
		return 0;
	}
	$n = tokenize($str2, ",", $tokBuf2);
	if ($n < 4)
	{
		return 0;
	}
	float $s1 = (float)$tokBuf1[2];
	float $s2 = (float)$tokBuf2[2];
	float $e1 = (float)$tokBuf1[3];
	float $e2 = (float)$tokBuf2[3];
	if ($s1 != $e1 && $s2 == $e2)
	{
		return -1;
	}
	if ($s1 == $e1 && $s2 != $e2)
	{
		return 1;
	}
	if ($s1 < $s2)
	{
		return -1;
	}
	if ($s1 > $s2)
	{
		return 1;
	}
	if ($e1 < $e2)
	{
		return -1;
	}
	if ($e1 > $e2)
	{
		return 1;
	}
	return nw4cSetAnimRange_CompareName($str1, $str2);
}

/******************************************************************************
	make animation range data string array
******************************************************************************/
proc string[] MakeAnimRangeDataStringArray(string $animRange)
{
	int $i;
	int $no = GetNumberOfClip();
	float $f[];
	string $array[];
	for ($i = 0; $i < $no; ++$i)
	{
		$array[$i] = (string)($i + 1);
		$array[$i] = $array[$i] + "," + (string)`getAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]")`;
		$f = GetTimeRangeFromKey($animRange, $i);
		$array[$i] = $array[$i] + "," + ((string)$f[0] + "," + (string)$f[1]);
		$array[$i] = $array[$i] + "," + (string)`getAttr ($animRange + "." + "nw4c_AnimRangeLoop" + "[" + $i + "]")`;
		$array[$i] = $array[$i] + "," + `getAttr ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]")`;
	}
	return $array;
}

/******************************************************************************
	set animation range data from string array
******************************************************************************/
proc SetAnimRangeDataFromStringArray(string $wName, string $animRange, string $array[])
{
	int $i, $n, $enable;
	int $no = GetNumberOfClip();
	string $tokBuf[];
	float $s, $e;
	for ($i = 0; $i < $no; ++$i)
	{
		EnableKeyChangeScript($wName, $animRange, $i, false);
			$n = tokenize($array[$i], ",", $tokBuf);
			$enable = (int)$tokBuf[1];
			setAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]") $enable;
			cutKey -cl -at ("nw4c_AnimRange" + $i) $animRange;
			setAttr -c ($animRange + "." + "nw4c_AnimRange" + $i) 0;
			setAttr ($animRange + "." + "nw4c_AnimRangeLoop" + "[" + $i + "]") ((int)$tokBuf[4]);

			$tokBuf[5] = SubstringTitle($array[$i]);
			setAttr -typ "string" ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]") $tokBuf[5];

			$s = (float)$tokBuf[2];
			$e = (float)$tokBuf[3];
			//if ($s != $e)
			if ($s != $e || $s != 0 || $enable) // if allow s = e // changed from original (2006/04/07)
			{
				SetTimeRangeToKey($wName, $animRange, $i, $s, $e);
			}
		EnableKeyChangeScript($wName, $animRange, $i, true);
	}
}

/******************************************************************************
	sort pack
******************************************************************************/
global proc nw4cSetAnimRange_SortPack(string $wName, string $mode)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange != "")
	{
		string $array[] = MakeAnimRangeDataStringArray($animRange);
		if ($mode == "t")
		{
			$array = QsortStringArray($array, "nw4cSetAnimRange_CompareTimeRange");
		}
		else
		{
			$array = QsortStringArray($array, "nw4cSetAnimRange_CompareName");
		}
		SetAnimRangeDataFromStringArray($wName, $animRange, $array);
		SetEditorCurrent($wName, $animRange);
	}
}

/******************************************************************************
	set unique animation range name
******************************************************************************/
// added (2006/01/23)
proc SetUniqueAnimRangeName(string $animRange, int $idst)
{
	int $no = GetNumberOfClip();
	string $base = `getAttr ($animRange + "." + "nw4c_AnimRangeName" + "[" + $idst + "]")`;
	string $name = $base;
	int $id = 1;

	while (1)
	{
		int $found = false;
		int $i;
		for ($i = 0; $i < $no; ++$i)
		{
			if ($i != $idst)
			{
				string $other = `getAttr ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]")`;
				if ($other == $name)
				{
					$found = true;
					break;
				}
			}
		}
		if ($found)
		{
			$name = $base + "_" + $id;
			++$id;
		}
		else
		{
			break;
		}
	}

	if ($id > 1)
	{
		setAttr -typ "string" ($animRange + "." + "nw4c_AnimRangeName" + "[" + $idst + "]")
			$name;
		//trace ("unique: " + $base + " -> " + $name);
	}
}

/******************************************************************************
	drag animation range
******************************************************************************/
global proc string[] nw4cSetAnimRange_DragAnimRange(string $wName,
	string $dragControl, int $x, int $y, int $mods)
{
	string $msgs[];
	if (!`window -ex $wName`)
	{
		return $msgs;
	}
	if ($mods != 0 && $mods != 2)
	{
		return $msgs;
	}
	string $i = match("[0-9]+$", $dragControl);
	if ($i != "")
	{
		$msgs[0] = $wName + "Clip";
		if ($mods == 0)
		{
			$msgs[1] = "Move";
		}
		else if ($mods == 2)		// ctrl
		{
			$msgs[1] = "Copy";
		}
		$msgs[2] = $i;
	}
	return $msgs;
}

/******************************************************************************
	drop animation range

		$msgs[0]	$wName + "Clip"
		$msgs[1]	"Move" or "Copy"
		$msgs[2]	clip index of drag item (source)
******************************************************************************/
global proc nw4cSetAnimRange_DropAnimRange(string $wName,
	string $dragControl, string $dropControl, string $msgs[],
	int $x, int $y, int $type)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	//if ($type != 2)
	//	return;

	if ($msgs[0] == $wName + "Clip")
	{
		string $i = match("[0-9]+$", $dropControl);
		if ($i != "" && $msgs[2] != "" && $i != $msgs[2])
		{
			int $s = (int)$msgs[2];
			int $d = (int)$i;
			string $animRange = GetCurrentAnimRange($wName);
			if ($animRange != "")
			{
				string $array[] = MakeAnimRangeDataStringArray($animRange);
				string $result[];
				int $j, $k = 0;
				int $no = GetNumberOfClip();
				if ($msgs[1] == "Move")
				{
					for ($j = 0; $j < $no; ++$j)
					{
						if ($j == $s)
						{
							continue;
						}
						if ($s < $d)
						{
							$result[$k++] = $array[$j];
						}
						if ($j == $d)
						{
							$result[$k++] = $array[$s];
						}
						if ($s > $d)
						{
							$result[$k++] = $array[$j];
						}
					}
				}
				else if ($msgs[1] == "Copy")
				{
					for ($j = 0; $j < $no; ++$j)
					{
						if ($j == $d)
						{
							$result[$k++] = $array[$s];
						}
						else
						{
							$result[$k++] = $array[$j];
						}
					}
				}
				SetAnimRangeDataFromStringArray($wName, $animRange, $result);
				// changed from original (2006/01/23)
				if ($msgs[1] == "Copy")
				{
					SetUniqueAnimRangeName($animRange, $d);
				}
				SetEditorCurrent($wName, $animRange);
			}
		}
	}
}

/******************************************************************************
	import animation range proc (called from animation range file)

		$orgAnimRange is not used
******************************************************************************/
global proc nw4cSetAnimRange_ImportAnimRangeProc(string $wName,
	string $exprotVer, string $orgAnimRange, string $list[])
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}
	if ($exprotVer != "1.00")								// check version
	{
		return;
	}
	string $array[], $titles[], $tokBuf[];
	string $str;
	float $s, $e;
	int $no = GetNumberOfClip();
	int $i;
	for ($str in $list)
	{
		clear($tokBuf);
		if (tokenize($str, ", \r\n\t", $tokBuf) < 6)
		{
			continue;
		}
		$i = $tokBuf[0];
		if ($i <= 0 || $i > $no)
		{
			continue;
		}
		$i--;

		$s = (float)$tokBuf[2];
		$e = (float)$tokBuf[3];
		if ($s > $e)									// check range
		{
			continue;
		}
		if (match("[^0-9a-zA-Z_]", $tokBuf[5]) != "")	// check title
		{
			continue;
		}
		$array[$i] = $tokBuf[0] + "," + $tokBuf[1] + "," + $tokBuf[2] + "," + $tokBuf[3] + "," + $tokBuf[4] + "," + $tokBuf[5];
		$titles[$i] = $tokBuf[5];
	}

	int $ret = false;
	if (size($array) == $no)		// check number of channels
	{
		for ($i = 0; $i < $no; ++$i)
		{
			if ($array[$i] == "")	// check title
			{
				break;
			}
		}
		if ($i == $no)				// check number of channels
		{
// enabled import animation range channel -> disabled current animation range channel
//			string $currentArray[] = MakeAnimRangeDataStringArray($animRange);
//			string $currentTitles[];
//			int $j = 0;
//			for ($i = 0; $i < $no; ++$i)
//			{
//				clear $tokBuf;
//				tokenize $currentArray[$i] ", \r\n\t" $tokBuf;
//				$currentTitles[$i] = $tokBuf[5];
//				if ($tokBuf[1] == "1")	// enable
//					continue;
//
//				clear $tokBuf;
//				tokenize $array[$j] ", \r\n\t" $tokBuf;
//				if ($tokBuf[1] == "1")	// enable
//				{
//					$currentArray[$i] = $array[$j];
//					$currentTitles[$i] = $tokBuf[5];
//					$j++;
//				}
//			}
//			$currentTitles = stringArrayRemoveDuplicates($currentTitles);	// check title
//			if (size($currentTitles) == $no)
//			{
//				SetAnimRangeDataFromStringArray($wName, $animRange, $currentArray);
//				SetEditorCurrent($wName, $animRange);
//
//				for (; $j<$no; $j++)
//				{
//					clear $tokBuf;
//					tokenize $array[$j] ", \r\n\t" $tokBuf;
//					if ($tokBuf[1] == "1")	// enable
//					{
//						warning ("Remain channels in import file. <" + $wName + ">");
//						break;
//					}
//				}
//
//				$ret = true;
//			}
//			else
//				DoError ("Found same title as current nw4c_AnimRangeCtrl in import file. <" + $wName + ">");
// overwrite all
//			$titles = stringArrayRemoveDuplicates($titles);	// check title
//			if (size($titles) == $no)
//			{
//				SetAnimRangeDataFromStringArray($wName, $animRange, $array);
//				SetEditorCurrent($wName, $animRange);
//				$ret = true;
//			}
// overwrite title or title and range
			$titles = stringArrayRemoveDuplicates($titles);	// check title
			if (size($titles) == $no)
			{
				string $opt = `confirmDialog -t "Import Option"
					-m "Select Import Type." -p $wName
					-b "All" -b "Title and Range" -b "Only Title" -b "Cancel"
					-db "All" -cb "Cancel" -ds "Cancel"`;
				if ($opt != "Cancel")
				{
					string $currentArray[] = MakeAnimRangeDataStringArray($animRange);
					string $tokBufTemp[];
					for ($i = 0; $i < $no; ++$i)
					{
						clear($tokBuf);
						tokenize($currentArray[$i], ", \r\n\t", $tokBuf);
	
						clear($tokBufTemp);
						tokenize($array[$i], ", \r\n\t", $tokBufTemp);

						$tokBuf[5] = $tokBufTemp[5]; // title
						if ($opt != "Only Title")
						{
							$tokBuf[2] = $tokBufTemp[2]; // start
							$tokBuf[3] = $tokBufTemp[3]; // end
						}
						if ($opt == "All")
						{
							$tokBuf[1] = $tokBufTemp[1]; // enable
							$tokBuf[4] = $tokBufTemp[4]; // loop
						}
						$currentArray[$i] = $tokBuf[0] + "," + $tokBuf[1] + "," + $tokBuf[2] + "," + $tokBuf[3] + "," + $tokBuf[4] + "," + $tokBuf[5];
					}
					SetAnimRangeDataFromStringArray($wName, $animRange, $currentArray);
					SetEditorCurrent($wName, $animRange);
				}
				$ret = true;
			}
		}
	}
	if (!$ret)
	{
		DoError("Invalid import file. <" + $wName + ">");
	}
}

/******************************************************************************
	import animation range CB
******************************************************************************/
global proc int nw4cSetAnimRange_ImportAnimRangeCB(string $wName,
	string $fileName, string $fileType)
{
	//string $abRet[];
	//catch($abRet = nw4c_ABGetLatest("", { $fileName }));

	int $fh = fopen($fileName, "r");
	if ($fh == 0)
	{
		return false;
	}
	string $str = fgetline($fh);
	$str = match("^nw4cSetAnimRange_ImportAnimRangeProc", $str);
	fclose($fh);

	if ($str == "")
	{
		DoError("Not exported file. <" + $wName + ">");
		return false;
	}

	eval("source \"" + $fileName + "\"");

	// save last accessed folder
	optionVar -sv nw4cSetAnimRange_AnimRangeFileFolder `dirname $fileName`;

	return true;
}

/******************************************************************************
	write file export animation range
******************************************************************************/
proc int WriteFileExportAnimRange(string $wName, string $animRange, string $fileName)
{
	int $fh = fopen($fileName, "w");
	if ($fh == 0)
	{
		return false;
	}
	string $str = "nw4cSetAnimRange_ImportAnimRangeProc(\r\n\t\"" + $wName +
		"\",\r\n\t\"1.00\",\r\n\t\"" + $animRange + "\",\r\n";
	fprint($fh, $str);
	string $list[] = MakeAnimRangeDataStringArray($animRange);
	$str = "\t{\r\n";
	int $i;
	for ($i = 0; $i < size($list); ++$i)
	{
		$str += ("\t\t\"" + $list[$i] + "\"");
		if ($i < (size($list) - 1))
		{
			$str += ",";
		}
		$str += "\r\n";
	}
	$str += "\t}\r\n";
	$str += ");\r\n";
	fprint($fh, $str);
	fclose($fh);
	return true;
}

/******************************************************************************
	export animation range CB
******************************************************************************/
global proc int nw4cSetAnimRange_ExportAnimRangeCB(string $wName,
	string $fileName, string $fileType)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return false;
	}

	//string $abRet[];
	//int $abCheckout = false;
	//if (!catch($abRet = nw4c_ABCheckOut("", { $fileName })))
	//	$abCheckout = $abRet[0];

	int $ret = WriteFileExportAnimRange($wName, $animRange, $fileName);

	//if ($abCheckout)
	//	catch($abRet = nw4c_ABCheckIn("", { $fileName }));

	// save last accessed folder
	optionVar -sv nw4cSetAnimRange_AnimRangeFileFolder `dirname $fileName`;

	return $ret;
}

/******************************************************************************
	get animation range win dir
******************************************************************************/
proc string GetAnimRangeFileFolder(string $wName, int $md)
{
	string $path;
	if (`optionVar -ex nw4cSetAnimRange_AnimRangeFileFolder`)
	{
		$path = `optionVar -q nw4cSetAnimRange_AnimRangeFileFolder`;
		if (`filetest -d $path`)
		{
			return $path;
		}
	}
	$path = `workspace -q -rd`;
	if (`filetest -d $path`)
	{
		return $path;
	}
	return "";
}

/******************************************************************************
	import animation range
******************************************************************************/
global proc nw4cSetAnimRange_ImportAnimRange(string $wName)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}
	string $path = GetAnimRangeFileFolder($wName, true);
	if ($path == "")
	{
		return;
	}
	string $old = `workspace -q -dir`;
	workspace -dir $path;
	fileBrowserDialog -m 0 -fc ("nw4cSetAnimRange_ImportAnimRangeCB " + $wName)
		-an "Import" -ft "mel";
	workspace -dir $old;

	// title bar doesn't become active (Maya bugfix)
	catch(setFocus(`getPanel -wf`));
	showWindow $wName;
}

/******************************************************************************
	export animation range
******************************************************************************/
global proc nw4cSetAnimRange_ExportAnimRange(string $wName)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}
	string $path = GetAnimRangeFileFolder($wName, true);
	if ($path == "")
	{
		return;
	}
	string $old = `workspace -q -dir`;
	workspace -dir $path;
	fileBrowserDialog -m 1 -fc ("nw4cSetAnimRange_ExportAnimRangeCB " + $wName)
		-an "Export" -ft "mel";
	workspace -dir $old;

	// title bar doesn't become active (Maya bugfix)
	catch(setFocus(`getPanel -wf`));
	showWindow $wName;
}

/******************************************************************************
	call editor (Graph Editor / Dope Sheet)
******************************************************************************/
global proc nw4cSetAnimRange_CallEditor(string $wName, string $cmd)
{
	string $node;
	$node = GetCurrentDag($wName);
	if ($node == "")
	{
		$node = GetCurrentAnimRange($wName);
	}
	if ($node != "")
	{
		select -r $node;
	}
	eval($cmd);
}

/******************************************************************************
	editor menu CB
******************************************************************************/
global proc nw4cSetAnimRange_OnMenuEditor(string $wName, int $i)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	menuItem -e -en `checkBox -q -v ($wName + "ClipEnable" + $i)` ($wName + "EditorMenu" + $i + "Item1"); // animation range from selected range
	menuItem -e -en `checkBox -q -v ($wName + "ClipEnable" + $i)` ($wName + "EditorMenu" + $i + "Item2"); // animation range from playback range
	menuItem -e -en `checkBox -q -v ($wName + "ClipEnable" + $i)` ($wName + "EditorMenu" + $i + "Item3"); // animation range from scene range
	menuItem -e -en `checkBox -q -v ($wName + "ClipEnable" + $i)` ($wName + "EditorMenu" + $i + "Item4"); // playback from selected animation range
	menuItem -e -en `checkBox -q -v ($wName + "ClipEnable" + $i)` ($wName + "EditorMenu" + $i + "Item5"); // select animation range anim curve
	menuItem -e -en `checkBox -q -v ($wName + "ClipEnable" + $i)` ($wName + "EditorMenu" + $i + "Item6"); // select animation range hierarchy anim curve
	menuItem -e -en `checkBox -q -v ($wName + "ClipEnable" + $i)` ($wName + "EditorMenu" + $i + "Item9"); // delete selected animation range

	int $en;
	if ($i)
	{
		$en = true;
	}
	else
	{
		$en = false;
	}
	menuItem -e -en $en ($wName + "EditorMenu" + $i + "Item7"); // move up

	if ($i < (GetNumberOfClip() - 1))
	{
		$en = true;
	}
	else
	{
		$en = false;
	}
	menuItem -e -en $en ($wName + "EditorMenu" + $i + "Item8"); // move down

	$en = false;
	if (`checkBox -q -v ($wName + "ClipEnable" + $i)`)
	{
		if (GetCurrentDag($wName) != "")
		{
			$en = true;
		}
	}
	menuItem -e -en $en ($wName + "EditorMenu" + $i + "Item10"); // add key to hierarchy from selected animation range

	$en = false;
	if (GetCurrentDag($wName) != "")
	{
		$en = true;
	}
	menuItem -e -en $en ($wName + "EditorMenu" + $i + "Item11"); // add key to hierarchy from enable animation range
}

/******************************************************************************
	get time range
******************************************************************************/
global proc nw4cSetAnimRange_GetTimeRange(string $wName, int $i, string $mode)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	float $s, $e;
	if ($mode == "s")			// playback from selected animation range
	{
		nw4cSetAnimRange_OnKeyChangeUI($wName, $i, "s");
		$s = `floatField -q -v ($wName + "ClipStart" + $i)`;
		$e = `floatField -q -v ($wName + "ClipEnd" + $i)`;
		// changed from original (2006/03/07)
		// set start frame later to avoid adjusting start frame when (s = e)
		playbackOptions -max `FloatToInt $e`;
		playbackOptions -min `FloatToInt $s`;
	}
	else if ($mode == "m")		// playback from enable animation range
	{
		string $animRange = GetCurrentAnimRange($wName);
		if ($animRange != "")
		{
			float $sf[], $ef[];
			GetEnabledTimeRangeArray($animRange, $sf, $ef);
			if (size($sf))
			{
				// changed from original (2006/03/07)
				// set start frame later to avoid adjusting start frame when (s = e)
				playbackOptions -max `FloatToInt ($ef[size($ef) - 1])`;
				playbackOptions -min `FloatToInt $sf[0]`;
			}
		}
	}
	else
	{
		if ($mode == "t")		// animation range from selected range
		{
			string $list[] = `lsUI -ctl`;
			string $item;
			for ($item in $list)
			{
				if (`objectType $item` == "timeControl")
				{
					string $rng = `timeControl -q -rng $item`;
					string $tokBuf[];
					tokenize($rng, "\"", $tokBuf);
					tokenize($tokBuf[0], ":", $tokBuf);
					$s = (float)$tokBuf[0];
					$e = (float)$tokBuf[1];
					break;
				}
			}
		}
		else if ($mode == "p")	// animation range from playback range
		{
			$s = `playbackOptions -q -min`;
			$e = `playbackOptions -q -max`;
		}
		else if ($mode == "a")	// animation range from scene range
		{
			$s = `playbackOptions -q -ast`;
			$e = `playbackOptions -q -aet`;
		}
		DisplayTimeRange($wName, $i, $s, $e);
		nw4cSetAnimRange_OnKeyChangeUI($wName, $i, "s");
	}
}

/******************************************************************************
	select time range key
******************************************************************************/
global proc nw4cSetAnimRange_SelectTimeRangeKey(string $wName, int $i)
{
	string $node;
	$node = GetCurrentDag($wName);
	if ($node == "")
	{
		$node = GetCurrentAnimRange($wName);
	}
	if ($node != "")
	{
		select -r $node;
	}

	$node = GetCurrentAnimRange($wName);
	if ($node != "")
	{
		selectKey -add -k ($node + "." + "nw4c_AnimRange" + $i);
	}
}

/******************************************************************************
	AE expand names
******************************************************************************/
// in others/showEditor.mel
proc string[] AEexpandNames(string $array[])
{
	string	$retval[];
	string	$buffer[];
	for ($i = 0; $i < size($array); ++$i)
	{
		$buffer = `ls -l $array[$i]`;
		for ($j = 0; $j < size($buffer); ++$j)
		{
			$retval[size($retval)] = $buffer[$j];
		}
		clear($buffer);
	}
	return $retval;
}

/******************************************************************************
	AE filter unwanted nodes
******************************************************************************/
// in others/showEditor.mel
proc string[] AEfilterUnwantedNodes(string $array[])
{   
	string  $retVal[];
	string  $nodeType;
	int $count, $i, $j = 0;
	
	$count = size($array);
	for ($i = 0; $i < $count; ++$i)
	{   
		$nodeType = `nodeType $array[$i]`;
		// Remove Referenced Fur Globals from a list
		int $refFurGlobal = `reference -q -inr $array[$i]`;
		if (!($nodeType == "renderGlobals" ||
			  ($nodeType == "FurGlobals" && $refFurGlobal)))
		{   
			$retVal[$j] = $array[$i];
			++$j;
		}
	}
	
	return $retVal;
}

/******************************************************************************
	AE get related nodes
******************************************************************************/
// in others/showEditor.mel
proc string[] AEgetRelatedNodes(string $node)
{
	string	$rNodes[], $retval[], $tmpNodes[];
	string	$nodeNameType = `nodeType $node`;
	string	$relatedScript = ("AE"+$nodeNameType+"Related");
	
	if (`exists $relatedScript`)
	{
		$tmpNodes = `eval($relatedScript + " \"" + $node + "\"")`;
		$rNodes = AEexpandNames($tmpNodes);
	}
	else
	{
		string $focusNode[];
		$tmpNodes = `defaultNavigation -ren -d $node`;
		$tmpNodes = AEfilterUnwantedNodes($tmpNodes);
		$rNodes = AEexpandNames($tmpNodes);
		$focusNode[0] = `defaultNavigation -dwn -d $node`;
		clear($tmpNodes);
		$tmpNodes = AEexpandNames($focusNode);
		$rNodes[size($rNodes)] = $tmpNodes[0];
	}
	// the first item in the return string array is the node itself
	//
	clear($tmpNodes);
	$tmpNodes[0] = $node;
	$retval = AEexpandNames($tmpNodes);

	// need to go through the string array and remove unwanted
	// duplicates
	//
	for ($i = 0; $i < size($rNodes)-1; ++$i)
	{
		$duplicated = false;
		for ($j = 0; $j < size($retval); ++$j)
		{
			if ($rNodes[$i] == $retval[$j])
			{
				$duplicated = true;
				break;
			}
		}
		if (!$duplicated)
		{
			$retval[size($retval)] = $rNodes[$i];
		}
	}

	// now search for the last item in the $retval for a duplicate
	//
	string $lastNode = $rNodes[size($rNodes)-1];
	$duplicated = false;
	for ($i = 0; $i < size($retval); ++$i)
	{
		if ($lastNode == $retval[$i])
		{
			$duplicated = true;
			break;
		}
	}

	if (!$duplicated)
	{
		$retval[size($retval)] = $node;
	}
	else
	{
		$retval[size($retval)] = $lastNode;
	}

	return $retval;
}

/******************************************************************************
	fix AE get related nodes
******************************************************************************/
proc string[] FixAEgetRelatedNodes(string $node)
{
	string $list[] = AEgetRelatedNodes($node);

	// shader search (Maya bugfix)
	string $shape[] = `ls -s $list`;
	string $workList[], $tmp[];
	string $work, $item;
	for ($work in $shape)
	{
		$workList = `listConnections -t "shadingEngine" $work`;
		$workList = stringArrayRemoveDuplicates($workList);
		for ($item in $workList)
		{
			$tmp = `listConnections ($item + ".surfaceShader")`;
			if (size($tmp))
			{
				if (!IsStringInArray($tmp[0], $list))
				{
					$list[size($list)] = $tmp[0];
				}
			}
		}
	}
	return $list;
}

/******************************************************************************
	ls material
******************************************************************************/
proc string[] LsMaterial(string $list[])
{
	string $tmpList[];
	if (size($list))
	{
		$tmpList = `ls -mat $list`;
	}
	string $workList[], $retList[];
	string $temp, $work;
	for ($temp in $tmpList)
	{
		$work = `nodeType $temp`;
		$workList = `getClassification $work`;
		if (match("^shader/surface", $workList[0]) != "")
		{
			$retList[size($retList)] = $temp;
		}
	}
	return $retList;
}

/******************************************************************************
	get selected key time list
******************************************************************************/
proc string[] GetSelectedKeyTimeList()
{
	string $sel[] = `keyframe -q -sl -n`;
	string $org[];
	float $key[];
	int $i, $j;
	// make list (attr_name, time[0], time[1], time[2], ...)
	for ($i = 0; $i < size($sel); ++$i)
	{
		$org[$i] = $sel[$i];
		$key = `keyframe -q -sl $org[$i]`;
		for ($j = 0; $j < size($key); ++$j)
		{
			$org[$i] = $org[$i] + "," + $key[$j];
		}
	}
	return $org;
}

/******************************************************************************
	select key time list
******************************************************************************/
proc SelectKeyTimeList(string $list[])
{
	int $i, $j;
	string $tokBuf[];
	if (`keyframe -q -kc`)
	{
		selectKey -cl;
	}
	string $arg;
	for ($i = 0; $i < size($list); ++$i)
	{
		clear($tokBuf);
		tokenize($list[$i], ",", $tokBuf);
		$arg = "";
		for ($j = 1; $j < size($tokBuf); ++$j)
		{
			$arg += (" -t " + ((float)$tokBuf[$j]));
		}
		if ($arg != "")
		{
			eval("selectKey -add -k" + $arg + " " + $tokBuf[0]);
		}
	}
}

/******************************************************************************
	search connect key attr
******************************************************************************/
proc string SearchConnectKeyAttr(string $src)
{
	string $node[] = `listConnections -p false ($src + ".output")`;
	if (!size($node))
	{
		return "";
	}
	string $plug[] = `listConnections -p true ($src + ".output")`;

	if (`nodeType $node[0]` == "mute" && ($node[0] + ".input") == $plug[0])
	{
		return SearchConnectKeyAttr($node[0]);
	}
	else
	{
		return $plug[0];
	}
}

/******************************************************************************
	is driven anim
******************************************************************************/
proc int IsDrivenAnim(string $anim)
{
	string $plug = SearchConnectKeyAttr($anim);
	if ($plug != "")
	{
		string $drv[] = `setDrivenKeyframe -q -dr $plug`;
		if (size($drv))
		{
			if ($drv[0] != "No drivers.")
			{
				return true;
			}
		}
	}
	return false;
}

/******************************************************************************
	select hierarchy time range
******************************************************************************/
global proc nw4cSetAnimRange_SelectHierarchyTimeRange(string $wName, int $i)
{
	if ((`getModifiers` % 2) != 1)	// != shift
	{
		if (`keyframe -q -kc`)
		{
			selectKey -cl;
		}
	}

	string $node = GetCurrentDag($wName);						// top dag
	if ($node == "")
	{
		return;
	}
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}
	nw4cSetAnimRange_OnKeyChangeUI($wName, $i, "s");
	float $s = `floatField -q -v ($wName + "ClipStart" + $i)`;
	float $e = `floatField -q -v ($wName + "ClipEnd"   + $i)`;
	if ($s >= $e)
	{
		return;
	}

	// if loop, select key at (endFrame + 1)
	// changed from original (2006/01/23)
	//if (`checkBox -q -v ($wName + "ClipLoop" + $i)`)	
	//{
	//	++$e;
	//}

	waitCursor -state on;
	string $selKey[] = GetSelectedKeyTimeList();
	string $sel[] = `ls -sl`;

	select -r $node;
	select -hi;
	string $list[] = `ls -sl`;
	string $item;
	string $tree[];												// related node list
	string $workList[];
	for ($item in $list)
	{
		$workList = FixAEgetRelatedNodes($item);
		if (size($workList))
		{
			$tree = stringArrayCatenate($tree, $workList);
		}
	}
	$tree = stringArrayRemoveDuplicates($tree);
	$tree = `ls $tree`;											// full path -> fine path
	$workList = GetAnimRangeList();
	$tree = stringArrayRemove($workList, $tree);				// exclude animation range node
	$tree[size($tree)] = $animRange + ".nw4c_AnimRange" + $i;				// add specified animation range

	// for custom effect of material
	$workList = LsMaterial($tree);
	if (size($workList))
	{
		$workList = `listHistory $workList`;
		if (size($workList))
		{
			$workList = stringArrayRemoveDuplicates($workList);
			$tree = stringArrayCatenate($tree, $workList);
			$tree = stringArrayRemoveDuplicates($tree);
		}
	}

	// add select
	select -r $sel;
	SelectKeyTimeList($selKey);
	for ($item in $tree)
	{
		$workList = `keyframe -q -n $item`;
		for ($item in $workList)									// anim curve node list
		{
			if (!IsDrivenAnim($item))
			{
				selectKey -add -k -t ($s + ":" + $e) $item;
			}
		}
	}

	// for dope sheet
	setToolTo scaleSuperContext;
	waitCursor -state off;
}

/******************************************************************************
	delete time range
******************************************************************************/
global proc nw4cSetAnimRange_DeleteTimeRange(string $wName, int $i, string $mode)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange != "")
	{
		int $s, $e;
		if ($mode == "s")	// selected animation range
		{
			if (!ConfirmDialogCheckWin($wName, "Delete nw4c_AnimRange" + $i + ".\n"))
			{
				return;
			}
			$s = $i;
			$e = $s + 1;
		}
		else				// disabled animation range
		{
			if (!ConfirmDialogCheckWin($wName, "Delete Disabled AnimRanges.\n"))
			{
				return;
			}
			$s = 0;
			$e = GetNumberOfClip();
		}

		for ($i = $s; $i < $e; ++$i)
		{
			if ($mode == "m")
			{
				if (`getAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]")`)
				{
					continue;
				}
			}
			EnableKeyChangeScript($wName, $animRange, $i, false);
				cutKey -cl -at ("nw4c_AnimRange" + $i) $animRange;
				setAttr -c ($animRange + "." + "nw4c_AnimRange" + $i) 0;

				$f = GetTimeRangeFromKey($animRange, $i);
				DisplayTimeRange($wName, $i, $f[0], $f[1]);

				setAttr ($animRange + "." + "nw4c_AnimRangeLoop" + "[" + $i + "]") false;
				setAttr -typ "string" ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]")
					`GetUniqueAnimRangeTitle $animRange $i`;
			EnableKeyChangeScript($wName, $animRange, $i, true);

			setAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]") false;
		}
	}
}

/******************************************************************************
	move time range (up / down) (using drag & drop proc)
******************************************************************************/
global proc nw4cSetAnimRange_MoveTimeRange(string $wName, int $i, string $mode)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange != "")
	{
		int $s = $i;
		int $d = $i;
		if ($mode == "u")
		{
			if ($i)
			{
				$d--;
			}
		}
		else
		{
			if ($i < (GetNumberOfClip() - 1))
			{
				$s++;
			}
		}
		if ($s != $d)
		{
			string $dragControl = ($wName + "ClipNo" + $s);
			string $dropControl = ($wName + "ClipNo" + $d);
			string $msgs[] = nw4cSetAnimRange_DragAnimRange($wName, $dragControl, 0, 0, 0);
			nw4cSetAnimRange_DropAnimRange($wName, $dragControl, $dropControl, $msgs, 0, 0, 2);
		}
	}
}

/******************************************************************************
	enable all
******************************************************************************/
global proc nw4cSetAnimRange_EnableAll(string $wName, string $mode)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange != "")
	{
		int $i;
		int $no = GetNumberOfClip();
		int $en = false;
		if ($mode == "e")
		{
			$en = true;
		}
		for ($i = 0; $i < $no; ++$i)
		{
			setAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]") $en;
		}
	}
}

/******************************************************************************
	check animation range title (if empty or same as other, restore)
******************************************************************************/
global proc nw4cSetAnimRange_CheckAnimRangeTitle(string $wName, int $i)
{
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange != "")
	{
		string $item = `getAttr ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]")`;
		//$item = `strip $item`;
		//setAttr -typ "string" ($animRange + "." + "nw4c_AnimRangeName" + "[" + $i + "]") $item;
		if ($item == ""
			|| match("[^0-9a-zA-Z_]", $item) != "")
		{
			RestoreTitleList($wName, $animRange, $i);
			warning (("nw4c_AnimRange" + $i) + ":Invalid name was specified. <" + $wName + ">.");
			return;
		}

		int $idx;
		int $no = GetNumberOfClip();
		string $list[] = GetAttrTitleList($animRange);
		for ($idx = 0; $idx < $no; ++$idx)
		{
			if ($idx == $i)
			{
				continue;
			}
			if ($item == $list[$idx])
			{
				break;
			}
		}
		if ($idx < $no)		// same name
		{
			RestoreTitleList($wName, $animRange, $i);
			warning (("nw4c_AnimRange" + $i) + ":Duplicate name was specified. <" + $wName + ">.");
			return;
		}

		SaveTitleList($wName, $animRange);
	}
}

/******************************************************************************
	set animation range range key
******************************************************************************/
global proc nw4cSetAnimRange_SetAnimRangeRangeKey(string $wName, int $i)
{
	string $node = GetCurrentDag($wName);						// top dag
	if ($node == "")
	{
		return;
	}
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}
	nw4cSetAnimRange_OnKeyChangeUI($wName, $i, "s");
	float $s = `floatField -q -v ($wName + "ClipStart" + $i)`;
	float $e = `floatField -q -v ($wName + "ClipEnd"   + $i)`;
	if ($s >= $e)
	{
		return;
	}

	// if loop, set key at (endFrame + 1)
	// changed from original (2006/01/23)
	//if (`checkBox -q -v ($wName + "ClipLoop" + $i)`)	
	//{
	//	++$e;
	//}

	waitCursor -state on;

	string $sel[] = `ls -sl`;

	select -r $node;
	select -hi;
	string $list[] = `ls -sl`;
	string $item;
	string $tree[];												// related node list
	string $workList[];
	for ($item in $list)
	{
		$workList = FixAEgetRelatedNodes($item);
		if (size($workList))
		{
			$tree = stringArrayCatenate($tree, $workList);
		}
	}
	$tree = stringArrayRemoveDuplicates($tree);
	$tree = `ls $tree`;											// full path -> fine path
	$workList = GetAnimRangeList();
	$tree = stringArrayRemove($workList, $tree);				// exclude animation range node

	// for custom effect of material
	$workList = LsMaterial($tree);
	if (size($workList))
	{
		$workList = `listHistory $workList`;
		if (size($workList))
		{
			$workList = stringArrayRemoveDuplicates($workList);
			$tree = stringArrayCatenate($tree, $workList);
			$tree = stringArrayRemoveDuplicates($tree);
		}
	}

	// add key
	float $anchor[] = { $s, $e };
	float $times[], $vals[];
	string $itt[], $ott[];
	int $i;
	for ($item in $tree)
	{
		$workList = `keyframe -q -n $item`;
		for ($item in $workList)									// anim curve node list
		{
			if (IsDrivenAnim($item))
			{
				continue;
			}
			for ($i = 0; $i < size($anchor); ++$i)
			{
				$times = `keyframe -q $item`;
				if ($times[0] <= $anchor[$i] && $anchor[$i] <= $times[size($times) - 1])
				{
					catchQuiet(`setKeyframe -i -hi none -t $anchor[$i] $item`);
				}
				else	// out of time-range
				{
					if (`getAttr ($item + ".preInfinity")` || `getAttr ($item + ".postInfinity")`)
					{
						continue;		// != constant
					}

					if ($times[0] > $anchor[$i])
					{
						$itt = `keyTangent -in 0 -q -itt $item`;
						if ($itt[0] == "spline" || $itt[0] == "fixed")
						{
							catchQuiet(`keyTangent -in 0 -e -l false -itt "clamped" $item`);
						}

						$ott = `keyTangent -in 0 -q -ott $item`;
						if ($ott[0] == "step")
						{
							$vals = `keyframe -t $times[0] -q -vc $item`;
							catchQuiet(`setKeyframe -hi none -t $anchor[$i] -v $vals[0] $item`);
							continue;
						}
					}
					else
					{
						$ott = `keyTangent -in (size($times) - 1) -q -ott $item`;
						if ($ott[0] == "spline" || $ott[0] == "fixed")
						{
							catchQuiet(`keyTangent -in (size($times) - 1) -e -l false -ott "clamped" $item`);
						}
					}
					catchQuiet(`setKeyframe -i -hi none -t $anchor[$i] $item`);
				}
			}
		}
	}

	if (size($sel))
	{
		select -r $sel;
	}
	else
	{
		select -cl;
	}
	
	waitCursor -state off;
}

/******************************************************************************
	set enabled animation range range key
******************************************************************************/
global proc nw4cSetAnimRange_SetEnabledAnimRangeRangeKey(string $wName, int $i)
{
	string $node = GetCurrentDag($wName);						// top dag
	if ($node == "")
	{
		return;
	}
	string $animRange = GetCurrentAnimRange($wName);
	if ($animRange == "")
	{
		return;
	}

	int $no = GetNumberOfClip();
	for ($i = 0; $i < $no; ++$i)
	{
		if (`getAttr ($animRange + "." + "nw4c_AnimRangeEnable" + "[" + $i + "]")`)
		{
			nw4cSetAnimRange_SetAnimRangeRangeKey($wName, $i);
		}
	}
}

/******************************************************************************
	update dag list
******************************************************************************/
global proc nw4cSetAnimRange_UpdateDagList(string $wName)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	string $exlist[] = GetDagList();
	string $list[];
	string $work;
	for ($work in $exlist)
	{
		if (!IsAnimRange($work))
		{
			$list[size($list)] = $work;
		}
	}
	string $sel[] = `textScrollList -q -ai ($wName + "DagList")`;
	string $name;
	int $i = 0;

	// same list
	if (size($sel) == size($list) && size($list))
	{
		// speed up
		//$sel = stringArrayRemove($list, $sel);
		//if (!size($sel))
		string $intsct = `stringArrayIntersector -i $list`;
		stringArrayIntersector -e -i $sel $intsct;
		$sel = `stringArrayIntersector -q $intsct`;
		deleteUI $intsct;
		if (size($sel) == size($list))
		{
			$i = 1;
		}
	}
	// change list
	if (!$i)
	{
		// speed up
		textScrollList -e -vis false -m false ($wName + "DagList");
		textScrollList -e -ra ($wName + "DagList");

		if (size($list))
		{
			$name = "";
			for ($work in $list)
			{
				$name += (" -a \"" + $work + "\"");
			}
			if (size($name))
			{
				eval("textScrollList -e " + $name + " " + ($wName + "DagList"));
			}
		}
		// speed up
		textScrollList -e -vis true -m true ($wName + "DagList");
	}

	// select
	$work = GetCurrentDag($wName);
	if ($work != "")
	{
		$sel = `ls $work`;
		$work = $sel[0];
		if (IsStringInArray($work, $list))
		{
			textScrollList -e -si $work ($wName + "DagList");
		}
	}
}

/******************************************************************************
	update animation range list
******************************************************************************/
global proc nw4cSetAnimRange_UpdateAnimRangeList(string $wName, int $updateEditor)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	string $list[] = GetAnimRangeList();
	string $sel[] = `textScrollList -q -ai ($wName + "AnimRangeList")`;
	string $work;
	string $name;
	int $i = 0;

	// same list
	if (size($sel) == size($list) && size($list))
	{
		$sel = stringArrayRemove($list, $sel);
		if (!size($sel))
		{
			$i = 1;
		}
	}
	// change list
	if (!$i)
	{
		textScrollList -e -ra ($wName + "AnimRangeList");

		if (size($list))
		{
			$name = "";
			for ($work in $list)
			{
				$name += (" -a \"" + $work + "\"");
			}
			if (size($name))
			{
				eval("textScrollList -e" + $name + " " + ($wName + "AnimRangeList"));
			}
		}
	}

	// select
	$work = GetCurrentAnimRange($wName);
	if ($work != "")
	{
		$sel = `ls $work`;
		$work = $sel[0];
		if (IsStringInArray($work, $list))
		{
			textScrollList -e -si $work ($wName + "AnimRangeList");
			RelationAnimRangeToDagList($wName, $work);
			// changed from original (2006/01/23)
			if ($updateEditor)
			{
				SetEditorCurrent($wName, $work);
			}
		}
	}
	else
	{
		SetEditorCurrent($wName, "");
	}
}

/******************************************************************************
	update view
******************************************************************************/
global proc nw4cSetAnimRange_UpdateView(string $wName, int $updateEditor)
{
	if (!`window -ex $wName`)
	{
		return;
	}
	checkBox -e -v false ($wName + "UpdateQueued");
	nw4cSetAnimRange_UpdateDagList($wName);
	nw4cSetAnimRange_UpdateAnimRangeList($wName, $updateEditor);
}

/******************************************************************************
	update view queue
******************************************************************************/
global proc nw4cSetAnimRange_UpdateViewQueue(string $wName, int $updateEditor)
{
	if (!`window -ex $wName`)
	{
		return;
	}

	if (!`checkBox -q -v ($wName + "UpdateQueued")`)
	{
		checkBox -e -v true ($wName + "UpdateQueued");
		evalDeferred -lp ("nw4cSetAnimRange_UpdateView " + $wName + " " + $updateEditor);
	}
}

/******************************************************************************
	draw editor label (by frameLayout)
******************************************************************************/
proc DrawEditorLabel(string $label)
{
	frameLayout -lv false -cll false -bs "etchedOut";
		columnLayout -adj true -cat "both" 0;
			text -l $label;
		setParent ..;
	setParent ..;
}

/******************************************************************************
	playback button CB
******************************************************************************/
global proc nw4cSetAnimRange_OnPlaybackButton(string $wName, int $cmd)
{
	if (!`window -ex $wName`)
	{
		return;
	}
	if (GetCurrentAnimRange($wName) != "")
	{
		int $cmdTable[];
		if ($cmd == 0)		// stop
		{
			$cmdTable = { false, false, true };
		}
		else if ($cmd == 1)	// once
		{
			$cmdTable = { true, false, false };
		}
		else				// continuous
		{
			$cmdTable = { true, true, false };
		}
		checkBox -e -v $cmdTable[0] ($wName + "PlaybackEnable");
		checkBox -e -v $cmdTable[1] ($wName + "PlaybackContinuous");
		checkBox -e -v $cmdTable[2] ($wName + "PlaybackStop");
		if ($cmd)
		{
			playButtonForward(); // others/timeSlider.mel
		}
	}
	if ($cmd == 0)		// stop
	{
		play -st false;
	}
}

/******************************************************************************
	create playback control
******************************************************************************/
proc string CreatePlaybackControl(string $wName)
{
	string $lay = `formLayout`;
		string $btn0 = `symbolButton -w 26 -h 26 ($wName + "PlayBtn0")`;
		string $btn1 = `symbolButton -w 26 -h 26 ($wName + "PlayBtn1")`;
	setParent ..; // formLayout
	formLayout -e
		-af $btn0 "left" 24
		-af $btn0 "top" 0
		-af $btn0 "bottom" 0
		-ac $btn1 "left" 20 $btn0
		-af $btn1 "top" 0
		-af $btn1 "bottom" 0
		$lay;
	UpdatePlaybackButton($wName);
	return $lay;
/*
	string $addAnn = "AnimRange ";
	string $icon[] = // iconFile, annotation, command, dimWhenPlay, space
	{
		"nw4cSetAnimRange_Play.bmp"    , ($addAnn + "Once"),
		("nw4cSetAnimRange_OnPlaybackButton " + $wName + " 1;"), "t", "0" ,
		"nw4cSetAnimRange_PlayLoop.bmp", ($addAnn + "Continuous"),
		("nw4cSetAnimRange_OnPlaybackButton " + $wName + " 2;"), "t", "20",
		"nw4cSetAnimRange_Stop.bmp"    , ("Stop"),
		("nw4cSetAnimRange_OnPlaybackButton " + $wName + " 0;"), "f", "20"
	};
	int $i, $j = 0, $w, $h;
	string $lay;
	string $btn[];
	$lay = `formLayout`;
	for ($i = 0; $i < size($icon); $i += 5)
	{
		// get size
		$btn[$j] = `picture -i $icon[$i]`;
		$w = `picture -q -w $btn[$j]`;
		$h = `picture -q -h $btn[$j]`;
		deleteUI $btn[$j];
		// create
		$btn[$j] = `symbolButton -w ($w + 2) -h ($h + 2)
			-i $icon[$i] -ann $icon[$i + 1] -c $icon[$i + 2]
			($wName + "PlayBtn" + $j)`;
		eval("dimWhen -" + $icon[$i + 3] + " playingBack " + $btn[$j]);
		if (!$i)
		{
			formLayout -e
				-af $btn[$j] "top" 0
				-af $btn[$j] "left" 0
				-af $btn[$j] "bottom" 0 $lay;
		}
		else
		{
			formLayout -e
				-af $btn[$j] "top" 0
				-ac $btn[$j] "left" ((int)$icon[$i + 4]) $btn[$j - 1]
				-af $btn[$j] "bottom" 0 $lay;
		}
		++$j;
	}
	setParent ..; // formLayout
	return $lay;
*/
}

/******************************************************************************
	create animation range edit control
******************************************************************************/
proc CreateAnimRangeEditControl(string $wName)
{
	int $afterMaya2011Adjust = 0;
	if (getApplicationVersionAsFloat() >= 2011)
		$afterMaya2011Adjust = 1;

	int $no = GetNumberOfClip();
	for ($i = 0; $i < $no; ++$i)
	{
		rowLayout -nc 7 -cw 1 (110 + $afterMaya2011Adjust * 10) -cw 2 (40 + $afterMaya2011Adjust * 9)
					-cw 3 200 -cw 4 45 -cw 5 45 -cw 6 50 -cw 7 40
					-cat 1 "both" 0 -cat 2 "both" 12 -cat 3 "both" 0 -cat 4 "both" 0 -cat 5 "both" 1 -cat 6 "both" 3 -cat 7 "both" 12
					-cal 1 "center" -cal 2 "center" -cal 3 "center" -cal 4 "center" -cal 5 "center" -cal 6 "center" -cal 7 "center"
					-rat 6 "bottom" 1;
			popupMenu -b 3 -pmc ("nw4cSetAnimRange_OnMenuEditor " + $wName + " " + $i);
				menuItem -l ("Set Anim Range from \"Selected Range\"")
					-c ("nw4cSetAnimRange_GetTimeRange " + $wName + " " + $i + " t")
					($wName + "EditorMenu" + $i + "Item1");
				menuItem -l ("Set Anim Range from \"Playback Range\"")
					-c ("nw4cSetAnimRange_GetTimeRange " + $wName + " " + $i + " p")
					($wName + "EditorMenu" + $i + "Item2");
				menuItem -l ("Set Anim Range from \"Scene Range\"")
					-c ("nw4cSetAnimRange_GetTimeRange " + $wName + " " + $i + " a")
					($wName + "EditorMenu" + $i + "Item3");
				menuItem -d true;
				menuItem -l ("Set Playback Range from \"nw4c_AnimRange" + $i + "\"")
					-c ("nw4cSetAnimRange_GetTimeRange " + $wName + " " + $i + " s")
					($wName + "EditorMenu" + $i + "Item4");
				menuItem -l ("Set Playback Range from \"Enabled Anim Ranges\"")
					-c ("nw4cSetAnimRange_GetTimeRange " + $wName + " " + $i + " m");
				menuItem -d true;
				menuItem -l ("Select \"nw4c_AnimRange" + $i + "\" Anim Curve")
					-c ("nw4cSetAnimRange_SelectTimeRangeKey " + $wName + " " + $i)
					($wName + "EditorMenu" + $i + "Item5");
				menuItem -l ("Select \"nw4c_AnimRange" + $i + "\" Hierarchy Anim Curve")
					-c ("nw4cSetAnimRange_SelectHierarchyTimeRange " + $wName + " " + $i)
					($wName + "EditorMenu" + $i + "Item6");
				menuItem -d true;
				menuItem -l ("Move Up \"nw4c_AnimRange" + $i + "\"")
					-c ("nw4cSetAnimRange_MoveTimeRange " + $wName + " " + $i + " u")
					($wName + "EditorMenu" + $i + "Item7");
				menuItem -l ("Move Down \"nw4c_AnimRange" + $i + "\"")
					-c ("nw4cSetAnimRange_MoveTimeRange " + $wName + " " + $i + " d")
					($wName + "EditorMenu" + $i + "Item8");
				menuItem -d true;
				menuItem -l ("Sort Order by Anim Range")
					-c ("nw4cSetAnimRange_SortPack " + $wName + " t");
				menuItem -l ("Sort Order by Title")
					-c ("nw4cSetAnimRange_SortPack " + $wName + " n");
				menuItem -d true;
				menuItem -l ("Delete \"nw4c_AnimRange" + $i + "\"")
					-c ("nw4cSetAnimRange_DeleteTimeRange " + $wName + " " + $i + " s")
					($wName + "EditorMenu" + $i + "Item9");
				menuItem -l ("Delete \"Disabled Anim Ranges\"")
					-c ("nw4cSetAnimRange_DeleteTimeRange " + $wName + " " + $i + " m");
				menuItem -d true;
				menuItem -l ("Add Key to Hierarchy from \"nw4c_AnimRange" + $i + "\"")
					-c ("nw4cSetAnimRange_SetAnimRangeRangeKey " + $wName + " " + $i)
					($wName + "EditorMenu" + $i + "Item10");
				menuItem -l ("Add Key to Hierarchy from Enabled Anim Ranges")
					-c ("nw4cSetAnimRange_SetEnabledAnimRangeRangeKey " + $wName + " " + $i)
					($wName + "EditorMenu" + $i + "Item11");

			button -l ("nw4c_AnimRange" + $i)
				-dgc ("nw4cSetAnimRange_DragAnimRange " + $wName)
				-dpc ("nw4cSetAnimRange_DropAnimRange " + $wName)
				-ann ("Select \"nw4c_AnimRange" + $i + "\" Hierarchy Anim Curve")
				-c ("nw4cSetAnimRange_SelectHierarchyTimeRange " + $wName + " " + $i)
				($wName + "ClipNo" + $i);

			checkBox -l "" ($wName + "ClipEnable" + $i);

			textField -cc ("nw4cSetAnimRange_CheckAnimRangeTitle " + $wName + " " + $i)
				($wName + "ClipName" + $i);

			floatField -pre 0 ($wName + "ClipStart" + $i);
			floatField -pre 0 ($wName + "ClipEnd" + $i);

			frameLayout -lv false -cll false -bs "in" -mw 1;
				text -l "" ($wName + "ClipSpan" + $i);
			setParent ..; // frameLayout

			checkBox -l "" ($wName + "ClipLoop" + $i);
		setParent ..; // rowLayout

		// no attr-change-event from anim-editor (Maya bugfix)
		floatField -m false ($wName + "ClipAttr" + $i);
	}
}

/******************************************************************************
	load plugin
******************************************************************************/
proc LoadPlugin()
{
	if (!`pluginInfo -q -l "NW4C_CallbackJob.mll"`)
	{
		loadPlugin("NW4C_CallbackJob.mll");
	}
}

/******************************************************************************
	main
******************************************************************************/
global proc NW4C_SetAnimRange()
{
	int $afterMaya2011Adjust = 0;
	if (getApplicationVersionAsFloat() >= 2011)
		$afterMaya2011Adjust = 1;

    // minimum window size
	int $winW = 580 + $afterMaya2011Adjust * 50;
	int $winH = 441;

	//-----------------------------------------------------------------------------
	// load plugin
	LoadPlugin();

	//-----------------------------------------------------------------------------
	// check window exists
	string $wName = GetWindowNameString();
	if (`window -ex $wName`)
	{
		showWindow $wName;
		return;
	}

	//-----------------------------------------------------------------------------
	// check playing back
	if (`isTrue "playingBack"`)
	{
		play -st false;
		warning ("PlayBack was stopped. Please restart \"NW4C Set Anim Range\".");
		return;
	}
	nw4cSetAnimRange_PlaybackExit($wName);

	//-----------------------------------------------------------------------------
	// begin create window
	waitCursor -st 1;
	window -t "NW4C Set Animation Range" -wh $winW $winH -mb 1 $wName;
	window -e -in `window -q -t $wName` $wName;		// (Maya bugfix)

	//-----------------------------------------------------------------------------
	// main menu
	//menuBarLayout;
	menu -l "File" -pmc ("nw4cSetAnimRange_OnMenuFile " + $wName);
		menuItem -l "Import Animation Range Channels..."
			-c ("nw4cSetAnimRange_ImportAnimRange " + $wName)
			($wName + "FileMenuItem1");
		menuItem -l "Export Animation Range Channels..."
			-c ("nw4cSetAnimRange_ExportAnimRange " + $wName)
			($wName + "FileMenuItem2");
	menu -l "Window";
		//if (!`exists nw4c_AnimEditUtility`)
		if (1)
		{
			menuItem -l "Graph Editor..." -c ("nw4cSetAnimRange_CallEditor " + $wName + " GraphEditor");
			menuItem -l "Dope Sheet..." -c ("nw4cSetAnimRange_CallEditor " + $wName + " DopeSheetEditor");
		}
		//else
		//{
		//	menuItem -l "NW4C AnimEdit Utility..." -c ("nw4cSetAnimRange_CallEditor " + $wName + " nw4c_AnimEditUtility");
		//}
	menu -l "Help";
		menuItem -l ("Help on " + `window -q -t $wName` + "...")
			-c "NW4C_ShowHelp \"html/NW4C_SetAnimRange.html\" \"\"";
	//setParent ..; // menuBarLayout

	//-----------------------------------------------------------------------------
	// top layout
	string $frm, $ctl;
	formLayout ($wName + "TopLayout");
		nameField -en false -vis false ($wName + "DagName");
		nameField -en false -vis false ($wName + "AnimRangeNameMaster");
		paneLayout -cn "top3" -ps 1 50 30 -ps 2 50 30 -ps 3 100 70
			-h 270 -w 530 ($wName + "Pane");
			//-----------------------------------------------------------------------------
			// dag list
			$frm = `formLayout`;
				$ctl = `text -l "Root List"`;
				textScrollList -ams false -fn "plainLabelFont"
					-sc ("nw4cSetAnimRange_OnSelectDagList " + $wName)
					-dcc ("nw4cSetAnimRange_OnDblClkDagList " + $wName)
					($wName + "DagList");
					popupMenu -b 3 -pmc ("nw4cSetAnimRange_OnMenuDagList " + $wName);
						menuItem -l "Create and Attach nw4c_AnimRangeCtrl"
							-c ("nw4cSetAnimRange_CreateAnimRange " + $wName + " a")
							($wName + "DagListMenuItem1");
				formLayout -e
						-af $ctl "top"		0
						-af $ctl "left"		5
						-an $ctl "bottom"
						-af $ctl "right"	0
						-ac ($wName + "DagList") "top"		0	$ctl
						-af ($wName + "DagList") "left"		0
						-af ($wName + "DagList") "bottom"	0
						-af ($wName + "DagList") "right"	0
						$frm;
			setParent ..; // formLayout

			//-----------------------------------------------------------------------------
			// animation range list
			$frm = `formLayout`;
				$ctl = `text -l "nw4c_AnimRangeCtrl List"`;
				nameField -vis false ($wName + "AnimRangeNameWork");
				textScrollList -ams false -fn "plainLabelFont"
					-sc ("nw4cSetAnimRange_OnSelectAnimRangeList " + $wName)
					-dcc ("nw4cSetAnimRange_OnDblClkAnimRangeList " + $wName)
					($wName + "AnimRangeList");
					popupMenu -b 3 -pmc ("nw4cSetAnimRange_OnMenuAnimRangeList " + $wName);
						menuItem -l "Create nw4c_AnimRangeCtrl"
							-c ("nw4cSetAnimRange_CreateAnimRange " + $wName + " c")
							($wName + "AnimRangeListMenuItem1");
						menuItem -l "Duplicate Highlighted"
							-c ("nw4cSetAnimRange_DuplicateAnimRange " + $wName)
							($wName + "AnimRangeListMenuItem2");
						menuItem -d true;
						menuItem -l "Attach Highlighted to" -sm true
							($wName + "AnimRangeListMenuItem3");
						setParent -menu ..;
						menuItem -l "Detach Highlighted"
							-c ("nw4cSetAnimRange_DeattachAnimRange " + $wName)
							($wName + "AnimRangeListMenuItem4");
						menuItem -d true;
						menuItem -l "Delete Highlighted"
							-c ("nw4cSetAnimRange_DeleteAnimRangeCtrl " + $wName)
							($wName + "AnimRangeListMenuItem5");
				formLayout -e
						-af $ctl "top"		0
						-af $ctl "left"		5
						-an $ctl "bottom"
						-af $ctl "right"	0
						-ac ($wName + "AnimRangeList") "top"		0	$ctl
						-af ($wName + "AnimRangeList") "left"		0
						-af ($wName + "AnimRangeList") "bottom"	0
						-af ($wName + "AnimRangeList") "right"	0
						$frm;
			setParent ..; // formLayout

			//-----------------------------------------------------------------------------
			// edit area
			$frm = `formLayout`;
				$ctl = `scrollLayout -hst 0`;
				formLayout -e
						-af $ctl "top"		0
						-af $ctl "left"		0
						-af $ctl "bottom"	0
						-af $ctl "right"	0
						$frm;
					columnLayout -adj true -cat "both" 0;
						text -l " Edit" -fn "boldLabelFont" -al "left";
						rowLayout -nc 2 -cw 1 (170 + $afterMaya2011Adjust * 20) -cw 2 220
							-ct2 "both" "both" -cl2 "right" "center";
							text -l "Current nw4c_AnimRangeCtrl  :  ";
							nameField -en false ($wName + "AnimRangeName");
						setParent ..; // rowLayout
						separator -st "none" -h 5;

						rowColumnLayout -nc 5
							-cw 1 (1 + $afterMaya2011Adjust * 75) -cw 2 (169 - $afterMaya2011Adjust * 53) -cw 3 300 -cw 4 5 -cw 5 25
							-cat 2 "right" 0;
							text -l ""; // dummy
							checkBox -l "Merge cmdl File" -v 0
								-cc ("nw4cSetAnimRange_MergeCmdlFlagCB " + $wName)
								($wName + "MergeCmdlFlag");
							textField
								($wName + "MergeCmdlPath");
							text -l ""; // dummy
							symbolButton -i "navButtonBrowse.xpm"
								-c ("nw4cSetAnimRange_MergeCmdlBrowserCB " + $wName)
								($wName + "MergeCmdlBrowser");
						setParent ..; // rowColumnLayout
						separator -st "none" -h 5;

						frameLayout -l "" -cll 1 -cl 1 -bv 1 -bs "etchedIn"
								($wName + "CustomOptsLayout");
							columnLayout -adj 1 -rs 4;
								checkBoxGrp -l "" -ncb 1 -cw2 18 200
									-l1 "Enable Custom Options"
									-cc ("nw4cSetAnimRange_EnableCustomOptsCB " + $wName)
									($wName + "EnableCustomOpts");
								frameLayout -l "Optimization Options" -cll 0 -cl 0 -bv 1 -bs "etchedIn";
									columnLayout -adj 1 -rs 4;
									optionMenuGrp -l "Compress Node" -cw 1 100
										-rat 1 "both" 4 -cat 1 "right" 4
										($wName + "CompressNode");
										menuItem -da 0 -l "None";
										menuItem -da 1 -l "Cull Useless Node";
										menuItem -da 2 -l "Cull Uninfluential Node";
										menuItem -da 3 -l "Unite Compressible Node";
										menuItem -da 4 -l "Unite All Node";
										menuItem -da 5 -l "Unite Below Node";
									optionMenuGrp -l "Compress Material" -cw 1 100
										-rat 1 "both" 4 -cat 1 "right" 4
										($wName + "CompressMaterial");
										menuItem -da 0 -l "None";
										menuItem -da 1 -l "Compress Same Material";
									checkBoxGrp -l "" -ncb 1 -cw 1 100 -cw 2 120
										-l1 "Optimize Primitive" -v1 0
										($wName + "OptimizePrimitive");
									checkBoxGrp -l "" -ncb 1 -cw 1 100 -cw 2 190
										-l1 "Disable SkeletalModel-Simplification" -v1 0
										($wName + "DisableSkeletalModelSimplification");
									setParent ..; // columnLayout
								setParent ..; // frameLayout
							setParent ..; // columnLayout
						setParent ..; // frameLayout
						separator -st "none" -h 5;

						columnLayout -adj true -cat "both" 0 ($wName + "Editor");
							textScrollList -vis 0 ($wName + "_ClipNameList"); // to restore name (never displayed)
							rowLayout -nc 6
								-cw 1 (110 + $afterMaya2011Adjust * 10) -cw 2 (40 + $afterMaya2011Adjust * 10)
								-cw 3 200 -cw 4 (90 + $afterMaya2011Adjust * 33) -cw 5 50 -cw 6 40
								-ct6 "both" "both" "both" "both" "both" "both"
								-cl6 "center" "center" "center" "center" "center" "center";
								DrawEditorLabel("Channel");
								DrawEditorLabel("Enable");
									popupMenu -b 3;
										menuItem -l "Enable All"
											-c ("nw4cSetAnimRange_EnableAll " + $wName + " e");
										menuItem -l "Disable All"
											-c ("nw4cSetAnimRange_EnableAll " + $wName + " d");
								DrawEditorLabel("Title");
								DrawEditorLabel("Animation Range");
								DrawEditorLabel("Size");
								DrawEditorLabel("Loop");
							setParent ..; // rowLayout
							columnLayout -adj true -cat "both" 0;
								CreateAnimRangeEditControl($wName);
							setParent ..; // columnLayout
						setParent ..; // columnLayout
					setParent ..; // columnLayout
				setParent ..; // scrollLayout
			setParent ..; // formLayout
		setParent ..; // paneLayout

		//-----------------------------------------------------------------------------
		$ctl = `columnLayout -adj true -cat "both" 0`;
			//-----------------------------------------------------------------------------
			// playback
			frameLayout -lv false -cll false -bs "in";
				columnLayout -adj true -cat "both" 0;
					rowLayout -nc 3 -cw 1 220 -cw 2 180 -adj 3
						-ct3 "both" "both" "both"
						-cl3 "left" "center" "center";
						columnLayout -adj true -cat "both" 0 -cal "left";
							text -l " Current Animation Range Playback" -fn "boldLabelFont";
						setParent ..; // columnLayout
						columnLayout -adj true -cat "both" 0;
							separator -st "none" -h 5;
							CreatePlaybackControl($wName);
						setParent ..; // columnLayout
						columnLayout -adj true -cat "both" 0;
							separator -st "none" -h 8;
							rowLayout -nc 2 -cw 1 70 -cw 2 40
								-ct2 "both" "both" -cl2 "right" "center";
								text -l "Loop Count ";
								intField -v 3 -min 1 ($wName + "Loop");
							setParent ..; // rowLayout
						setParent ..; // columnLayout
					setParent ..; // rowLayout
					columnLayout -vis false -adj true -cat "both" 10 -cal "left";
						checkBox -l "" ($wName + "PlaybackEnable");
						checkBox -l "" ($wName + "PlaybackContinuous");
						checkBox -l "" ($wName + "PlaybackStop");
						separator -st "none" -h 3;
					setParent ..; // columnLayout
					separator -st "none" -h 3;
				setParent ..; // columnLayout
			setParent ..; // frameLayout
			separator -st "none" -h 5;

			//-----------------------------------------------------------------------------
			// close button
			columnLayout -adj true -cat "both" 10;
				button -l "Close" -c ("deleteUI " + $wName);
			setParent ..; // columnLayout

			formLayout -e
				-af ($wName + "Pane") "top"		0
				-af ($wName + "Pane") "left"	0
				-ac ($wName + "Pane") "bottom"	0	$ctl
				-af ($wName + "Pane") "right"	0
				-an $ctl "top"
				-af $ctl "left"		0
				-af $ctl "bottom"	3
				-af $ctl "right"	0
				($wName + "TopLayout");

			// speed up
			//nw4cSetAnimRange_NodeUpdateCtrl($wName, $wName + "TopLayout", "nw4cSetAnimRange_UpdateView " + $wName);
				// ^ commented out in original
			checkBox -m false -v false ($wName + "UpdateQueued");

			//-----------------------------------------------------------------------------
			// set script job
			scriptJob -p $wName -e deleteAll ("nw4cSetAnimRange_UpdateViewQueue " + $wName + " 0");
			scriptJob -p $wName -e NameChanged ("nw4cSetAnimRange_UpdateViewQueue " + $wName + " 1");
			scriptJob -p $wName -cf readingFile ("nw4cSetAnimRange_UpdateViewQueue " + $wName + " 0");
			scriptJob -p $wName -ct "delete" ("nw4cSetAnimRange_UpdateViewQueue " + $wName + " 0");
			scriptJob -p $wName -e DagObjectCreated ("nw4cSetAnimRange_UpdateViewQueue " + $wName + " 0");
			eval("NW4C_CallbackJob -p " + $wName
				+ " -e kAfterRemoveReference \"nw4cSetAnimRange_UpdateViewQueue " + $wName + " 0\"");
			if (`getApplicationVersionAsFloat` >= 6.5) // in startup/getApplicationVersionAsFloat.mel
			{
				eval("NW4C_CallbackJob -p " + $wName
					+ " -e kAfterUnloadReference \"nw4cSetAnimRange_UpdateViewQueue " + $wName + " 0\"");
			}
			eval("NW4C_CallbackJob -p " + $wName
				+ " -e kParentAdded \"nw4cSetAnimRange_UpdateViewQueue " + $wName + " 0\"");
			eval("NW4C_CallbackJob -p " + $wName
				+ " -e kParentRemoved \"nw4cSetAnimRange_UpdateViewQueue " + $wName + " 0\"");
			eval("NW4C_CallbackJob -p " + $wName
				+ " -e kChildReordered \"nw4cSetAnimRange_UpdateViewQueue " + $wName + " 0\"");

			button -m false ($wName + "DefFocus");
			setFocus ($wName + "DefFocus");

		setParent ..; // columnLayout (playback & close)
	setParent ..; // formLayout (Top)

	if (`window -q -w $wName` < $winW)
	{
		window -e -w $winW $wName;
	}
	if (`window -q -h $wName` < $winH)
	{
		window -e -h $winH $wName;
	}

	showWindow;

	//-----------------------------------------------------------------------------
	// update window
	nw4cSetAnimRange_UpdateView($wName, 0);
	SetEditorCurrent($wName, "");
	waitCursor -st 0;

	//-----------------------------------------------------------------------------
	// create playing back condition
	condition -i -d "playingBack"
		-s ("nw4cSetAnimRange_PlaybackCondition " + $wName)
		($wName + "PlaybackCondition");
	scriptJob -uid $wName ("nw4cSetAnimRange_PlaybackCondition " + $wName);
	scriptJob -p $wName -e SelectionChanged
		("nw4cSetAnimRange_OnKeyChangeAddKey " + $wName);
}