/////////////////////////////////////////////////*/
/*　　
/*　　JavaScript Library [ UniMinna ] 
/*　　
/*　　[Minna]簡易統合版スクリプトパッケージ
/*
/*			auther : Hiroyuki Shinkai
/*			update : 2008/02/26
/*	   description : [Minna]の主要機能を取り出して1パッケージ化したスクリプト
/////////////////////////////////////////////////*/

//++++++++++++++++++++++++++++++++++++++++++++++++
//　Global
//++++++++++++++++++++++++++++++++++++++++++++++++

	var Version = "1.0.0.0";
	var Release = "20080226";
	var Name = "UniMinna";
	var Description = "The Simple JavaScript Package [ Minna ] Unified Version.";
	

//++++++++++++++++++++++++++++++++++++++++++++++++
//　Minna
//++++++++++++++++++++++++++++++++++++++++++++++++
	
	var ImportedClass = new Array();
	
	//----------------------------------------
	// 外部JavaScriptファイルをインポート
	//----------------------------------------
	function use(Target)
	{
		var TargetFile = Target.replace(/\./, "/") + ".js";
		require(TargetFile);
	}
	function require(TargetFile)
	{
		if (ImportedClass[TargetFile] != undefined) return;
		var XmlHttp = createXmlHttp();
		XmlHttp.open("GET", TargetFile, false);
		XmlHttp.send(null);
		eval(XmlHttp.responseText);
		ImportedClass[TargetFile] = TargetFile;
	}
	function resolve(Targets)
	{
		for (var i = 0; i < Targets.length; i++)
		{
			use(Targets[i]);
		}
	}

	//----------------------------------------
	// document.getElementById()のショートハンド
	//----------------------------------------
	function $(ObjName)
	{
		return document.getElementById(ObjName);
	}
	
	//----------------------------------------
	// Array.indexOf()の実装
	//----------------------------------------
	/*
	if (!Array.prototype.indexOf)
	{
		alert("add indexOf()!");
		Array.prototype.indexOf = function(elt)
		{
			for (var i = 0; i < this.length; i++)
			{
				if (this[i] === elt) return i;
			}
			return -1;
		};
	}
	*/



//++++++++++++++++++++++++++++++++++++++++++++++++
//　Minna.Query
//++++++++++++++++++++++++++++++++++++++++++++++++

	//----------------------------------------
	// 入力引数を取得しハッシュを返す
	//----------------------------------------
	function readParse(TargetQuery)
	{
		if (TargetQuery == undefined) TargetQuery = location.search.substr(1);
		var hshQuery = new Array();
		
		if (TargetQuery.length > 0) {
			var arrElem = TargetQuery.split(/&/);
			for (i in arrElem) {
				var arrQuery = arrElem[i].split(/=/);
				hshQuery[arrQuery[0]] = arrQuery[1];
			}
		}
		
		return hshQuery;
	}


//++++++++++++++++++++++++++++++++++++++++++++++++
//　Minna.Ajax
//++++++++++++++++++++++++++++++++++++++++++++++++

	//取得したデータ、通信状態を格納するハッシュ
	var HttpTextDataHash = new Object();
	var HttpXmlDataHash = new Object();
	var HttpDataReadyHash = new Object();
	var HttpStatusHash = new Object();
	
	//返却モードの定数
	var ReturnModeNone = 0;
	var ReturnModeText = 1;
	var ReturnModeXml = 2;
	var ReturnModeBoth = 3;
	var ReturnModeHttp = 4;
	
	
	//----------------------------------------
	// XMLHttpRequestオブジェクトを作成
	//----------------------------------------
	function createXmlHttp()
	{
		if (window.XMLHttpRequest)				// Mozilla, Firefox, Safari, IE7
		{
			return new XMLHttpRequest();
		}
		else if (window.ActiveXObject)			// IE5, IE6
		{
			try
			{
				return new ActiveXObject("Msxml2.XMLHTTP");    // MSXML3
			}
			catch(e)
			{
				return new ActiveXObject("Microsoft.XMLHTTP"); // MSXML2まで
			}
		}
		else
		{
			return null;
		}
	}
	
	//----------------------------------------
	// 指定URLのデータを読み込み、指定形式で返す || コールバックを実行する
	//	Param:
	//		DataId		:　データを一意に識別するID
	//		SourceURI	:　読み込み元URL
	//		[AsyncFlag]	:　同期・非同期フラグ（true：非同期通信　false：同期通信　省略時：true）
	//		[CacheFlag]	:　キャッシュフラグ（true：キャッシュIDを付加してリクエスト　false：キャッシュIDなしでリクエスト　省略時：true）
	//		[Return]	:　同期通信時の返却モード（省略時：responseText（1）　非同期通信時はXmlHttpObjectに固定）
	//		[CallBack]	:　コールバック関数（省略時：何も実行せず（ハッシュに格納するだけ））
	//		[Args]		:　コールバック関数に渡す引数（省略時：何も渡さない（XmlHttpだけ渡る））
	//----------------------------------------
	function loadData(DataID, SourceURI, AsyncFlag, CacheFlag, Return, CallBack, Args)
	{
		//既定値
		if (AsyncFlag == null) AsyncFlag = true;
		if (CacheFlag == null) CacheFlag = true;
		if (Return == null) Return = ReturnModeText;
	
		//通信オブジェクト作成
		var XmlHttp = createXmlHttp();
		if (XmlHttp == null) return false;
		
		//コールバックの設定
		HttpDataReadyHash[DataID] = false;
		var myself = this;
		XmlHttp.onreadystatechange = function() { myself.loadDataCallBack(DataID, XmlHttp, CallBack, Args) };
		
		//キャッシュID作成
		var CacheID = getCacheID();
		var RequestURI = SourceURI + ((SourceURI.indexOf("?") >= 0) ? "&cache=" : "?cache=") + CacheID;
		
    	//HTTPリクエスト実行
		XmlHttp.open("GET", RequestURI, AsyncFlag);
		XmlHttp.send(null);
		
		//値を返す
		if (AsyncFlag)
		{
			return XmlHttp;
		}
		else
		{
			if (Return == ReturnModeNone) return null;
			if (Return == ReturnModeText) return XmlHttp.responseText;
			if (Return == ReturnModeXml) return XmlHttp.responseXML;
			if (Return == ReturnModeBoth) return new Array(XmlHttp.responseText, XmlHttp.responseXml);
			if (Return == ReturnModeHttp) return XmlHttp;
		}
		
	}
	
	//----------------------------------------
	// loadDataのコールバック関数
	//----------------------------------------
	function loadDataCallBack(DataID, XmlHttp, CallBack, Args)
	{
		if (XmlHttp.readyState == 4 && XmlHttp.status == 200)
		{
			HttpTextDataHash[DataID] = XmlHttp.responseText;
			HttpXmlDataHash[DataID] = XmlHttp.responseXML;	
			HttpDataReadyHash[DataID] = true;
			
			if (CallBack != null)
			{
				if (Args != null)
				{
					CallBack(XmlHttp, Args);
				}
				else
				{
					CallBack(XmlHttp);
				}
			}
		}
		HttpStatusHash[DataID] = XmlHttp.readyState;
	}
	
	//----------------------------------------
	// CacheIDを取得
	//----------------------------------------
	function getCacheID()
	{
		return new Date().getTime().toString();
	}
	
	//----------------------------------------
	// 指定URLのデータを指定のオブジェクトに配置する
	//	Param:
	//		DataId		:　データを一意に識別するID
	//		SourceURI	:　読み込み元URL
	//		Container	:　挿入先オブジェクト
	//----------------------------------------
	function include(DataID, SourceURI, Container)
	{
		loadData(DataID, SourceURI, true, true, null, function(XmlHttp){ Container.innerHTML = XmlHttp.responseText; });
	}



//++++++++++++++++++++++++++++++++++++++++++++++++
//　Minna.Hash
//++++++++++++++++++++++++++++++++++++++++++++++++

	var DefLineDelimiter = "\n";
	var DefItemDelimiter = ",";
	var DefSpaceReplacer = "__";
	var DefCommentChar = "#";
	var DefKeyJoiner = "-";
	
	
	//----------------------------------------
	// CSV形式文字列からハッシュを作成
	//----------------------------------------
	function getCSV(CSVData, LineDelimiter, ItemDelimiter, CommentChar, KeyIndex, KeyJoiner){
		var hshCSV = new Array();
		var tmpStr;
		
		if (!CSVData) return hshCSV;
		if (CSVData.length <= 2) return hshCSV;
		tmpStr = CSVData;
		
		//キーインデックス配列とキーインデックス結合文字
		var arrKeyIndex = new Array();
		if (KeyIndex == undefined)
		{
			arrKeyIndex.push(0);
		}
		else if (!KeyIndex.length)
		{
			arrKeyIndex.push(KeyIndex);
		}
		else
		{
			for (var i = 0; i < KeyIndex.length; i++)
			{
				arrKeyIndex.push(KeyIndex[i]);
			}
		}
		if (KeyJoiner == undefined) KeyJoiner = DefKeyJoiner;
		
		//コメント文字
		if (CommentChar == undefined) CommentChar = DefCommentChar;

		//要素デリミタ
		if (ItemDelimiter == undefined) ItemDelimiter = DefItemDelimiter;
							   
		//改行置換と行デリミタ
		if (LineDelimiter == undefined) 
		{
			LineDelimiter = DefLineDelimiter;
			if (tmpStr.indexOf("\r") > 0){
				if (tmpStr.charCodeAt(tmpStr.indexOf("\r") + 1) == 10) {
					tmpStr = tmpStr.replace(/\r/g, "");
				}else{
					tmpStr = tmpStr.replace(/\r/g, "\n");
				}
			}
		}

		var arrLines = tmpStr.split(LineDelimiter);
		for (var i = 0; i < arrLines.length; i++){
			if (arrLines[i] == "") {
				continue;
			}
			if (arrLines[i] == undefined) {
				continue;
			}
			if (arrLines[i].charAt(0) == CommentChar) {
				continue;
			}
			var tmpLine = arrLines[i].replace(DefSpaceReplacer, " ");
			var arrTmp = tmpLine.split(ItemDelimiter);
			
			//キーインデックス
			var arrTmpKeyStr = new Array();
			for (var j = 0; j < arrKeyIndex.length; j++)
			{
				arrTmpKeyStr.push(arrTmp[arrKeyIndex[j]]);
			}
			var TmpKey = arrTmpKeyStr.join(KeyJoiner);
			hshCSV[TmpKey] = arrTmp;
		}
		
		return hshCSV;
	}
	
	//----------------------------------------
	// ハッシュのキーを返す
	//----------------------------------------
	function getKeys(TargetHash)
	{
		
		var arrTmp = new Array();
		var i = 0;
		for (var TmpKey in TargetHash){
			arrTmp[i] = TmpKey;
			i++;
		}
		
		return arrTmp;
	}
	
	//----------------------------------------
	// ハッシュ内のキー存在チェック
	//----------------------------------------
	function exists(TargetHash, TargetKey){
		
		return TargetHash[TargetKey] != undefined;
		/*
		for (var TmpKey in TargetHash){
			if (TmpKey == TargetKey) return true;
		}
		return false;
		*/
	}
	//----------------------------------------
	// CSV形式文字列から2次元を作成
	//----------------------------------------
	function getCSVtoArray(CSVData, LineDelimiter, ItemDelimiter, CommentChar, KeyIndex, KeyJoiner){
		var hshCSV = new Array();
		var tmpStr;
		
		if (!CSVData) return hshCSV;
		if (CSVData.length <= 2) return hshCSV;
		tmpStr = CSVData;
		
		//キーインデックス配列とキーインデックス結合文字
		var arrKeyIndex = new Array();
		if (KeyIndex == undefined)
		{
			arrKeyIndex.push(0);
		}
		else if (!KeyIndex.length)
		{
			arrKeyIndex.push(KeyIndex);
		}
		else
		{
			for (var i = 0; i < KeyIndex.length; i++)
			{
				arrKeyIndex.push(KeyIndex[i]);
			}
		}
		if (KeyJoiner == undefined) KeyJoiner = DefKeyJoiner;
		
		//コメント文字
		if (CommentChar == undefined) CommentChar = DefCommentChar;

		//要素デリミタ
		if (ItemDelimiter == undefined) ItemDelimiter = DefItemDelimiter;
							   
		//改行置換と行デリミタ
		if (LineDelimiter == undefined) 
		{
			LineDelimiter = DefLineDelimiter;
			if (tmpStr.indexOf("\r") > 0){
				if (tmpStr.charCodeAt(tmpStr.indexOf("\r") + 1) == 10) {
					tmpStr = tmpStr.replace(/\r/g, "");
				}else{
					tmpStr = tmpStr.replace(/\r/g, "\n");
				}
			}
		}

		var arrLines = tmpStr.split(LineDelimiter);
		for (var i = 0; i < arrLines.length; i++){
			if (arrLines[i] == "") {
				continue;
			}
			if (arrLines[i] == undefined) {
				continue;
			}
			if (arrLines[i].charAt(0) == CommentChar) {
				continue;
			}
			var tmpLine = arrLines[i].replace(DefSpaceReplacer, " ");
			var arrTmp = tmpLine.split(ItemDelimiter);
			
			hshCSV[i] = arrTmp;
		}
		
		return hshCSV;
	}
	

//++++++++++++++++++++++++++++++++++++++++++++++++
//　Minna.Date
//++++++++++++++++++++++++++++++++++++++++++++++++

    //月名のショートネーム配列
	var MonthName = new Array("Jan", "Feb", "Mar", "Apr",
							   "May", "Jun", "Jul", "Aug",
							   "Sep", "Oct", "Nov", "Dec" );

    //月名のロングネーム配列
	var MonthLongName = new Array("January", "February", "March", "April",
								   "May", "June", "July", "August",
								   "September", "October", "November", "December" );

    //和月の名称配列
    var MonthNameJpn = new Array("睦月", "如月", "弥生", "卯月",
								  "皐月", "水無月", "文月", "葉月",
								  "長月", "神無月", "霜月", "師走" );

    ///曜日の名称配列
    var WeekdayName = new Array("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday");

    ///曜日の和名配列（短）
    var WeekdayNameJpn = new Array("日", "月", "火", "水", "木", "金", "土");

    //曜日の和名配列（中）
    var WeekdayMiddleNameJpn = new Array("日曜", "月曜", "火曜", "水曜", "木曜", "金曜", "土曜");

    //曜日の和名配列（長）
    var WeekdayLongNameJpn = new Array("日曜日", "月曜日", "火曜日", "水曜日", "木曜日", "金曜日", "土曜日");
	
	//----- DateFormat列挙体
	var DateFormat = new Array();
	DateFormat.YYYYMMDDHHNNSS = 0;
	DateFormat.YYYYMMDDHHNN = 1;
	DateFormat.YYYYMMDDHH = 2;
	DateFormat.YYYYMMDD = 3;
	DateFormat.YYYYMM = 4;
	DateFormat.YYMMDDHHNNSS = 5;
	DateFormat.YYMMDDHHNN = 6;
	DateFormat.YYMMDDHH = 7;
	DateFormat.YYMMDD = 8;
	DateFormat.YYMM = 9;
	DateFormat.YY = 10;
	DateFormat.HHNNSS = 11;
	DateFormat.HHNN = 12;
	DateFormat.YYYYsMMsDD_HHcNNcSS = 13;
	DateFormat.YYYYsMMsDD_HHcNN = 14;
	DateFormat.YYYYsMMsDD_HH = 15;
	DateFormat.YYYYsMMsDD = 16;
	DateFormat.YYYYsMM = 17;
	DateFormat.YYsMMsDD_HHcNNcSS = 18;
	DateFormat.YYsMMsDD_HHcNN = 19;
	DateFormat.YYsMMsDD_HH = 20;
	DateFormat.YYsMMsDD = 21;
	DateFormat.YYsMM = 22;
	DateFormat.MMsDD = 23;
	DateFormat.HHcNNcSS = 24;
	DateFormat.HHcNN = 25;
	DateFormat.YYYYjMMjDDjHHjNNjSSj = 26;
	DateFormat.YYYYjMjDjHHjNNjSSj = 27;
	DateFormat.YYYYjMjDjgHjNNjSSj = 28;
	DateFormat.YYYYjMjDjHjNjSj = 29;
	DateFormat.YYYYjMjDjgHjNjSj = 30;
	DateFormat.YYYYjMMjDDjHHjNNj = 31;
	DateFormat.YYYYjMMjDDjgHjNNj = 32;
	DateFormat.YYYYjMjDjHHjNNj = 33;
	DateFormat.YYYYjMjDjHjNj = 34;
	DateFormat.YYYYjMjDjgHjNj = 35;
	DateFormat.YYYYjMMjDDjHHj = 36;
	DateFormat.YYYYjMjDjHHj = 37;
	DateFormat.YYYYjMjDjgHj = 38;
	DateFormat.YYYYjMMjDDj = 39;
	DateFormat.YYYYjMjDj = 40;
	DateFormat.YYYYjMMj = 41;
	DateFormat.YYYYjMj = 42;
	DateFormat.YYYYj = 43;
	DateFormat.MMjDDj = 44;
	DateFormat.MjDj = 45;
	DateFormat.MMj = 46;
	DateFormat.Mj = 47;
	DateFormat.DDj = 48;
	DateFormat.Dj = 49;
	DateFormat.HHjNNjSSj = 50;
	DateFormat.HjNjSj = 51;
	DateFormat.gHjNNjSSj = 52;
	DateFormat.gHjNjSj = 53;
	DateFormat.HHjNNj = 54;
	DateFormat.gHjNNj = 55;
	DateFormat.HjNj = 56;
	DateFormat.gHjNj = 57;
	DateFormat.HHj = 58;
	DateFormat.Hj = 59;
	DateFormat.gHj = 60;
	DateFormat.NNj = 61;
	DateFormat.Nj = 62;
	DateFormat.SSj = 63;
	DateFormat.Sj = 64;
	DateFormat.MmmDDYYYY = 65;
	DateFormat.MmmDDHHNN = 66;
	DateFormat.MmmDD = 67;
	DateFormat.Mmm = 68;
	DateFormat.YYYY = 69;
	DateFormat.MM = 70;
	DateFormat.DD = 71;
	DateFormat.HH = 72;
	DateFormat.NN = 73;
	DateFormat.SS = 74;
	DateFormat.Www = 75;
	DateFormat.Wwwwww = 76;
	DateFormat.Jw = 77;
	DateFormat.Jwww = 78;
	DateFormat.Jwwwww = 79;
	

	//----------------------------------------
	// 2つの時間の差を求める
	//----------------------------------------
	function dateDiff(Interval, Date1, Date2){
		var tmpNum;
		
		if (!Date1 || !Date2) return;
		
		tmpNum = Date2.getTime() - Date1.getTime();
		
		if (Interval == "s"){
			return Math.floor(tmpNum / 1000);
		}else if (Interval == "n"){
			return Math.floor(tmpNum / 1000 / 60);
		}else if (Interval == "h"){
			return Math.floor(tmpNum / 1000 / 60 / 60);
		}else if (Interval == "d"){
			return Math.floor(tmpNum / 1000 / 60 / 60 / 24);
		}else{
			return "";
		}
	}
	
	//----------------------------------------
	// 指定された時間間隔を加算した日付を求める
	//----------------------------------------
	function dateAdd(Interval, number, inDate){
		var tmpNum;
		var tmpAddNum;
		var tmpDate = new Date();
		
		if (!inDate) return;
		
		tmpNum = inDate.getTime();
		
		if (Interval == "s"){
			tmpAddNum = number * 1000;
		}else if (Interval == "n"){
			tmpAddNum = number * 1000 * 60;
		}else if (Interval == "h"){
			tmpAddNum = number * 1000 * 60 * 60;
		}else if (Interval == "d"){
			tmpAddNum = number * 1000 * 60 * 60 * 24;
		}else{
			tmpAddNum = 0;
		}
		
		tmpDate.setTime(tmpNum + tmpAddNum);
			
		return tmpDate;
		
	}
	
	//----------------------------------------
	// YYYYMMDDHHNNSSをDateに変換
	//----------------------------------------
	function strToDate(inDateStr){
	
		if (!inDateStr) return;
		
		if (inDateStr.length < 14) {
			var tmpStr = inDateStr + "00000000000000";
			inDateStr = inDateStr.substr(0, 14);
		}
		return new Date(inDateStr.substr(0, 4),
						 parseInt(inDateStr.substr(4, 2), 10) - 1,
						 inDateStr.substr(6, 2),
						 inDateStr.substr(8, 2), 
						 inDateStr.substr(10, 2), 
						 inDateStr.substr(12, 2),
						 0);
	}
	
	//----------------------------------------
	// Dateを指定書式に変換
	//----------------------------------------
	function dateToStr(date, Format){
			
		if (Format == DateFormat.YYYYMMDDHHNNSS)
        {
            return dateToStr(date, DateFormat.YYYYMMDD) + dateToStr(date, DateFormat.HHNNSS);
        }
        else if (Format == DateFormat.YYYYMMDDHHNN)
        {
            return dateToStr(date, DateFormat.YYYYMMDD) + dateToStr(date, DateFormat.HHNN);
        }
        else if (Format == DateFormat.YYYYMMDDHH)
        {
            return dateToStr(date, DateFormat.YYYYMMDD) + dateToStr(date, DateFormat.HH);
        }
        else if (Format == DateFormat.YYYYMMDD)
        {
            return dateToStr(date, DateFormat.YYYYMM) + dateToStr(date, DateFormat.DD);
        }
        else if (Format == DateFormat.YYYYMM)
        {
            return dateToStr(date, DateFormat.YYYY) + dateToStr(date, DateFormat.MM);
        }
        else if (Format == DateFormat.YYMMDDHHNNSS)
        {
            return (dateToStr(date, DateFormat.YYYYMMDDHHNNSS)).substr(2);
        }
        else if (Format == DateFormat.YYMMDDHHNN)
        {
            return (dateToStr(date, DateFormat.YYYYMMDDHHNN)).substr(2);
        }
        else if (Format == DateFormat.YYMMDDHH)
        {
            return (dateToStr(date, DateFormat.YYYYMMDDHH)).substr(2);
        }
        else if (Format == DateFormat.YYMMDD)
        {
            return (dateToStr(date, DateFormat.YYYYMMDD)).substr(2);
        }
        else if (Format == DateFormat.YYMM)
        {
            return (dateToStr(date, DateFormat.YY)) + (dateToStr(date, DateFormat.MM));
        }
        else if (Format == DateFormat.YY)
        {
            return dateToStr(date, DateFormat.YYYY).substr(2);
        }
        else if (Format == DateFormat.HHNNSS)
        {
            return dateToStr(date, DateFormat.HHNN) + dateToStr(date, DateFormat.SS);
        }
        else if (Format == DateFormat.HHNN)
        {
            return dateToStr(date, DateFormat.HH) + dateToStr(date, DateFormat.NN);
        }
        else if (Format == DateFormat.YYYYsMMsDD_HHcNNcSS)
        {
            return dateToStr(date, DateFormat.YYYYsMMsDD) + " " + dateToStr(date, DateFormat.HHcNNcSS);
        }
        else if (Format == DateFormat.YYYYsMMsDD_HHcNN)
        {
            return dateToStr(date, DateFormat.YYYYsMMsDD) + " " + dateToStr(date, DateFormat.HHcNN);
        }
        else if (Format == DateFormat.YYYYsMMsDD_HH)
        {
            return dateToStr(date, DateFormat.YYYYsMMsDD) + " " + dateToStr(date, DateFormat.HH);
        }
        else if (Format == DateFormat.YYYYsMMsDD)
        {
            return dateToStr(date, DateFormat.YYYYsMM) + "/" + dateToStr(date, DateFormat.DD);
        }
        else if (Format == DateFormat.YYYYsMM)
        {
            return dateToStr(date, DateFormat.YYYY) + "/" + dateToStr(date, DateFormat.MM);
        }
        else if (Format == DateFormat.YYsMMsDD_HHcNNcSS)
        {
            return dateToStr(date, DateFormat.YYYYsMMsDD_HHcNNcSS).substr(2);
        }
        else if (Format == DateFormat.YYsMMsDD_HHcNN)
        {
            return dateToStr(date, DateFormat.YYYYsMMsDD_HHcNN).substr(2);
        }
        else if (Format == DateFormat.YYsMMsDD_HH)
        {
            return dateToStr(date, DateFormat.YYYYsMMsDD_HH).substr(2);
        }
        else if (Format == DateFormat.YYsMMsDD)
        {
            return dateToStr(date, DateFormat.YYYYsMMsDD).substr(2);
        }
        else if (Format == DateFormat.YYsMM)
        {
            return dateToStr(date, DateFormat.YYYYsMM).substr(2);
        }
        else if (Format == DateFormat.MMsDD)
        {
            return dateToStr(date, DateFormat.MM) + "/" + dateToStr(date, DateFormat.DD);
        }
        else if (Format == DateFormat.HHcNNcSS)
        {
            return dateToStr(date, DateFormat.HHcNN) + ":" + dateToStr(date, DateFormat.SS);
        }
        else if (Format == DateFormat.HHcNN)
        {
            return dateToStr(date, DateFormat.HH) + ":" + dateToStr(date, DateFormat.NN);
        }
        else if (Format == DateFormat.YYYYjMMjDDjHHjNNjSSj)
        {
            return dateToStr(date, DateFormat.YYYYjMMjDDj) + dateToStr(date, DateFormat.HHjNNjSSj);
        }
        else if (Format == DateFormat.YYYYjMjDjHHjNNjSSj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.HHjNNjSSj);
        }
        else if (Format == DateFormat.YYYYjMjDjgHjNNjSSj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.gHjNNjSSj);
        }
        else if (Format == DateFormat.YYYYjMjDjHjNjSj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.HjNjSj);
        }
        else if (Format == DateFormat.YYYYjMjDjgHjNjSj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.gHjNjSj);
        }
        else if (Format == DateFormat.YYYYjMMjDDjHHjNNj)
        {
            return dateToStr(date, DateFormat.YYYYjMMjDDj) + dateToStr(date, DateFormat.HHjNNj);
        }
        else if (Format == DateFormat.YYYYjMMjDDjgHjNNj)
        {
            return dateToStr(date, DateFormat.YYYYjMMjDDj) + dateToStr(date, DateFormat.gHjNNj);
        }
        else if (Format == DateFormat.YYYYjMjDjHHjNNj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.HHjNNj);
        }
        else if (Format == DateFormat.YYYYjMjDjHjNj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.HjNj);
        }
        else if (Format == DateFormat.YYYYjMjDjgHjNj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.gHjNj);
        }
        else if (Format == DateFormat.YYYYjMMjDDjHHj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.HHj);
        }
        else if (Format == DateFormat.YYYYjMjDjHHj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.HHj);
        }
        else if (Format == DateFormat.YYYYjMjDjgHj)
        {
            return dateToStr(date, DateFormat.YYYYjMjDj) + dateToStr(date, DateFormat.gHj);
        }
        else if (Format == DateFormat.YYYYjMMjDDj)
        {
            return dateToStr(date, DateFormat.YYYYjMMj) + dateToStr(date, DateFormat.DDj);
        }
        else if (Format == DateFormat.YYYYjMjDj)
        {
            return dateToStr(date, DateFormat.YYYYjMj) + dateToStr(date, DateFormat.Dj);
        }
        else if (Format == DateFormat.YYYYjMMj)
        {
            return dateToStr(date, DateFormat.YYYYj) + dateToStr(date, DateFormat.MMj);
        }
        else if (Format == DateFormat.YYYYjMj)
        {
            return dateToStr(date, DateFormat.YYYYj) + dateToStr(date, DateFormat.Mj);
        }
        else if (Format == DateFormat.YYYYj)
        {
            return dateToStr(date, DateFormat.YYYY) + "年";
        }
        else if (Format == DateFormat.MMjDDj)
        {
            return dateToStr(date, DateFormat.MMj) + dateToStr(date, DateFormat.DDj);
        }
        else if (Format == DateFormat.MjDj)
        {
            return dateToStr(date, DateFormat.Mj) + dateToStr(date, DateFormat.Dj);
        }
        else if (Format == DateFormat.MMj)
        {
            return dateToStr(date, DateFormat.MM) + "月";
        }
        else if (Format == DateFormat.Mj)
        {
            return date.getMonth() + "月";
        }
        else if (Format == DateFormat.DDj)
        {
            return dateToStr(date, DateFormat.DD) + "日";
        }
        else if (Format == DateFormat.Dj)
        {
            return date.getDate() + "日";
        }
        else if (Format == DateFormat.HHjNNjSSj)
        {
            return dateToStr(date, DateFormat.HHjNNj) + dateToStr(date, DateFormat.SSj);
        }
        else if (Format == DateFormat.HjNjSj)
        {
            return dateToStr(date, DateFormat.HjNj) + dateToStr(date, DateFormat.Sj);
        }
        else if (Format == DateFormat.gHjNNjSSj)
        {
            return dateToStr(date, DateFormat.gHjNNj) + dateToStr(date, DateFormat.SSj);
        }
        else if (Format == DateFormat.gHjNjSj)
        {
            return dateToStr(date, DateFormat.gHjNj) + dateToStr(date, DateFormat.Sj);
        }
        else if (Format == DateFormat.HHjNNj)
        {
            return dateToStr(date, DateFormat.HHj) + dateToStr(date, DateFormat.NNj);
        }
        else if (Format == DateFormat.gHjNNj)
        {
            return dateToStr(date, DateFormat.gHj) + dateToStr(date, DateFormat.NNj);
        }
        else if (Format == DateFormat.HjNj)
        {
            return dateToStr(date, DateFormat.Hj) + dateToStr(date, DateFormat.Nj);
        }
        else if (Format == DateFormat.gHjNj)
        {
            return dateToStr(date, DateFormat.gHj) + dateToStr(date, DateFormat.Nj);
        }
        else if (Format == DateFormat.HHj)
        {
            return dateToStr(date, DateFormat.HH) + "時";
        }
        else if (Format == DateFormat.Hj)
        {
            return date.getHours() + "時";
        }
        else if (Format == DateFormat.gHj)
        {
            if (date.getHours() == 12)
            {
                return "午後12時";
            }
            else
            {
                return (date.getHours() < 12 ? "午前" : "午後") + (date.getHours() % 12) + "時";
            }
        }
        else if (Format == DateFormat.NNj)
        {
            return dateToStr(date, DateFormat.NN) + "分";
        }
        else if (Format == DateFormat.Nj)
        {
            return date.getMinutes().toString() + "分";
        }
        else if (Format == DateFormat.SSj)
        {
            return dateToStr(date, DateFormat.SS) + "秒";
        }
        else if (Format == DateFormat.Sj)
        {
            return date.getSeconds().toString() + "秒";
        }
        else if (Format == DateFormat.MmmDDYYYY)
        {
            return dateToStr(date, DateFormat.MmmDD) + " " + dateToStr(date, DateFormat.YYYY);
        }
        else if (Format == DateFormat.MmmDDHHNN)
        {
            return dateToStr(date, DateFormat.MmmDD) + " " + dateToStr(date, DateFormat.HH) + ":" + dateToStr(date, DateFormat.NN);
        }
        else if (Format == DateFormat.MmmDD)
        {
            return dateToStr(date, DateFormat.Mmm) + " " + dateToStr(date, DateFormat.DD);
        }
        else if (Format == DateFormat.Mmm)
        {
            return MonthName[date.getMonth()];
        }
        else if (Format == DateFormat.YYYY)
        {
            return date.getFullYear().toString();
        }
        else if (Format == DateFormat.MM)
        {
			var tmpNum = date.getMonth() + 1;
            return (tmpNum < 10 ? "0" + tmpNum.toString() : tmpNum.toString());
        }
        else if (Format == DateFormat.DD)
        {
			var tmpNum = date.getDate();
            return (tmpNum < 10 ? "0" + tmpNum.toString() : tmpNum.toString());
        }
        else if (Format == DateFormat.HH)
        {
			var tmpNum = date.getHours();
            return (tmpNum < 10 ? "0" + tmpNum.toString() : tmpNum.toString());
        }
        else if (Format == DateFormat.NN)
        {
			var tmpNum = date.getMinutes();
            return (tmpNum < 10 ? "0" + tmpNum.toString() : tmpNum.toString());
        }
        else if (Format == DateFormat.SS)
        {
			var tmpNum = date.getSeconds();
            return (tmpNum < 10 ? "0" + tmpNum.toString() : tmpNum.toString());
        }
        else if (Format == DateFormat.Www)
        {
            return dateToStr(date, DateFormat.Wwwwww).substr(0, 3);
        }
        else if (Format == DateFormat.Wwwwww)
        {
            return WeekdayName[date.getDay()];
        }
        else if (Format == DateFormat.Jw)
        {
            return WeekdayNameJpn[date.getDay()];
        }
        else if (Format == DateFormat.Jwww)
        {
            return WeekdayMiddleNameJpn[date.getDay()];
        }
        else if (Format == DateFormat.Jwwwww)
        {
            return WeekdayLongNameJpn[date.getDay()];
        }
        else
        {
            return "";
        }
	}
	
	
//++++++++++++++++++++++++++++++++++++++++++++++++
//　Minna.Effect
//++++++++++++++++++++++++++++++++++++++++++++++++

	//----------------------------------------
	// オブジェクトの透明度を設定（0～1）
	//----------------------------------------
	function setOpacity(Target, Value) {
		if (Target) {
			Target.style.opacity = Value;
			Target.style.filter = "alpha(opacity=" + Value * 100 + ")";
			Target.style.MozOpacity = Value;
		}
	}