// Multi Keying Numeric 0.851

@name "MultiKeyingNumeric"
@version 2.5
@warnings
@script generic

@define DESCRIPT "Multi Keying Numeric Panel"
@define MODE_SET 1
@define MODE_COPY 2
@define MODE_ADD 3
@define MODE_EX_ADD 4
@define MODE_SEQ_ADD 5
@define MODE_SEQ_COPY 6
@define MODE_PAIR_COPY 7
// 回転制限反映スイッチの初期状態 true/false
@define DEFAULT_LIMIT true
// Copy時の自己書き換えスイッチの初期状態 true/false
@define DEFAULT_SELFWRITE false
// minisliderでの入力可能範囲フレーム数
@define FRAME_MIN -100
@define FRAME_MAX 1000

// getLimitRot(Item)：ItemのLimitRotationをVal[6](Hmin,Pmin,Bmin,Hmax,Pmax,Bmax)で返す。Limit有効なら値、無効ならNil
// searchKeyIDOrder(Channel, SrcTime)：Channel内からSrcTimeのKeyを探して返す。在ればKey番号(Key[]用)、無ければNil
// getKeyIDRange(Channel, StTime, EdTime)：Channel内のStTime〜EdTime間に納まるKey番号の始点番号と終点番号を返す
// Keyが１個なら1と0、0個なら1と-2が返る。 終点-始点+1すると有効な数が判る
// testValMinMax(Value, Min, Max)：ValueがMinより小さければMinを、Maxより大きければMaxを返す。範囲内ならValueを返す

// 変更/反転フラグとctl.OA用
var ChgFlag[9];
var RevFlag[9];
var f1,f2,f3,f4,f5,f6,f7,f8,f9;
var c0,cA,cB;
var MaxChan;
var CurScene;

generic
{
//debug();
	CurScene = Scene();
	var CurItems = CurScene.getSelect();
	if(CurItems == nil) return;
 	var ItemNum = CurItems.size();
	var CurTime  = CurScene.currenttime;
	var CurFrame = CurTime / (1.0 / CurScene.fps);
// 1をFPSで割った値が1Frame辺りの秒数

// Channel数確定
	if(CurItems[1].isCamera() || CurItems[1].isLight()) MaxChan = 6;
	else MaxChan = 9;

	ChgFlag[] = false;
	RevFlag[] = false;

// 基本値の取得
	var Val;
	var CurVal[9];
	var CurKeyCurv[9];
	var CurChan = CurItems[ItemNum].firstChannel();
	for(i = 1; i <= MaxChan; i++){
// .value()はラジアン、.getKeyValueでは度数
		CurVal[i] = CurChan.value(CurTime);
		if((KeyID = CurChan.keyExists(CurTime)) != nil){
// LS2.5だと配列に.get〜()メソッドで値を入れるとLSCoreが壊れる?。LS2.7〜では平気
			Val = CurChan.getKeyCurve(KeyID);
			CurKeyCurv[i] = Val;
		}
		CurChan = CurItems[ItemNum].nextChannel();
	}
// .value()で得たラジアンを度数に変換
	CurVal[4] = deg(CurVal[4]);
	CurVal[5] = deg(CurVal[5]);
	CurVal[6] = deg(CurVal[6]);
	if(MaxChan == 6){
		CurVal[7] = 1.0;
		CurVal[8] = 1.0;
		CurVal[9] = 1.0;
	}

// ---------------------------
	reqbegin(DESCRIPT);
		reqsize(380,200);
		m0 = ctlchoice("", 1, @"   Set","  Copy","  Add"," ExAdd","SeqAdd","SeqCopy","PairCopy"@, false);
			ctlposition(m0,  0,  2,372);
// 現在or対象Frame
		c0 = ctlminislider("Frame", CurFrame, FRAME_MIN, FRAME_MAX);
		ctlposition(c0, 58, 23, 80);
		p0 = ctlbutton("",  16, "setPreStFrame");
		ctlposition(p0,162, 23);
// 終端Frame
		cA = ctlminislider("-", CurFrame, FRAME_MIN, FRAME_MAX);
		ctlposition(cA,181, 23, 55);
		pA = ctlbutton("",  16, "setPreEdFrame");
		ctlposition(pA,260, 23);
// シフトFrame
		cB = ctlminislider("Shift", 0, FRAME_MIN, FRAME_MAX);
		ctlposition(cB,278, 23, 72);

		lt = ctlcheckbox("LimitRotate", DEFAULT_LIMIT);
		ctlposition(lt,104,148);
		ov = ctlcheckbox("SelfWback", DEFAULT_SELFWRITE);
		ctlposition(ov, 10,148);
// セパレータ
		s0 = ctlsep();
		ctlposition(s0, 0, 49);

		tp = ctltext("","Position");
		ctlposition(tp,  39,122);
		fp = ctlbutton("",   16, "changeFlagPos");
		ctlposition(fp, 104,123);
// pos X
		tpx = ctltext("","X");
		ctlposition(tpx,  5, 58);
		r1 = ctlstate("", false, 16, "changeFlagRevPX");
		ctlposition(r1,  16, 55);
		c1 = ctldistance("",CurVal[1]);
		ctlposition(c1,  32, 55);
		f1 = ctlstate("", false, 16, "changeFlagPXT");
		ctlposition(f1, 104, 55);
// pos Y
		tpy = ctltext("","Y");
		ctlposition(tpy,  5, 80);
		r2 = ctlstate("", false, 16, "changeFlagRevPY");
		ctlposition(r2,  16, 77);
		c2 = ctldistance("",CurVal[2]);
		ctlposition(c2,  32, 77);
		f2 = ctlstate("", false, 16, "changeFlagPYT");
		ctlposition(f2, 104, 77);
// pos Z
		tpz = ctltext("","Z");
		ctlposition(tpz,  5,102);
		r3 = ctlstate("", false, 16, "changeFlagRevPZ");
		ctlposition(r3,  16, 99);
		c3 = ctldistance("",CurVal[3]);
		ctlposition(c3,  32, 99);
		f3 = ctlstate("", false, 16, "changeFlagPZT");
		ctlposition(f3, 104, 99);

		tr = ctltext("","Rotation");
		ctlposition(tr, 159,122);
		fr = ctlbutton("",   16, "changeFlagRot");
		ctlposition(fr, 247,123);
// rot H
		trh = ctltext("","H");
		ctlposition(trh,125, 58);
		r4 = ctlstate("", false, 16, "changeFlagRevRH");
		ctlposition(r4, 136, 55);
		c4 = ctlangle("",CurVal[4]);
		ctlposition(c4, 152, 55);
		f4 = ctlstate("", false, 16, "changeFlagRHT");
		ctlposition(f4, 247, 55);
// rot P
		trp = ctltext("","P");
		ctlposition(trp,125, 80);
		r5 = ctlstate("", false, 16, "changeFlagRevRP");
		ctlposition(r5, 136, 77);
		c5 = ctlangle("",CurVal[5]);
		ctlposition(c5, 152, 77);
		f5 = ctlstate("", false, 16, "changeFlagRPT");
		ctlposition(f5, 247, 77);
// rot B
		trb = ctltext("","B");
		ctlposition(trb,125,102);
		r6 = ctlstate("", false, 16, "changeFlagRevRB");
		ctlposition(r6, 136, 99);
		c6 = ctlangle("",CurVal[6]);
		ctlposition(c6, 152, 99);
		f6 = ctlstate("", false, 16, "changeFlagRBT");
		ctlposition(f6, 247, 99);

		ts = ctltext("","Scale");
		ctlposition(ts, 290,122);
		fs = ctlbutton("",   16, "changeFlagScl");
		ctlposition(fs, 355,123);
// Scl X
		tsx = ctltext("","SX");
		ctlposition(tsx,268, 58);
		c7 = ctlnumber("",CurVal[7]);
		ctlposition(c7, 282, 55);
		f7 = ctlstate("", false, 16, "changeFlagSXT");
		ctlposition(f7, 355, 55);
// Scl Y
		tsy = ctltext("","SY");
		ctlposition(tsy,268, 80);
		c8 = ctlnumber("",CurVal[8]);
		ctlposition(c8, 282, 77);
		f8 = ctlstate("", false, 16, "changeFlagSYT");
		ctlposition(f8, 355, 77);
// Scl Z
		tsz = ctltext("","SZ");
		ctlposition(tsz,268,102);
		c9 = ctlnumber("",CurVal[9]);
		ctlposition(c9, 282, 99);
		f9 = ctlstate("", false, 16, "changeFlagSZT");
		ctlposition(f9, 355, 99);

// Item名表示用枠
		n0 = ctlstring("1st", CurItems[ItemNum].name);
		ctlposition(n0, 200,148,170);

// セパレータをトリガにしてItem欄をマスク
		ctlactive( s0, "maskItemSlot",  n0);
// セパレータをトリガにしてカメラ＆ライト時にスケール欄をマスクする為
		ctlactive( s0, "maskScales", c7,c8,c9);
		ctlvisible(s0, "maskScales", f7,f8,f9,fs);

		ctlactive( m0, "maskEndFrame",  cA, pA);
		ctlactive( m0, "maskInputVal6", c1,c2,c3,c4,c5,c6);
		ctlactive( m0, "maskInputVal9", c7,c8,c9);
		ctlactive( m0, "maskInputVal", c1,c2,c3,c4,c5,c6,c7,c8,c9);
		ctlactive( m0, "maskShiftFrame",cB);
		ctlactive( m0, "maskSelfWback", ov);
		ctlrefresh(c0, "changeFlagCurTime");
		ctlrefresh(cA, "changeFlagEndTime");
		ctlrefresh(c1, "changeFlagPX");
		ctlrefresh(c2, "changeFlagPY");
		ctlrefresh(c3, "changeFlagPZ");
		ctlrefresh(c4, "changeFlagRH");
		ctlrefresh(c5, "changeFlagRP");
		ctlrefresh(c6, "changeFlagRB");
		ctlrefresh(c7, "changeFlagSX");
		ctlrefresh(c8, "changeFlagSY");
		ctlrefresh(c9, "changeFlagSZ");
	return if !reqpost();
	var SelType   = getvalue(m0);
		CurFrame  = getvalue(c0);
	var EndFrame  = getvalue(cA);
	var ShtFrame  = getvalue(cB);
		CurVal[1] = getvalue(c1);
		CurVal[2] = getvalue(c2);
		CurVal[3] = getvalue(c3);
		CurVal[4] = getvalue(c4);
		CurVal[5] = getvalue(c5);
		CurVal[6] = getvalue(c6);
		CurVal[7] = getvalue(c7);
		CurVal[8] = getvalue(c8);
		CurVal[9] = getvalue(c9);
	var LimitType = getvalue(lt);
	var SelfWType = getvalue(ov);
	reqend();

	if((SelType == MODE_SEQ_COPY)&&(CurFrame == EndFrame)){
		info("<br>Start Frame equal End Frame, Changed Single COPY mode");
		SelType = MODE_COPY;
	}
	if((SelType == MODE_SEQ_ADD)&&(CurFrame == EndFrame)){
		info("<br>Start Frame equal End Frame, Changed Single ADD mode");
		SelType = MODE_ADD;
	}

// フレームに応じた時間の生成。
	var EndTime, ShtTime;
	CurTime = CurFrame / CurScene.fps;
	EndTime = EndFrame / CurScene.fps;
	if(ShtFrame != 0) ShtTime = ShtFrame / CurScene.fps;
	else ShtTime = 0.0;

// ---------------------------
	var SrcKeyNum, TempItemNum, KeyID;
	var KeyBlock;
	var StKeyOrder, EdKeyOrder;
	var LimitRot[6];
	switch(SelType){
		case MODE_SET:
			for(i = 1; i <= ItemNum; i++){
				if(LimitType && (ChgFlag[4] || ChgFlag[5] || ChgFlag[6]))
					LimitRot = getLimitRot(CurItems[i]);
				CurChan = CurItems[i].firstChannel();
				for(c = 1; c <= MaxChan; c++){
					if(ChgFlag[c]){
// LimitRotは1-3がHPBmin、4-6がHPBmax。中身(1&3〜)がNilなら無効
						if((4 <= c)&&(c <= 6)&&(LimitType)&&(LimitRot[c] != nil)){
							Val = testValMinMax(CurVal[c], LimitRot[c - 3], LimitRot[c]);
						}else{
							Val = CurVal[c];
						}
						if((KeyID = CurChan.keyExists(CurTime)) != nil) CurChan.setKeyValue(KeyID, Val);
						else CurChan.createKey(CurTime, Val);
					}
					CurChan = CurItems[i].nextChannel();
				}
			}
			break;
// ---------------------------
		case MODE_COPY:
			if((!SelfWType)&&(ItemNum == 1)){
				error("<br>Normal COPY mode Need 2 or more Items");
				break;
			}
// フラグに応じて±反転
			for(i = 1; i <= 6; i++) if(RevFlag[i]) CurVal[i] *= -1.0;
// 第一選択は末尾(ItemNum)
			if(SelfWType) TempItemNum = ItemNum;
			else TempItemNum = ItemNum - 1;
			for(i = 1; i <= TempItemNum; i++){
				if(LimitType && (ChgFlag[4] || ChgFlag[5] || ChgFlag[6]))
					LimitRot = getLimitRot(CurItems[i]);
				CurChan = CurItems[i].firstChannel();
				for(c = 1; c <= MaxChan; c++){
					if(ChgFlag[c]){
						if((4 <= c)&&(c <= 6)&&(LimitType)&&(LimitRot[c] != nil)){
							Val = testValMinMax(CurVal[c], LimitRot[c - 3], LimitRot[c]);
						}else{
							Val = CurVal[c];
						}
						if((KeyID = CurChan.keyExists(CurTime)) != nil) CurChan.setKeyValue(KeyID, Val);
						else KeyID = CurChan.createKey(CurTime, Val);
						if(CurKeyCurv[c] != nil) CurChan.setKeyCurve(KeyID, CurKeyCurv[c]);
					}
					CurChan = CurItems[i].nextChannel();
				}
			}
			break;
// ---------------------------
		case MODE_ADD:
			for(i = 1; i <= ItemNum; i++){
				if(LimitType && (ChgFlag[4] || ChgFlag[5] || ChgFlag[6]))
					LimitRot = getLimitRot(CurItems[i]);
				CurChan = CurItems[i].firstChannel();
				for(c = 1; c <= MaxChan; c++){
					if(ChgFlag[c]){
						if((4 <= c)&&(c <= 6)&&(LimitType)&&(LimitRot[c] != nil)){
							Val = testValMinMax(deg(CurChan.value(CurTime)) + CurVal[c], LimitRot[c - 3], LimitRot[c]);
						}else{
							Val = CurChan.value(CurTime) + CurVal[c];
						}
						if((KeyID = CurChan.keyExists(CurTime)) != nil) CurChan.setKeyValue(KeyID, Val);
						else CurChan.createKey(CurTime, Val);
					}
					CurChan = CurItems[i].nextChannel();
				}
			}
			break;
// ---------------------------
		case MODE_EX_ADD:
			var MultiVal = 1;
// 選択順は降順だから末尾(先頭)から処理
			for(i = ItemNum; i >= 1; i--){
				if(LimitType && (ChgFlag[4] || ChgFlag[5] || ChgFlag[6]))
					LimitRot = getLimitRot(CurItems[i]);
				CurChan = CurItems[i].firstChannel();
				for(c = 1; c <= MaxChan; c++){
					if(ChgFlag[c]){
						if((4 <= c)&&(c <= 6)&&(LimitType)&&(LimitRot[c] != nil)){
							Val = testValMinMax(deg(CurChan.value(CurTime)) + (CurVal[c] * MultiVal), LimitRot[c - 3], LimitRot[c]);
						}else{
							Val = CurChan.value(CurTime) + (CurVal[c] * MultiVal);
						}
						if((KeyID = CurChan.keyExists(CurTime)) != nil) CurChan.setKeyValue(KeyID, Val);
						else CurChan.createKey(CurTime, Val);
					}
					CurChan = CurItems[i].nextChannel();
				}
				MultiVal++;
			}
			break;
// ---------------------------
		case MODE_SEQ_ADD:
			for(i = 1; i <= ItemNum; i++){
				if(LimitType && (ChgFlag[4] || ChgFlag[5] || ChgFlag[6]))
					LimitRot = getLimitRot(CurItems[i]);
				CurChan = CurItems[i].firstChannel();
				for(c = 1; c <= MaxChan; c++){
					if(ChgFlag[c]){
						(StKeyOrder, EdKeyOrder) = getKeyIDRange(CurChan, CurTime, EndTime);
// LimitRot[j]は1-3でHPBmin、[c]は4-6でHPBmaxとなる。無効なら中身(1&3〜)がNil
						if((4 <= c)&&(c <= 6)&&(LimitType)&&(LimitRot[c] != nil)){
							j = c - 3;
							for(x = StKeyOrder; x <= EdKeyOrder; x++){
								Val = testValMinMax(CurChan.getKeyValue(CurChan.keys[x]) + CurVal[c], LimitRot[j], LimitRot[c]);
								CurChan.setKeyValue(CurChan.keys[x], Val);
							}
						}else{
							for(x = StKeyOrder; x <= EdKeyOrder; x++){
								Val = CurChan.getKeyValue(CurChan.keys[x]) + CurVal[c];
								CurChan.setKeyValue(CurChan.keys[x], Val);
							}
						}
					}
					CurChan = CurItems[i].nextChannel();
				}
			}
			break;
// ---------------------------
		case MODE_SEQ_COPY:
			if((!SelfWType)&&(ItemNum == 1)){
				error("<br>Normal SEQUENCE COPY mode Need 2 or more Items");
				break;
			}
// Get MODE_SEQ_COPY
			CurChan = CurItems[ItemNum].firstChannel();
			for(c = 1; c <= MaxChan; c++){
				if(ChgFlag[c]){
					(StKeyOrder, EdKeyOrder) = getKeyIDRange(CurChan, CurTime, EndTime);
					SrcKeyNum[c] = EdKeyOrder - StKeyOrder + 1;
// キー読出し位置は不定、配列への格納はx=1から
					x = 1;
					for(i = StKeyOrder; i <= EdKeyOrder; i++){
						Val = CurChan.getKeyTime(CurChan.keys[i]);
						KeyBlock[c][x][1] = Val;
						Val = CurChan.getKeyValue(CurChan.keys[i]);
						KeyBlock[c][x][2] = Val;
						Val = CurChan.getKeyCurve(CurChan.keys[i]);
						KeyBlock[c][x][3] = Val;
						x++;
					}
// フラグに応じて±反転
					if(RevFlag[c]){
						for(x = 1; x <= SrcKeyNum[c]; x++){
							Val = KeyBlock[c][x][2];
							KeyBlock[c][x][2] = Val * -1.0;
						}
					}
// 時間シフト
					if(ShtFrame != 0){
						for(x = 1; x <= SrcKeyNum[c]; x++){
							Val = KeyBlock[c][x][1];
							KeyBlock[c][x][1] = Val + ShtTime;
						}
					}
				}
				CurChan = CurItems[ItemNum].nextChannel();
			}
			if(SelfWType) TempItemNum = ItemNum;
			else TempItemNum = ItemNum - 1;
// Set MODE_SEQ_COPY
			for(i = 1; i <= TempItemNum; i++){
				if(LimitType && (ChgFlag[4] || ChgFlag[5] || ChgFlag[6]))
					LimitRot = getLimitRot(CurItems[i]);
				CurChan = CurItems[i].firstChannel();
				for(c = 1; c <= MaxChan; c++){
					if(ChgFlag[c]){
						(StKeyOrder, EdKeyOrder) = getKeyIDRange(CurChan, CurTime + ShtTime, EndTime + ShtTime);
						for(x = EdKeyOrder; x >= StKeyOrder; x--) CurChan.deleteKey(CurChan.keys[x]);
// LimitRot[j]は1-3でHPBmin、[c]は4-6でHPBmaxとなる。無効なら中身(1&3〜)がNil
						if((4 <= c)&&(c <= 6)&&(LimitType)&&(LimitRot[c] != nil)){
							j = c - 3;
							for(x = 1; x <= SrcKeyNum[c]; x++){
								Val = testValMinMax(KeyBlock[c][x][2], LimitRot[j], LimitRot[c]);
								KeyID = CurChan.createKey(KeyBlock[c][x][1], Val);
								CurChan.setKeyCurve(KeyID, KeyBlock[c][x][3]);
							}
						}else{
							for(x = 1; x <= SrcKeyNum[c]; x++){
								KeyID = CurChan.createKey(KeyBlock[c][x][1], KeyBlock[c][x][2]);
								CurChan.setKeyCurve(KeyID, KeyBlock[c][x][3]);
							}
						}
					}
					CurChan = CurItems[i].nextChannel();
				}
			}
			break;
// ---------------------------
		case MODE_PAIR_COPY:
			if(ItemNum == 1){
				error("<br>Pair COPY mode Need 2,4,6.. or more Pair Items");
				break;
			}

// 第一選択は末尾(ItemNum)
			TempItemNum = ItemNum >> 1;
			i = ItemNum;
			for(x = 1; x <= TempItemNum; x++){
// Srcから読み込み
				CurChan = CurItems[i].firstChannel();
				for(c = 1; c <= MaxChan; c++){
// .value()はラジアン、.getKeyValueでは度数
					CurVal[c] = CurChan.value(CurTime);
					if((KeyID = CurChan.keyExists(CurTime)) != nil){
// LS2.5だと配列に.get〜()メソッドで値を入れるとLSCoreが壊れる?。LS2.7〜では平気
						Val = CurChan.getKeyCurve(KeyID);
						CurKeyCurv[c] = Val;
					}
					CurChan = CurItems[i].nextChannel();
				}
// .value()で得たラジアンを度数に変換
				CurVal[4] = deg(CurVal[4]);
				CurVal[5] = deg(CurVal[5]);
				CurVal[6] = deg(CurVal[6]);
// フラグに応じて±反転
				for(c = 1; c <= 6; c++) if(RevFlag[c]) CurVal[c] *= -1.0;
				i--;

// Destへ書き込み
				if(LimitType && (ChgFlag[4] || ChgFlag[5] || ChgFlag[6]))
					LimitRot = getLimitRot(CurItems[i]);
				CurChan = CurItems[i].firstChannel();
				for(c = 1; c <= MaxChan; c++){
					if(ChgFlag[c]){
						if((4 <= c)&&(c <= 6)&&(LimitType)&&(LimitRot[c] != nil)){
							Val = testValMinMax(CurVal[c], LimitRot[c - 3], LimitRot[c]);
						}else{
							Val = CurVal[c];
						}
						if((KeyID = CurChan.keyExists(CurTime)) != nil) CurChan.setKeyValue(KeyID, Val);
						else KeyID = CurChan.createKey(CurTime, Val);
						if(CurKeyCurv[c] != nil) CurChan.setKeyCurve(KeyID, CurKeyCurv[c]);
					}
					CurChan = CurItems[i].nextChannel();
				}
				i--;
			}
			info(ItemNum);
			break;
		default:
			break;
	}

// 選択順を維持する為に末尾(=先頭)から選択。LimitTypeでLimitを見に行ってなければ再選択は不要
	if(LimitType && (ChgFlag[4] || ChgFlag[5] || ChgFlag[6]) && (ItemNum > 1)){
		SelectItem(CurItems[ItemNum].id);
		for(i = ItemNum - 1; i >= 1; i--) AddToSelection(CurItems[i].id);
	}
	Refresh();
	return;
}

// --------------------------------------
getKeyIDRange: Channel, StTime, EdTime
{
	var StTmpKey, EdTmpKey;
	var MakeStFlag = false;
	var MakeEdFlag = false;
// 指定時間にキーが存在しない場合ダミーキーを打つ
	if((StTmpKey = Channel.keyExists(StTime)) == nil){
		StTmpKey = Channel.createKey(StTime, 0.0);
		MakeStFlag = true;
	}
	if((EdTmpKey = Channel.keyExists(EdTime)) == nil){
		EdTmpKey = Channel.createKey(EdTime, 0.0);
		MakeEdFlag = true;
	}
	var StKeyOrder = searchKeyIDOrder(Channel,StTime);
	var EdKeyOrder = searchKeyIDOrder(Channel,EdTime);
// ダミーキーを打っていたらそれを削除
	if(MakeStFlag){
		Channel.deleteKey(StTmpKey);
		EdKeyOrder--;
	}
	if(MakeEdFlag){
		Channel.deleteKey(EdTmpKey);
		EdKeyOrder--;
	}
	return(StKeyOrder, EdKeyOrder);
}

searchKeyIDOrder: Channel, SrcTime
{
// 二分検索
	var st = 1;
	var ed = Channel.keyCount;
// 丸め値で評価しないと見えない誤差のせいで誤判定する(1.66667 > 1.66667等が成立してしまう)
	var RTime = round(SrcTime, 6);
	while(st <= ed){
// ビットシフトにしてみた(右＝ x/2 切り捨て)
//		var KeyNum = ceil((st + ed) * 0.5);
		var KeyNum = (st + ed) >> 1;
		if(RTime < round(Channel.getKeyTime(Channel.keys[KeyNum]), 6)){
			ed = KeyNum - 1;
		}else if(RTime > round(Channel.getKeyTime(Channel.keys[KeyNum]), 6)){
			st = KeyNum + 1;
		}else{
			return(KeyNum);
		}
	}
	return(nil);
}

testValMinMax: Value, MinRot, MaxRot
{
	if(Value < MinRot) return(MinRot);
	else if(Value > MaxRot) return(MaxRot);
	return(Value);
}

getLimitRot: Item
{
	var v[6];
	SelectItem(Item.id);
	LimitH();
	LimitP();
	LimitB();
	v = Item.limits(ROTATION);
	LimitH();
	LimitP();
	LimitB();
	return(v);
// LW7.5のLimit_H/P/B()は(第一)選択アイテム単体にのみ作用、LW8/9は選択中アイテム全て
// そのまま.limits()した場合、有効だとNilが返り、無効だと値が返る
// 一度反転させる事で有効(値)、無効(Nil)として取れるようになる
// Limit有効な所は値、無効な所はNilの配列 Val[6]を返す
}

changeFlagCurTime: v
{
	var EndF = getvalue(cA);
	if(v > EndF) setvalue(cA, v);
}
changeFlagEndTime: v
{
	var StartF = getvalue(c0);
	if(StartF > v) setvalue(c0, v);
}

maskItemSlot: v
{ return(false); }
maskEndFrame: v
{ return(v == 5 || v == 6); }
maskShiftFrame: v
{ return(v == 6); }
maskSelfWback: v
{ return((v == 2)||(v == 6)); }
maskInputVal6: v
{ return(v <= 5); }
maskInputVal9: v
{
	if(MaxChan == 6) return(false);
	else return(v <= 5);
}
maskInputVal: v
{ return(v != 7); }
maskScales: v
{
	if(MaxChan == 6) return(false);
	else return(true);
}

setPreStFrame
{ setvalue(c0, CurScene.previewstart); }
setPreEdFrame
{ setvalue(cA, CurScene.previewend); }

changeFlagPX: v
{ ChgFlag[1] = true; setvalue(f1, true); }
changeFlagPY: v
{ ChgFlag[2] = true; setvalue(f2, true); }
changeFlagPZ: v
{ ChgFlag[3] = true; setvalue(f3, true); }
changeFlagRH: v
{ ChgFlag[4] = true; setvalue(f4, true); }
changeFlagRP: v
{ ChgFlag[5] = true; setvalue(f5, true); }
changeFlagRB: v
{ ChgFlag[6] = true; setvalue(f6, true); }
changeFlagSX: v
{ ChgFlag[7] = true; setvalue(f7, true); }
changeFlagSY: v
{ ChgFlag[8] = true; setvalue(f8, true); }
changeFlagSZ: v
{ ChgFlag[9] = true; setvalue(f9, true); }

changeFlagPXT: v
{ ChgFlag[1] = v; }
changeFlagPYT: v
{ ChgFlag[2] = v; }
changeFlagPZT: v
{ ChgFlag[3] = v; }
changeFlagRHT: v
{ ChgFlag[4] = v; }
changeFlagRPT: v
{ ChgFlag[5] = v; }
changeFlagRBT: v
{ ChgFlag[6] = v; }
changeFlagSXT: v
{ ChgFlag[7] = v; }
changeFlagSYT: v
{ ChgFlag[8] = v; }
changeFlagSZT: v
{ ChgFlag[9] = v; }

changeFlagRevPX: v
{
	RevFlag[1] = v;
	ChgFlag[1] = v;
	setvalue(f1, v);
}
changeFlagRevPY: v
{
	RevFlag[2] = v;
	ChgFlag[2] = v;
	setvalue(f2, v);
}
changeFlagRevPZ: v
{
	RevFlag[3] = v;
	ChgFlag[3] = v;
	setvalue(f3, v);
}
changeFlagRevRH: v
{
	RevFlag[4] = v;
	ChgFlag[4] = v;
	setvalue(f4, v);
}
changeFlagRevRP: v
{
	RevFlag[5] = v;
	ChgFlag[5] = v;
	setvalue(f5, v);
}
changeFlagRevRB: v
{
	RevFlag[6] = v;
	ChgFlag[6] = v;
	setvalue(f6, v);
}

changeFlagPos
{
	ChgFlag[1] ^= 1;
	ChgFlag[2] ^= 1;
	ChgFlag[3] ^= 1;
	setvalue(f1, ChgFlag[1]);
	setvalue(f2, ChgFlag[2]);
	setvalue(f3, ChgFlag[3]);
}
changeFlagRot
{
	ChgFlag[4] ^= 1;
	ChgFlag[5] ^= 1;
	ChgFlag[6] ^= 1;
	setvalue(f4, ChgFlag[4]);
	setvalue(f5, ChgFlag[5]);
	setvalue(f6, ChgFlag[6]);
}
changeFlagScl
{
	ChgFlag[7] ^= 1;
	ChgFlag[8] ^= 1;
	ChgFlag[9] ^= 1;
	setvalue(f7, ChgFlag[7]);
	setvalue(f8, ChgFlag[8]);
	setvalue(f9, ChgFlag[9]);
}