// ★コメント未記入

/*-----------------------------------------------------------------------------
[名称]	Common.cpp
[概要]	汎用関数 実装
[備考]	なし
[履歴]	2003-11-08	b031130 (3146)関数追加(moralog)
		2003-11-12	b031130 (3146)関数追加(dincom)
		2003-12-28	b031228 (3146)関数名称変更(dincom)
		2004-01-30	b031228 (3367)Grep検索(dincom)
		2004-05-10	b031228 (3204)へぼぺとの連携(moralog)
		2004-05-10	b031228 (3751)文書名がショートファイルネームで表示される(moralog)
-----------------------------------------------------------------------------*/
#include "stdafx.h"
#define Common
#include "Common.h"
#include "Shlwapi.h"
#include <atlbase.h>
#include <direct.h>
#include <shlobj.h> // use shell32.lib

// 参考になるWebページ
// MFC Programming Note（全般）
// http://www.aa.wakwak.com/~dragoon/mfctop.htm


/*-----------------------------------------------------------------------------
[名称]	LastError(Win32API)出力
[機能]	LastErrorが存在すればメッセージボックスを表示する。
[戻値]	なし
[備考]	なし
-----------------------------------------------------------------------------*/
void PrintLastErr(
	CString strCaption	// I: ダイアログキャプション [-] ("":デフォルトキャプション、それ以外:指定文字列) :""
)
{
	if ( strCaption.IsEmpty() )
	{
		strCaption = "したらびあん ランタイムエラー";
	}

	DWORD	dwErr = GetLastError();

	if ( dwErr != NO_ERROR )
	{
		char* lpMsgBuf;
		FormatMessage(
			FORMAT_MESSAGE_ALLOCATE_BUFFER |
			FORMAT_MESSAGE_FROM_SYSTEM |
			FORMAT_MESSAGE_IGNORE_INSERTS,
			NULL,
			dwErr,
			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // 既定の言語
			(LPTSTR) &lpMsgBuf,
			0,
			NULL
		);
		// 文字列を表示する。
		::MessageBox(NULL, (LPCTSTR)lpMsgBuf, strCaption, MB_OK | MB_ICONINFORMATION);
		// バッファを解放する。
		LocalFree(lpMsgBuf);
	}
}


/*-----------------------------------------------------------------------------
[名称]	文字列→文字列リスト分割
[機能]	文字列を区切り文字で複数行に分割しリストに格納する。
[戻値]	long 分割行数 [行] (-)
[備考]	なし
-----------------------------------------------------------------------------*/
long	StringToList(
	CString&		strLinez,		// I: 対象文字列 [-] (-) :-
	CStringList*	plstLinez,		// O: 行格納リスト [-] (-) :-
	CString&		strReturn		// I: 区切り文字 [-] (-) :-
){
	plstLinez->RemoveAll();

	int		nRow = 0;
	int		idxOffset = 0;
	int		idxReturn = 0;
	BOOL	bReturnEnd = FALSE;
	while( strLinez.GetLength() > idxOffset )
	{
		nRow++;

		idxReturn = strLinez.Find( strReturn, idxOffset );
		if ( idxReturn >= 0 )
		{
			plstLinez->AddTail( strLinez.Mid( idxOffset, idxReturn-idxOffset ) );
			bReturnEnd = TRUE;
		}
		else
		{
			plstLinez->AddTail( strLinez.Right( strLinez.GetLength()-idxOffset ) );
			bReturnEnd = FALSE;
			break;
		}

		idxOffset = idxReturn + strReturn.GetLength();
	}
	if ( bReturnEnd )
	{
		// 最後の行の末尾が改行の場合、最後に空白行を追加
		CString		strLine;
		plstLinez->AddTail( strLine );
		nRow++;
	}

	return( nRow );
}




/*-----------------------------------------------------------------------------
[名称]	文字列→文字列アレイ分割
[機能]	文字列を区切り文字で複数行に分割しアレイに格納する。
[戻値]	long 分割行数 [行] (-)
[備考]	なし
-----------------------------------------------------------------------------*/
long	StringToArray(
	CString&		strLinez,		// I: 対象文字列 [-] (-) :-
	CStringArray*	paLinez,		// O: 行格納アレイ [-] (-) :-
	CString&		strReturn		// I: 区切り文字 [-] (-) :-
){
	paLinez->RemoveAll();

	int		nRow = 0;
	int		idxOffset = 0;
	int		idxReturn = 0;
	BOOL	bReturnEnd = FALSE;
	while( strLinez.GetLength() > idxOffset )
	{
		nRow++;

		idxReturn = strLinez.Find( strReturn, idxOffset );
		CString		strLine;
		if ( idxReturn >= 0 )
		{
			strLine = strLinez.Mid( idxOffset, idxReturn-idxOffset );
			paLinez->Add( strLine );
			bReturnEnd = TRUE;
		}
		else
		{
			strLine = strLinez.Right( strLinez.GetLength()-idxOffset );
			paLinez->Add( strLine );
			bReturnEnd = FALSE;
			break;
		}

		idxOffset = idxReturn + strReturn.GetLength();
	}
	if ( bReturnEnd )
	{
		// 最後の行の末尾が改行の場合、最後に空白行を追加
		CString		strLine;
		paLinez->Add( strLine );
		nRow++;
	}

	return( nRow );
}


// ▼ (3204) BGN 2004.05.10 (moralog) ランチャツールバー追加
/*-----------------------------------------------------------------------------
[名称]	文字列分割
[機能]	文字列を区切り文字部分で分割する。
[戻値]	long	要素個数 [-] (0-)
[備考]
	文字列を区切り文字部分で分割する
	クォーテーションにくくられた部分は分割しない
	エスケープシーケンスを考慮していない
-----------------------------------------------------------------------------*/
long	StringToArrayWithQuoteCare(
	CString&		strLinez,		// I: 対象文字列 [-] (-) :-
	CStringArray*	paLinez,		// O: 行格納アレイ [-] (-) :-
	CString&		strSepalater	// I: 区切り文字 [-] (-) :-
){
	paLinez->RemoveAll();

	long	nLine( 0 );
	long	idxStart( 0 );
	long	idxChar( 0 );
	BOOL	bBlank( TRUE );
	BOOL	bQuote( FALSE );
	LPCTSTR	strSrc = (LPCTSTR)strLinez;
	while( 1 )
	{
		// 文字列末尾確認
		if ( strSrc[ idxChar ] == 0x00 )
		{
			if ( !bBlank )
			{
				CString		str1 = strLinez.Mid( idxStart, idxChar-idxStart );
				paLinez->Add( str1 );
			}
			break;
		}

		// 区切り文字確認
		if ( !bQuote )
		if ( strSrc[ idxChar ] == ' ' )
		{
			if ( bBlank )
			{
				idxChar++;
				continue;
			}

			// 区切りの空白発見に付き、ココまでを登録
			CString		str1 = strLinez.Mid( idxStart, idxChar-idxStart );
			paLinez->Add( str1 );
			idxChar++;
			bBlank = TRUE;
			continue;
		}

		// 空白以外文字開始？
		if ( bBlank )
		{
			idxStart = idxChar;
			bBlank = FALSE;
		}

		// クオーテーション存在確認
		if ( strSrc[ idxChar ] == '\"' )
		{
			bQuote = !bQuote;
		}

		// 次の文字へ
		if ( isleadbyte( strSrc[ idxChar ] ) )
		{
		// マルチバイト
			idxChar += 2;
		}
		else
		{
			idxChar++;
		}
	}

	return( paLinez->GetSize() );
}
// ▲ (3204) END






CString	BoolToString(
	BOOL	bValue
)
{
	if( bValue )
	{
		return( "TRUE" );
	}
	else
	{
		return( "FALSE" );
	}
}

BOOL	StringToBool(
	CString	strValue
)
{
	strValue.MakeUpper();
	strValue.TrimLeft();
	strValue.TrimRight();
	if( strValue == "TRUE" )
	{
		return( TRUE );
	}
	else
	{
		return( FALSE );
	}
}


BOOL	MaruBatuToBool(
	CString&	strValue
)
{
	strValue.MakeUpper();
	strValue.TrimLeft();
	strValue.TrimRight();
	if( strValue == "○" )
	{
		return( TRUE );
	}
	else
	{
		return( FALSE );
	}
}

CString	BoolToMaruBatu(
	BOOL	bValue
)
{
	if ( bValue )
	{
		return("○");
	}
	return("×");
}


CString	LongToString(
	long	lValue
)
{
	CString	str;
	str.Format("%d", lValue);
	return( str );
}

long	StringToLong(
	CString	strValue
)
{
	return( atol( strValue ) );
}

CString	ColorrefToString(
	COLORREF	colValue
)
{
	CString	str;
	str.Format("#%06X", (int)colValue);
	return( str );
}

COLORREF	StringToColorref(
	CString		strValue
)
{
	int		iValue = 0;

	::sscanf( strValue, "#%06X", &iValue );
	return( (COLORREF)(iValue) );
}

CString	DeQuoteString(
	CString&	strValue
)
{
//	strValue.TrimLeft();
//	strValue.TrimRight();

	int		idxStart = strValue.Find( '\"' ) + 1;
	int		idxEnd = strValue.ReverseFind ( '\"' );

	if( idxStart>0 )
	if( idxEnd>0 )
	if( idxStart<=idxEnd )
	{
		strValue = strValue.Mid(
			idxStart,
			idxEnd - idxStart
		);
	}
	return( strValue );
}


CString	QuoteString(
	CString&	strValue
)
{
	CString	str;
	str.Format("\"%s\"", strValue);
	return( str );
}

/*
CString		IniFilePath()
{
	int	iLength = strlen( __argv[0] );

	CString		strFilename = __argv[0];
	int	idxLastSlash = strFilename.ReverseFind( '\\' );
	strFilename = strFilename.Left( idxLastSlash+1 );

	return( strFilename );
}
*/


BOOL WriteGeneralProfile(
	CString&			strFilename,
	const char*			strKey,
	const char*			strValue
)
{
	BOOL	bSuccess;
	bSuccess = WritePrivateProfileString(
		"General",
		strKey,
		strValue,
		strFilename
	);

	return( bSuccess );
}
/*
BOOL WriteFontProfile(
	CString&			strFilename,
	const char*			strKey,
	const char*			strValue
)
{
	BOOL	bSuccess;
	bSuccess = WritePrivateProfileString(
		"Font",
		strKey,
		strValue,
		strFilename
	);

	return( bSuccess );
}
*/
BOOL WritePrintProfile(
	CString&			strFilename,
	const char*			strKey,
	const char*			strValue
)
{
	BOOL	bSuccess;
	bSuccess = WritePrivateProfileString(
		"Print",
		strKey,
		strValue,
		strFilename
	);

	return( bSuccess );
}

BOOL WriteProfile(
	CString&			strFilename,
	const char*			strSection,
	const char*			strKey,
	const char*			strValue
)
{
	BOOL	bSuccess;
	bSuccess = WritePrivateProfileString(
		strSection,
		strKey,
		strValue,
		strFilename
	);

	return( bSuccess );
}


BOOL	ReadGeneralProfile(
	CString&			strFilename,
	const char*			strKey,
	CString*			pstrValue
)
{
	const 	PROFILE_LINE_SIZE = 512;
	char	aBuffer[ PROFILE_LINE_SIZE+1 ];
	aBuffer[ 0 ] = 0x00;
	BOOL	bSuccess = GetPrivateProfileString(
		"General",
		strKey,
		"",
		aBuffer,
		PROFILE_LINE_SIZE,
		strFilename
	);
	*pstrValue = aBuffer;

	return( bSuccess );
}
/*
BOOL	ReadFontProfile(
	CString&			strFilename,
	const char*			strKey,
	CString*			pstrValue
)
{
	const 	PROFILE_LINE_SIZE = 512;
	char	aBuffer[ PROFILE_LINE_SIZE+1 ];
	aBuffer[ 0 ] = 0x00;
	BOOL	bSuccess = GetPrivateProfileString(
		"Font",
		strKey,
		"",
		aBuffer,
		PROFILE_LINE_SIZE,
		strFilename
	);
	*pstrValue = aBuffer;

	return( bSuccess );
}
*/

BOOL	ReadPrintProfile(
	CString&			strFilename,
	const char*			strKey,
	CString*			pstrValue
)
{
	const 	PROFILE_LINE_SIZE = 512;
	char	aBuffer[ PROFILE_LINE_SIZE+1 ];
	aBuffer[ 0 ] = 0x00;
	BOOL	bSuccess = GetPrivateProfileString(
		"Print",
		strKey,
		"",
		aBuffer,
		PROFILE_LINE_SIZE,
		strFilename
	);
	*pstrValue = aBuffer;

	return( bSuccess );
}

BOOL	ReadProfile(
	CString&			strFilename,
	const char*			strSection,
	const char*			strKey,
	CString*			pstrValue
)
{
	const 	PROFILE_LINE_SIZE = 512;
	char	aBuffer[ PROFILE_LINE_SIZE+1 ];
	aBuffer[ 0 ] = 0x00;
	BOOL	bSuccess = GetPrivateProfileString(
		strSection,
		strKey,
		"",
		aBuffer,
		PROFILE_LINE_SIZE,
		strFilename
	);
	*pstrValue = aBuffer;

	return( bSuccess );
}
//***************************************************************************
// 汎用関数
//***************************************************************************

/****************************************************************************
[名称]
	色数判定
[概要]
	ビット深度からサポート色数を計算する。
[引数]
	iColorBits			<I> - ビット深度 [-] ( - )
[戻り値]
	int - 色数 [-] （-）
[備考]
	なし
****************************************************************************/
int BitCountToColorCount(const int& iColorBits)
{
	int iNColor;
	switch ( iColorBits )
	{
	case  1:
		iNColor = 2;
		break;
	case  4:
		iNColor = 16;
		break;
	case  8:
		iNColor = 256;
		break;
	case 15:
	case 16:
	case 24:
	case 32:
		iNColor	= 0;
		break;
	default:
		iNColor = 2;
		break;
	}
	return iNColor;
}


int StringToStringArray(
	CString& strLine,
	CStringArray* aCharz
){
	aCharz->RemoveAll();

	CString		str = strLine;

	while( TRUE )
	{
		int	idx = str.Find('/');
		if ( idx < 0 )
		{
			break;
		}

		CString		strToken = str.Left( idx );
		strToken.Replace( "\\0", "/" );
		strToken.Replace( "\\\\", "\\" );
		aCharz->Add( strToken );

		str = str.Mid( idx+1 );
	}

	return( aCharz->GetSize() );
}

CString StringArrayToString(
	CStringArray& aCharz
){
	CString		str;

	for( int idxItem=0 ; idxItem<aCharz.GetSize() ; idxItem++ )
	{
		CString		strToken = aCharz[ idxItem ];
		strToken.Replace( "\\", "\\\\" );
		strToken.Replace( "/", "\\0"  );

		str += strToken;
		str += "/";
	}

	return( str );
}





	typedef struct
	{
		const char*		pszName;
		int				iKey;
		const char*		pszNickname;
	} TKeyString;

	TKeyString atKeyString[] =
	{
		{ "VK_LBUTTON"        ,0x01, ""				},
		{ "VK_RBUTTON"        ,0x02, ""				},
		{ "VK_CANCEL"         ,0x03, ""				},
		{ "VK_MBUTTON"        ,0x04, "" /* NOT contiguous with L & RBUTTON */},

		{ "VK_BACK"           ,0x08, "BSｷｰ"			},
		{ "VK_TAB"            ,0x09, "TABｷｰ"		},

		{ "VK_CLEAR"          ,0x0C, ""				},
		{ "VK_RETURN"         ,0x0D, "ﾘﾀｰﾝｷｰ"		},

		{ "VK_SHIFT"          ,0x10, "Shift"		},
		{ "VK_CONTROL"        ,0x11, "Ctrlｷｰ"		},
		{ "VK_MENU"           ,0x12, "Altｷｰ"		},
		{ "VK_PAUSE"          ,0x13, ""				},
		{ "VK_CAPITAL"        ,0x14, ""				},

		{ "VK_KANA"           ,0x15, ""				},
		{ "VK_HANGEUL"        ,0x15, ""  /* old name - should be here for compatibility */},
		{ "VK_HANGUL"         ,0x15, ""				},
		{ "VK_JUNJA"          ,0x17, ""				},
		{ "VK_FINAL"          ,0x18, ""				},
		{ "VK_HANJA"          ,0x19, ""				},
		{ "VK_KANJI"          ,0x19, ""				},

		{ "VK_ESCAPE"         ,0x1B, "ESCｷｰ"		},

		{ "VK_CONVERT"        ,0x1C, ""				},
		{ "VK_NONCONVERT"     ,0x1D, ""				},
		{ "VK_ACCEPT"         ,0x1E, ""				},
		{ "VK_MODECHANGE"     ,0x1F, ""				},

		{ "VK_SPACE"          ,0x20, "ｽﾍﾟｰｽｷｰ"		},
		{ "VK_PRIOR"          ,0x21, "PageUpｷｰ"		},
		{ "VK_NEXT"           ,0x22, "PageDownｷｰ"	},
		{ "VK_END"            ,0x23, "ENDｷｰ"		},
		{ "VK_HOME"           ,0x24, "HOMEｷｰ"		},
		{ "VK_LEFT"           ,0x25, "←ｷｰ"			},
		{ "VK_UP"             ,0x26, "↑ｷｰ"			},
		{ "VK_RIGHT"          ,0x27, "→ｷｰ"			},
		{ "VK_DOWN"           ,0x28, "↓ｷｰ"			},
		{ "VK_SELECT"         ,0x29, ""				},
		{ "VK_PRINT"          ,0x2A, "Printｷｰ"		},
		{ "VK_EXECUTE"        ,0x2B, ""				},
		{ "VK_SNAPSHOT"       ,0x2C, ""				},
		{ "VK_INSERT"         ,0x2D, "INSｷｰ"		},
		{ "VK_DELETE"         ,0x2E, "DELｷｰ"		},
		{ "VK_HELP"           ,0x2F, ""				},

		{ "VK_LWIN"           ,0x5B, ""				},
		{ "VK_RWIN"           ,0x5C, ""				},
		{ "VK_APPS"           ,0x5D, ""				},

		{ "VK_NUMPAD0"        ,0x60, "ﾃﾝｷｰ0"		},
		{ "VK_NUMPAD1"        ,0x61, "ﾃﾝｷｰ1"		},
		{ "VK_NUMPAD2"        ,0x62, "ﾃﾝｷｰ2"		},
		{ "VK_NUMPAD3"        ,0x63, "ﾃﾝｷｰ3"		},
		{ "VK_NUMPAD4"        ,0x64, "ﾃﾝｷｰ4"		},
		{ "VK_NUMPAD5"        ,0x65, "ﾃﾝｷｰ5"		},
		{ "VK_NUMPAD6"        ,0x66, "ﾃﾝｷｰ6"		},
		{ "VK_NUMPAD7"        ,0x67, "ﾃﾝｷｰ7"		},
		{ "VK_NUMPAD8"        ,0x68, "ﾃﾝｷｰ8"		},
		{ "VK_NUMPAD9"        ,0x69, "ﾃﾝｷｰ9"		},
		{ "VK_MULTIPLY"       ,0x6A, "ﾃﾝｷｰ*"		},
		{ "VK_ADD"            ,0x6B, "ﾃﾝｷｰ+"		},
		{ "VK_SEPARATOR"      ,0x6C, ""				},
		{ "VK_SUBTRACT"       ,0x6D, "ﾃﾝｷｰ-"		},
		{ "VK_DECIMAL"        ,0x6E, ""				},
		{ "VK_DIVIDE"         ,0x6F, "ﾃﾝｷｰ/"		},
		{ "VK_F1"             ,0x70, "F1ｷｰ"				},
		{ "VK_F2"             ,0x71, "F2ｷｰ"				},
		{ "VK_F3"             ,0x72, "F3ｷｰ"				},
		{ "VK_F4"             ,0x73, "F4ｷｰ"				},
		{ "VK_F5"             ,0x74, "F5ｷｰ"				},
		{ "VK_F6"             ,0x75, "F6ｷｰ"				},
		{ "VK_F7"             ,0x76, "F7ｷｰ"				},
		{ "VK_F8"             ,0x77, "F8ｷｰ"				},
		{ "VK_F9"             ,0x78, "F9ｷｰ"				},
		{ "VK_F10"            ,0x79, "F10ｷｰ"				},
		{ "VK_F11"            ,0x7A, "F11ｷｰ"				},
		{ "VK_F12"            ,0x7B, "F12ｷｰ"				},
		{ "VK_F13"            ,0x7C, "F13ｷｰ"				},
		{ "VK_F14"            ,0x7D, "F14ｷｰ"				},
		{ "VK_F15"            ,0x7E, "F15ｷｰ"				},
		{ "VK_F16"            ,0x7F, "F16ｷｰ"				},
		{ "VK_F17"            ,0x80, "F17ｷｰ"				},
		{ "VK_F18"            ,0x81, "F18ｷｰ"				},
		{ "VK_F19"            ,0x82, "F19ｷｰ"				},
		{ "VK_F20"            ,0x83, "F20ｷｰ"				},
		{ "VK_F21"            ,0x84, "F21ｷｰ"				},
		{ "VK_F22"            ,0x85, "F22ｷｰ"				},
		{ "VK_F23"            ,0x86, "F23ｷｰ"				},
		{ "VK_F24"            ,0x87, "F24ｷｰ"				},
		{ "VK_NUMLOCK"        ,0x90, "NumLockｷｰ"	},
		{ "VK_SCROLL"         ,0x91, "ScrollRockｷｰ"	},
		{ "VK_LSHIFT"         ,0xA0, "左Shiftｷｰ"				},
		{ "VK_RSHIFT"         ,0xA1, "右Shiftｷｰ"				},
		{ "VK_LCONTROL"       ,0xA2, "左Ctrlｷｰ"				},
		{ "VK_RCONTROL"       ,0xA3, "右Ctrlｷｰ"				},
		{ "VK_LMENU"          ,0xA4, "左Altｷｰ"				},
		{ "VK_RMENU"          ,0xA5, "右Altｷｰ"				},
		{ "VK_ATTN"           ,0xF6, ""				},
		{ "VK_CRSEL"          ,0xF7, ""				},
		{ "VK_EXSEL"          ,0xF8, ""				},
		{ "VK_EREOF"          ,0xF9, ""				},
		{ "VK_PLAY"           ,0xFA, ""				},
		{ "VK_ZOOM"           ,0xFB, ""				},
		{ "VK_NONAME"         ,0xFC, ""				},
		{ "VK_PA1"            ,0xFD, ""				},
		{ "VK_OEM_CLEAR"      ,0xFE, ""				},
	};
CString		VKToString(
	int		iKey
)
{
	int		idxKey;
	for( idxKey=0 ; idxKey<sizeof(atKeyString)/sizeof(TKeyString) ; idxKey++ )
	{
		if ( atKeyString[idxKey].iKey == iKey )
		{
			return( atKeyString[idxKey].pszName );
		}
	}
	return( (char)iKey );
}

CString		VKToNickname(
	int		iKey
)
{
	int		idxKey;
	for( idxKey=0 ; idxKey<sizeof(atKeyString)/sizeof(TKeyString) ; idxKey++ )
	{
		if ( atKeyString[idxKey].iKey == iKey )
		{
			return( atKeyString[idxKey].pszNickname );
		}
	}
	return( (char)iKey );
}

int		StringToVK(
	CString		strKey
)
{
	int		idxKey;
	for( idxKey=0 ; idxKey<sizeof(atKeyString)/sizeof(TKeyString) ; idxKey++ )
	{
		if ( strcmp( atKeyString[idxKey].pszName, strKey ) == 0 )
		{
			return( atKeyString[idxKey].iKey );
		}
	}
	if( !strKey.IsEmpty() )
	{
		return( strKey[0] );
	}
	return( '?' );
}



long HexToLong(
	const CString&	strHex
)
{
	long	lValue = 0;
	for( int idxChar=0 ; idxChar<strHex.GetLength() ; idxChar++ )
	{
		char n = strHex[idxChar];
		if ( '0' <= n && n <= '9' )
		{
			lValue = lValue*16 + n-'0';
		}
		else
		if ( 'a' <= n && n <= 'z' )
		{
			lValue = lValue*16 + n-'a'+10;
		}
		else
		if ( 'A' <= n && n <= 'Z' )
		{
			lValue = lValue*16 + n-'A'+10;
		}
		else
		{
			return( 0 );
		}
	}
	return( lValue );
}



CString		DayOfWeek(
	int		iDay
)
{
	CString strDayOfWeek;
	switch( iDay )
	{
	case 1:
		strDayOfWeek = "日";
		break;
	case 2:
		strDayOfWeek = "月";
		break;
	case 3:
		strDayOfWeek = "火";
		break;
	case 4:
		strDayOfWeek = "水";
		break;
	case 5:
		strDayOfWeek = "木";
		break;
	case 6:
		strDayOfWeek = "金";
		break;
	case 7:
		strDayOfWeek = "土";
		break;
	default:
		strDayOfWeek = "";
		break;
	}
	return( strDayOfWeek );
}










BOOL DIBStretchBlt(
	CDC*		pdcDst,
	CRect&		rcDst,
	CDC*		pdcSrc,
	CBitmap*	pbmpSrc,
	CRect&		rcSrc
)
{
	{
		BITMAP	tBitmap;
		::GetObject( (HBITMAP)(*pbmpSrc), sizeof(BITMAP), &tBitmap );

		// BITMAPINFO取得
		BITMAPINFO	tBitmapInfo;
		tBitmapInfo.bmiHeader.biSize = sizeof( BITMAPINFOHEADER );

        memset( &tBitmapInfo, 0, sizeof(tBitmapInfo) );

        tBitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
        tBitmapInfo.bmiHeader.biWidth = tBitmap.bmWidth;
        tBitmapInfo.bmiHeader.biHeight = tBitmap.bmHeight;
        tBitmapInfo.bmiHeader.biPlanes = tBitmap.bmPlanes;
        tBitmapInfo.bmiHeader.biBitCount = tBitmap.bmBitsPixel;

		int iResult = ::GetDIBits(
			pdcSrc->m_hDC,				// handle to device context
			(HBITMAP)(*pbmpSrc),		// handle to bitmap
			0,
			tBitmap.bmHeight,			// number of scan lines to copy
			NULL,						// address of array for bitmap bits
			&tBitmapInfo,				// address of structure with bitmap data
			DIB_RGB_COLORS				// RGB or palette index
		);
		if ( iResult == 0 )
		{
			return( FALSE );
		}

		UINT		uiColorFlag;
		switch ( tBitmapInfo.bmiHeader.biBitCount )
		{
		case 1:
			uiColorFlag = DIB_PAL_COLORS;
			// ごめん、未対応。RGBQUAD用意するのがめんどくさい。
			return( FALSE );
			break;

		default:
			uiColorFlag = DIB_RGB_COLORS;
			break;
		}

		int		iWidth = tBitmapInfo.bmiHeader.biWidth;
		int		iHeight = tBitmapInfo.bmiHeader.biHeight;
		int		iDepth = tBitmapInfo.bmiHeader.biBitCount;

		long	nBit = iWidth * iHeight * iDepth;
		char* pBitmapBits = new char[ nBit + sizeof(BITMAPFILEHEADER) ];

		// BITMAPINFO取得
		iResult = ::GetDIBits(
			pdcSrc->m_hDC,				// handle to device context
			(HBITMAP)(*pbmpSrc),		// handle to bitmap
			0,
			tBitmapInfo.bmiHeader.biHeight,
			pBitmapBits,				// address of array for bitmap bits
			&tBitmapInfo,				// address of structure with bitmap data
			uiColorFlag					// RGB or palette index
		);
		if ( iResult == 0 )
		{
			delete [] pBitmapBits;
			return( FALSE );
		}

		::StretchDIBits(
			pdcDst->m_hDC,			// handle to device context
			rcDst.left,				// x-coordinate of upper-left 
			rcDst.top,				// y-coordinate of upper-left 
			rcDst.Width(),			// width of destination rectangle
			rcDst.Height(),			// height of destination rectangle
			rcSrc.left,				// x-coordinate of upper-left 
			rcSrc.top,				// y-coordinate of upper-left 
			rcSrc.Width(),			// width of source rectangle
			rcSrc.Height(),			// height of source rectangle
			pBitmapBits,			// address of bitmap bits
			&tBitmapInfo,
			DIB_RGB_COLORS,
			SRCCOPY
		);

		delete [] pBitmapBits;
	}
	return( TRUE );
}


CString		PathFromPathName(
	CString&	strPathName
)
{
	int	idxLastSlash = strPathName.ReverseFind( '\\' );
//	int	idxLastDot = strPathName.ReverseFind( '.' );

	return( strPathName.Left( idxLastSlash+1 ) );
}


CString		FilenameFromPathName(
	CString&	strPathName
)
{
	int	idxLastSlash = strPathName.ReverseFind( '\\' );
	int	idxLastDot = strPathName.ReverseFind( '.' );

	return( strPathName.Mid( idxLastSlash+1, idxLastDot-idxLastSlash-1 ) );
}


CString		ExtFromPathName(
	CString&	strPathName
)
{
//	int	idxLastSlash = strPathName.ReverseFind( '\\' );
	int	idxLastDot = strPathName.ReverseFind( '.' );

	return( strPathName.Mid( idxLastDot+1 ) );
}


/*-----------------------------------------------------------------------------
[名称]	フォルダ構築
[機能]	指定フォルダが存在しなければ新たに作る。
[戻値]	BOOL	処理結果 [-] (TRUE:成功、FALSE:失敗)
[備考]	１階層しか対応していない。
-----------------------------------------------------------------------------*/
BOOL	PrepareFolder(
	CString&	strFolderName
)
{
	if( strFolderName.IsEmpty() )
	{
		return( FALSE );
	}

	// 存在確認
	CFileStatus		tStatus;
	BOOL	bExists = CFile::GetStatus(
		strFolderName,
		tStatus
	);
	if ( bExists )
	{
		if ( (tStatus.m_attribute | 0x10) == 0 )
		{
			// 同名のファイルが存在する
			return FALSE;
		}
	}
	else
	{
		// フォルダの作成
		if ( _mkdir( strFolderName ) != 0 )
		{
			// エラー
//			::ErrorLog(
//				"フォルダ作成に失敗",
//				"::PrepareFolder()"
//			);
			return( FALSE );
		}
	}

	return( TRUE );
}




// http://cgi23.plala.or.jp/a-w-h/mfc/deldir.html
/*-------------------------------------------------------------------------------/

  関数名：BOOL DeleteDirectory(LPCTSTR lpPathName)
  引　数：lpPathName　削除するディレクトリのパス名が入ったNULLで終わる文字列。
　戻り値：関数が成功すると、0以外の値が返り、関数が失敗すると、0が返ります。
  解　説：ディレクトリを丸ごと削除する。

/-------------------------------------------------------------------------------*/
BOOL DeleteDirectory(LPCTSTR lpPathName)
{
    CFileFind fnd;
    CString strPathName = lpPathName;
    strPathName.TrimRight('\\');
    strPathName += _T("\\*.*");
    if(fnd.FindFile(strPathName, 0))
    {
        int i = 1;
        while(i)
        {
            i = fnd.FindNextFile();

            // ファイル名が"."か".."の場合は次を検索
            if(fnd.IsDots())
                continue;

            // 削除するファイル名取得
            // GetFilePath()にはバグがあり正確に取得できない場合があるので使わない
            CString strDeleteFile = lpPathName;
            strDeleteFile.TrimRight('\\');
            strDeleteFile += _T("\\") + fnd.GetFileName();

            // フォルダだった場合、再帰呼び出しでそのフォルダを削除
            if(fnd.IsDirectory())
                DeleteDirectory(strDeleteFile);

            // ファイルの削除
            else
                ::DeleteFile(strDeleteFile);
        }
        fnd.Close();

        // フォルダの削除
        return ::RemoveDirectory(lpPathName);
    }
    return FALSE;
}





// http://www.hidecnet.ne.jp/~sinzan/tips/win/win_tip0b.htm
BOOL SaveShellLink( IShellLink *psl, const WCHAR *wcLinkName, BOOL bRemember );
//*********************************************************
// ショートカットファイルを作成する
//     LinkFile ……… ショートカットファイルの名前(*.lnk)
//   TargetFile ……… リンク先
//    Arguments ……… コマンドライン引数
//      WorkDir ……… 作業ディレクトリ
//      ShowCmd ……… 実行時の大きさ
//*********************************************************
BOOL CreateShellLink( const char *LinkFile, const char *TargetFile, const char *Arguments, const char *WorkDir, int ShowCmd )
{
	IShellLink *psl;
	WCHAR       wcLinkFile[MAX_PATH+1];

	CoInitialize( NULL );
	if ( S_OK == CoCreateInstance( CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl ) )
	{
		psl->SetPath( TargetFile );                           // リンク先を設定
		if ( Arguments ) psl->SetArguments( Arguments );      // コマンドライン引数を設定
		if ( WorkDir   ) psl->SetWorkingDirectory( WorkDir ); // 作業フォルダを設定
		psl->SetShowCmd( ShowCmd );                           // 実行時の大きさを設定

		MultiByteToWideChar( CP_ACP, 0, LinkFile, -1, wcLinkFile, MAX_PATH ); 
		if ( SaveShellLink( psl, wcLinkFile, TRUE ) ) // ショートカットの保存
		{
			psl->Release();
			CoUninitialize();
			return TRUE; // 成功
		}
		psl->Release();
	}
	CoUninitialize();
	return FALSE; // 失敗
}//CreateShellLink

//*********************************************************
// SaveShellLink
//*********************************************************
BOOL SaveShellLink( IShellLink *psl, const WCHAR *wcLinkName, BOOL bRemember )
{
	HRESULT       hResult;
	IPersistFile *ppf;

	if ( S_OK != psl->QueryInterface( IID_IPersistFile, (void **)&ppf ) )
		return FALSE;

	hResult = ppf->Save( wcLinkName, bRemember );
	ppf->Release();
	return S_OK == hResult;
}//SaveShellLink


/*-----------------------------------------------------------------------------
[名称]	関連付け
[機能]	拡張子をアプリケーションに関連付ける。
[戻値]	CString	それまで関連付けられていた文書タイプ [-] (-)
[備考]	ext下にDefaultIconキーをつくり、そこに元の関連付けdocnameを保存しておく。

MASATOの開発日記 2000年6月
http://www.yks.ne.jp/~masato/room/diary/dev200006.html#20000607

// したらびあん用に改造
	SetFileType(
		".txt",
		"txtfile",
		"テキスト ドキュメント",
		"したらびあんで開く",						←アクションを指定。
		"\"C:\\Windows\\Shitarabian.exe\" \"%1\""
	);

-----------------------------------------------------------------------------*/
void SetFileType(
	CString& ext,		// extは拡張子名（ピリオド含む）で、
	CString& docname,	// docnameは、レジストリで使うドキュメントの名前
	CString& doctype,	// doctypeは、エクスプローラー等で表示される「ファイルの種類」
	CString& action,	// アクション
	CString& exepath	// exepathは、実行ファイルのパス
)
{ 
	CString	strOldDocname;
    CRegKey reg; 

	long lResult =  reg.Open( HKEY_CLASSES_ROOT, ext+"\\OldDocName" ) ;
	if ( ERROR_SUCCESS == lResult )
	{
		// すでに復元情報が存在すればすでに関連付けされているとみなし
		// 処理しない。
		return;
	}

	// extに関連付けられているdocnameがあれば取得する
	{
// ▼ (ワーニング回避) BGN 2003.12.29 (moralog) warning C4101
// ▽ original BGN
//		DWORD dwPostalNum2;		// "PostalNumber"のデータを受け取る
//		DWORD dwType;			// 値の種類を受け取る
// △ original END
// ▲ (ワーニング回避) END
		DWORD dwSize = 0;		// データのサイズを受け取る

		reg.Open( HKEY_CLASSES_ROOT, ext );
		reg.QueryValue( NULL, "", &dwSize );
		if ( dwSize > 0 )
		{
			char*	buff = new char [dwSize+1];
			reg.QueryValue( buff, "", &dwSize);
			buff[dwSize] = 0x00;
			strOldDocname = buff;
			delete [] buff;
		}
	}

	// すでに関連付けされているのではないか？
	if ( docname == strOldDocname )
	{
		// 登録済み
		return;
	}

	// doctypeが登録されていなければ新規作成する
	if ( ERROR_SUCCESS != reg.Open( HKEY_CLASSES_ROOT, docname ) )
	{
		// docname作成
		reg.SetValue(HKEY_CLASSES_ROOT, docname, doctype );
			// please! がおー！これじゃ拡張子によらず全部同じファイルタイプに表示される
			// 1ext=1docnameにするか？

		// アプリケーション登録
		{
			CString	strCommand;
			strCommand = exepath + " \"%1\"";
			CString		strExeKey;
			strExeKey.Format( "%s%s%s%s", docname, "\\shell\\", action, "\\command" );
			reg.SetValue( HKEY_CLASSES_ROOT, strExeKey, strCommand );
		}

		// "標準"設定
		reg.SetValue(HKEY_CLASSES_ROOT, docname + "\\shell", action ); 

		// アイコン変更
		{
			CString	strKey( docname + "\\DefaultIcon" );
			CString	strPath( exepath + ",1" );				// １のアイコン（文書）を使用
			reg.SetValue(
				HKEY_CLASSES_ROOT,
				strKey,
				strPath
			);
		}
	}

	// extをdocnameに関連付ける
	reg.SetValue(HKEY_CLASSES_ROOT, ext, docname); 

	// 元の関連付け情報を保存
	reg.SetValue(HKEY_CLASSES_ROOT, ext+"\\OldDocName", strOldDocname); 

    // 関連付けが変更された事をシステムに通知（アイコンの更新）
    ::SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL); 

    return; 
} 



/*-----------------------------------------------------------------------------
[名称]	関連付け解除
[機能]	拡張子をアプリケーションの関連付けからはずす。
[戻値]	なし
[備考]	なし
-----------------------------------------------------------------------------*/
void RemoveFileType(
	CString& ext,		// extは拡張子名（ピリオド含む）で、
	CString& docname	// docnameは、復元するドキュメント種類の名前
)
{ 
	CString	strOldAction;
    CRegKey reg;

	// 元のdocnameを取得
	CString		strRelatedDocname;
	CString		strOldDocname;
	{
		long lResult =  reg.Open( HKEY_CLASSES_ROOT, ext+"\\OldDocName" ) ;
		if ( ERROR_SUCCESS != lResult )
		{
			// 復元情報がないときはSetFileTypeによる関連付けがされてないものとみなし
			// 処理しない。
			return;
		}
// ▼ (ワーニング回避) BGN 2003.12.29 (moralog) warning C4101
// ▽ original BGN
//		DWORD dwPostalNum2;		// "PostalNumber"のデータを受け取る
//		DWORD dwType;			// 値の種類を受け取る
// △ original END
// ▲ (ワーニング回避) END
		DWORD dwSize = 0;		// データのサイズを受け取る

		// 元のdocnameを取得
		reg.QueryValue( NULL, "", &dwSize );
		if ( dwSize > 0 )
		{
			char*	buff = new char [dwSize+1];
			reg.QueryValue( buff, "", &dwSize);
			buff[dwSize] = 0x00;
			strOldDocname = buff;
			delete [] buff;
		}

		// 関連づいているdocnameを取得
		reg.Open( HKEY_CLASSES_ROOT, ext );
		reg.QueryValue( NULL, "", &dwSize );
		if ( dwSize > 0 )
		{
			char*	buff = new char [dwSize+1];
			reg.QueryValue( buff, "", &dwSize);
			buff[dwSize] = 0x00;
			strRelatedDocname = buff;
			delete [] buff;
		}
	}

	// 指定のdoctypeに関連づいているなら関連付けを解除
	if ( docname == strRelatedDocname )
	{
		// docnameを削除する
		if ( ERROR_SUCCESS == reg.Open( HKEY_CLASSES_ROOT, "" ) )
		{
			reg.RecurseDeleteKey( docname );
		}

		// 元の関連付けを復元
		if ( !strOldDocname.IsEmpty() )
		{
			// 元の関連付けメモを削除
			if ( ERROR_SUCCESS == reg.Open( HKEY_CLASSES_ROOT, ext ) )
			{
				reg.RecurseDeleteKey( "OldDocName" );
			}

			// extを元のdocnameに関連付ける
			reg.SetValue(HKEY_CLASSES_ROOT, ext, strOldDocname);
		}
		else
		{
		// 元の関連付けが存在しないならextごと削除
			if ( ERROR_SUCCESS == reg.Open( HKEY_CLASSES_ROOT, "" ) )
			{
				reg.RecurseDeleteKey( ext );
			}
		}

		// 関連付けが変更された事をシステムに通知（アイコンの更新）
		::SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL); 
	}
}



/*-----------------------------------------------------------------------------
[名称]	関連付け解除
[機能]	拡張子をアプリケーションの関連付けからはずす。
[戻値]	なし
[備考]	なし
-----------------------------------------------------------------------------*/
BOOL IsRelatedFileType(
	CString& ext,		// extは拡張子名（ピリオド含む）で、
	CString& docname	// docnameは、復元するドキュメント種類の名前
)
{ 
	CString	strOldAction;
    CRegKey reg;

	// リンクしているdocnameを取得
	CString		strRelatedDocname;
	{
		long lResult =  reg.Open( HKEY_CLASSES_ROOT, ext+"\\OldDocName" ) ;
		if ( ERROR_SUCCESS != lResult )
		{
			// 復元情報がないときはSetFileTypeによる関連付けがされてないものとみなす
			return( FALSE );
		}

		// extのリンクdoctypeを取得
// ▼ (ワーニング回避) BGN 2003.12.29 (moralog) warning C4101
// ▽ original BGN
//		DWORD dwPostalNum2;		// "PostalNumber"のデータを受け取る
//		DWORD dwType;			// 値の種類を受け取る
// △ original END
// ▲ (ワーニング回避) END
		DWORD dwSize = 0;		// データのサイズを受け取る
		lResult =  reg.Open( HKEY_CLASSES_ROOT, ext ) ;
		reg.QueryValue( NULL, "", &dwSize );
		if ( dwSize > 0 )
		{
			char*	buff = new char [dwSize+1];
			reg.QueryValue( buff, "", &dwSize);
			buff[dwSize] = 0x00;
			strRelatedDocname = buff;
			delete [] buff;
		}
	}

	return( strRelatedDocname == docname );
}

// ▼ (3146) BGN 2003.11.08 (moralog) 新規追加
/*-----------------------------------------------------------------------------
[名称]	リソース文字列取得
[機能]	リソース文字列を取得する。
[戻値]	CString		-	リソース文字列 [-] (-)
[備考]	なし
-----------------------------------------------------------------------------*/
CString	GetString(
	long	lStringID	// <I> リソースID [-] (-) :-
)
{
	CString	str;
	str.LoadString( lStringID );
	return( str );
}
// ▲ (3146) END


// ▼ (3146) BGN 2003.11.08 (moralog) 新規追加
/*-----------------------------------------------------------------------------
[名称]	オプション内容取得
[機能]	オプション内容を取得する。
[戻値]	CString		-	オプション内容 [-] (-)
[備考]	なし
-----------------------------------------------------------------------------*/
CString GetCommandtailOption(
	LPCTSTR strOptionName	// <I> オプション名称 [-] (たとえば"row","column") :-
)
{
	CString strOptionValue;

	// __argv[n]を検索して"-option1=nn"のようなオプション指定の"nn"部分を戻す
	CString	strOptionLabel;
	strOptionLabel.Format( "-%s=", strOptionName );
	long	idxOption;
	for( idxOption=1 ; idxOption<__argc ; idxOption++ )
	{
		// 先頭がオプション認識文字列と合致するか？
		if ( 0 == memcmp( __argv[idxOption], (LPCTSTR)strOptionLabel, strOptionLabel.GetLength() ) )
		{
			strOptionValue = (CString)(__argv[idxOption] + strOptionLabel.GetLength() );
			strOptionValue.TrimLeft();
			strOptionValue.TrimRight();
			break;
		}
	}
	return( strOptionValue );
}
// ▲ (3146) END

// ▼ (3146) BGN 2003.11.10 (dincom) 新規追加
/*-----------------------------------------------------------------------------
[名称]	タグジャンプ情報取得
[機能]	タグジャンプの情報を取得する。
[戻値]	BOOL	処理結果 [-] (TRUE:成功、FALSE:失敗)
[備考]	なし
-----------------------------------------------------------------------------*/
BOOL	GetTagJumpInfo( 
	CString&	strTagJumpInfo,		//<I> タグジャンプ情報（文字列）　[-] (-) :-
	CString*	pstrFilePath,		//<O> ジャンプ先のファイル名
	long*		plRow,				//<O> ジャンプ後の指定行
	long*		plColumn			//<O> ジャンプ後の指定カラム
)
{
	CFile	fCheck;
	int		idxInfoMAX = strTagJumpInfo.GetLength();

	for( int idxInfo = 0 ; idxInfo < idxInfoMAX ; idxInfo++ )
	{
		CString strTempFilePath;
		strTempFilePath.Empty();
		strTempFilePath = strTagJumpInfo.Left( idxInfoMAX - idxInfo );

		//ファイルがあるかチェックする
		if( fCheck.Open( strTempFilePath , CFile::shareDenyNone ) )
		{
			//ファイル名取得
			*pstrFilePath = strTempFilePath;
			
			//行、カラム抜き出し
			long	lRow			= 0;
			long	lColumn			= 0;
			int		idxComma		= 0;
			int		idxJumpInfoMAX  = idxInfo;

			//ファイル名以外を切り出し
			CString strJumpInfo = strTagJumpInfo.Right( idxJumpInfoMAX );
			
			//行取得
// ▼ (3146) BGN 2003.12.28 (moralog) 関数名称変更
			lRow = GetNumeric( strJumpInfo );
// ▽ original BGN
//			lRow = GetFigure( strJumpInfo );
// △ original END
// ▲ (3146) END

			idxComma = strJumpInfo.FindOneOf( "," );
			//','があればカラムを考慮する
			if( idxComma != -1 )
			{
				//カラム取得
// ▼ (3146) BGN 2003.12.28 (moralog) 関数名称変更
// ▼ (ワーニング回避) BGN 2003.12.29 (moralog) warning C4239
				CString	strColumn = strJumpInfo.Right( idxJumpInfoMAX - idxComma );
				lColumn = GetNumeric( strColumn );
// ▽ original BGN
//				lColumn = GetNumeric( strJumpInfo.Right( idxJumpInfoMAX - idxComma ));
// △ original END
// ▲ (ワーニング回避) END
// ▽ original BGN
//				lColumn = GetFigure( strJumpInfo.Right( idxJumpInfoMAX - idxComma ));
// △ original END
// ▲ (3146) END
			}

			*plColumn	= lColumn;
			*plRow		= lRow;

			return TRUE;
		}
	}
	return FALSE;
}
// ▲ (3146) END

// ▼ (3146) BGN 2003.11.12 (dincom) 新規追加
/*-----------------------------------------------------------------------------
[名称]	数字取得
[機能]	文字列から最初の数字を抜き出す。
[戻値]	long	数値　[-] (-)
[備考]	数字が文字列内に無い場合0を返します
-----------------------------------------------------------------------------*/
// ▼ (3146) BGN 2003.12.28 (moralog) 関数名称変更
long GetNumeric(
	CString& strNumeric		//<I> 文字列　[-] (-) :-
)
{
	char*	pcNumeric  = (char*)(LPCSTR)strNumeric;
	int		idxNumeric = strNumeric.FindOneOf( _T("0123456789") );

	return atol( pcNumeric + idxNumeric );

}
/*
// ▽ original BGN
long GetFigure(
	CString& strFigure		//<I> 文字列　[-] (-) :-
)
{
	char*	pcFigure  = (char*)(LPCSTR)strFigure;
	int		idxFigure = strFigure.FindOneOf( "0123456789" );

	return atol( pcFigure + idxFigure );

}
// △ original END
*/
// ▲ (3146) END
// ▲ (3146) END

// ▼ (3367) BGN 2004.1.30 (dincom)
/*-----------------------------------------------------------------------------
[名称]	フォルダ取得ダイアログのためのコールバック
[機能]	フォルダ取得ダイアログのためのコールバック
[戻値]	int		
[備考]	フォルダ取得ダイアログのためのコールバック関数
-----------------------------------------------------------------------------*/ 
int CALLBACK BrowseCallbackProc( 
	HWND hwnd,				// <I> ダイアログボックスのハンドル
	UINT uMsg,				// <I> イベントを識別する値
	LPARAM lParam,			// <I> uMsg に依存する値
	LPARAM lpData			// <I> アプリケーション定義値
)
{
	//　初期化時のフォルダを選択
	if(uMsg == BFFM_INITIALIZED)
	{
       if(lpData != NULL)
	   {
            SendMessage(hwnd, BFFM_SETSELECTION, (WPARAM)TRUE, lpData);
	   }
    }
	return 0;
}
// ▲ (3367) END

// ▼ (3367) BGN 2004.1.30 (dincom)
/*-----------------------------------------------------------------------------
[名称]	フォルダ取得関数
[機能]	フォルダ取得ダイアログを開きフォルダ名を取得する
[戻値]	BOOL	処理結果 [-] (TRUE:成功、FALSE:失敗)
[備考]	なし
-----------------------------------------------------------------------------*/ 
BOOL SelectFolder ( 
	HWND hWnd,				// <I> ダイアログボックスのハンドル
	LPCTSTR lpDefFolder,	// <I> 初期位置フォルダ名
	LPTSTR lpSelectPath		// <O> 選択されたフォルダ名
)
{
	LPMALLOC	pMalloc;
	BOOL		rslt = FALSE;

	//　IMallocインターフェイスへのポインタを取得
	if (SUCCEEDED(SHGetMalloc(&pMalloc)))
	{
		BROWSEINFO		brows;
		ITEMIDLIST		*pIDlist;

		//　構造体の初期化 
		memset ( &brows, NULL, sizeof(brows));
		brows.hwndOwner			= hWnd;
		brows.pszDisplayName	= lpSelectPath;
		brows.lpszTitle			= _T("フォルダーを選択してください");
		brows.lpfn				= (BFFCALLBACK)BrowseCallbackProc;
		brows.lParam			= (LPARAM)lpDefFolder;

		//	フォルダー選択ダイアログの表示
		pIDlist = SHBrowseForFolder( &brows);

		if( pIDlist == NULL)
		{
			strcpy( lpSelectPath, "");
		}
		else 
		{
			// ITEMIDLIST からフルパスを得る
			SHGetPathFromIDList( pIDlist, lpSelectPath);
			rslt	= TRUE;

			//ITEMIDLIST の開放
			pMalloc -> Free( pIDlist);
		}

		pMalloc -> Release();
	}

	return	rslt;
}
// ▲ (3367) END



// ▼ (3204) BGN 2004.05.12 (moralog) ExeCommon.cppから移動。汎用関数化。
/*-----------------------------------------------------------------------------
[名称]	クリップボードコピー
[機能]	文字列をクリップボードへ出力する。
[戻値]	なし
[備考]	なし
-----------------------------------------------------------------------------*/
void EditCopyString(
	CString&	strCopySrc	// I  :コピー元文字列 [-] (-) :-
) 
{
	if ( !strCopySrc.IsEmpty() )
	if ( ::OpenClipboard( NULL ) )
	{
		long	nChar = strCopySrc.GetLength();
		HGLOBAL hGMem = NULL;
		hGMem = ::GlobalAlloc(
			GHND,// | GMEM_DDESHARE,
			sizeof(TCHAR)*( nChar+2 )
		);
		if ( hGMem == NULL )
		{
			PrintLastErr("::GlobalAlloc");
		}

		TCHAR* psz = (TCHAR*)::GlobalLock(hGMem);
		void* p = ::lstrcpy( psz, (LPCTSTR)strCopySrc );
		if ( p == NULL )
		{
			PrintLastErr("::lstrcpy");
		}
		BOOL	b = ::GlobalUnlock(hGMem);
		if ( !b )
		{
			PrintLastErr("::GlobalUnlock");
		}

		BOOL	bEmpty = ::EmptyClipboard();
		if ( !bEmpty )
		{
			PrintLastErr("::EmptyClipboard");
		}

		HANDLE	h = ::SetClipboardData(CF_TEXT, hGMem);
		if ( h == NULL )
		{
			PrintLastErr("::SetClipboardData");
		}
		BOOL	bSuccess = ::CloseClipboard();
		if ( !bSuccess )
		{
			PrintLastErr("::SetClipboardData");
		}
	}
}
// ▲ (3204) END

// ▼ (3751) BGN 2004.05.10 (moralog) ショートファイルネームをロングファイルネームに変換
// ショートファイルネームをロングファイルネームに変換
CString	GetLongFilePath(
	CString& strShortPath
)
{
	const	iMaxLength( 1024 );
	char	strLongPath[ iMaxLength ];
	long	iLength = ::GetLongPathName(
		strShortPath,
		strLongPath,
		iMaxLength
	);
	if ( iLength > 0 )
	{
		return( strLongPath );
	}
	return( strShortPath );
}
// ▲ (3751) END

// ▼ (3751) BGN 2004.05.10 (moralog) ロングファイルネームをショートファイルネームに変換
// ロングファイルネームをショートファイルネームに変換
CString	GetShortFilePath(
	CString& strLongPath
)
{
	// ショートファイルのパスを得る
	const	iMaxLength( 1024 );	// パス格納バッファ長さ
	char	strShortPath[ iMaxLength ];
	long	iLength = ::GetShortPathName( strLongPath, strShortPath, iMaxLength );
	if ( iLength > 0 )
	{
		return( strShortPath );
	}
	return( strLongPath );
}
// ▲ (3751) END

// ▼ (3751) BGN 2004.05.10 (moralog) 関数化
CString	GetExePathName()
{
	const	iMaxLength( 1024 );	// パス格納バッファ長さ
	char	strExeLongPath[ iMaxLength ];
	::GetModuleFileName(
		NULL,
		strExeLongPath,
		iMaxLength
	);
	return( strExeLongPath );
}
// ▲ (3751) END
