/*

  regclass.h
  Copyright(C) 2002-2011 INASOFT 矢吹拓也/Ayacy

  regclass.libを利用するためのヘッダファイル
  (Rnsfおよびすっきりシリーズ用レジストリクラス/一般ライブラリ)

*/

#ifndef MYLIB__ISREGCLASS__
#define MYLIB__ISREGCLASS__

#ifndef OWN__REGCLASS__
#pragma comment(lib, "regclass.lib")
#endif /* OWN__REGCLASS__ */

#ifdef __cplusplus

#ifndef LibExport
#define LibExport extern "C"
#endif  /* LibExport */

#else /* __cplusplus */

#ifndef LibExport
#define LibExport extern
#endif  /* LibExport */

#endif /* __cplusplus */

#define REGCLASS_VERSIONNUMBER 41010

LibExport DWORD tRegGetVersion(void);						// ライブラリのバージョン番号の取得
LibExport VOID  tRegEnglishMode(BOOL flag);					// 英語モードへの切り替え
LibExport VOID  tRegNoMessageMode(BOOL flag);				// ノーメッセージモードへの切り替え
LibExport VOID  tRegDisableReflectionKeyMode(BOOL flag);	// このライブラリで開くレジストリについて、レジストリのリフレクションを行わない
LibExport LONG  tRegDisableReflectionKey(HKEY hBase);		// 指定したキーのハンドルについて、レジストリのリフレクションを行わない

LibExport LONG  tRegGetLastError(void);						// 最後に発生したレジストリ系Windows APIのエラーコード（作者デバッグ用のため、すべてで取得できるわけではない）
LibExport VOID  tRegClearLastError(void);					// tRegGetLastErrorが返す値を初期化する

LibExport HKEY  tRegOpenKeyA(HKEY root, const char    *subkey, DWORD flag);						// キーを開く
LibExport HKEY  tRegOpenKeyW(HKEY root, const wchar_t *subkey, DWORD flag);						// キーを開く
// flag:0=書き込み可能なモードで呼び出し TREG_OPEN_CREATE=存在しなければ作成, TREG_OPEN_READONLY=読み込みのみモード

#ifdef _UNICODE
#define tRegOpenKey	tRegOpenKeyW
#else  /* _UNICODE */
#define tRegOpenKey	tRegOpenKeyA
#endif /* _UNICODE */

LibExport HKEY  tRegOpenSubKeyA(HKEY root, const char    *subkey, const char    *subsubkey, DWORD flag);// サブキーを開く
LibExport HKEY  tRegOpenSubKeyW(HKEY root, const wchar_t *subkey, const wchar_t *subsubkey, DWORD flag);// サブキーを開く
// flag:0=書き込み可能なモードで呼び出し TREG_OPEN_CREATE=存在しなければ作成, TREG_OPEN_READONLY=読み込みのみモード

#ifdef _UNICODE
#define tRegOpenSubKey	tRegOpenSubKeyW
#else  /* _UNICODE */
#define tRegOpenSubKey	tRegOpenSubKeyA
#endif /* _UNICODE */

LibExport int   tRegValueExistA(HKEY hkey, const char    *ValueName);								// 値の存在を調べ、サイズを返す。存在しなければ-1
LibExport int   tRegValueExistW(HKEY hkey, const wchar_t *ValueName);								// 値の存在を調べ、サイズを返す。存在しなければ-1

#ifdef _UNICODE
#define tRegValueExist	tRegValueExistW
#else  /* _UNICODE */
#define tRegValueExist	tRegValueExistA
#endif /* _UNICODE */

LibExport DWORD tRegValueSizeA(HKEY hkey, const char    *ValueName);								// 単純に値のサイズを返す。存在しなければ0
LibExport DWORD tRegValueSizeW(HKEY hkey, const wchar_t *ValueName);								// 単純に値のサイズを返す。存在しなければ0

#ifdef _UNICODE
#define tRegValueSize	tRegValueSizeW
#else  /* _UNICODE */
#define tRegValueSize	tRegValueSizeA
#endif /* _UNICODE */

LibExport DWORD tRegValueTypeA(HKEY hKey, const char    *ValueName);								// 値の型を調べる
LibExport DWORD tRegValueTypeW(HKEY hKey, const wchar_t *ValueName);								// 値の型を調べる

#ifdef _UNICODE
#define tRegValueType	tRegValueTypeW
#else  /* _UNICODE */
#define tRegValueType	tRegValueTypeA
#endif /* _UNICODE */

LibExport BOOL  tRegReadStringA(HKEY hkey, const char    *ValueName, char    *Value, int size);		// 文字列・バイナリの読み込み
LibExport BOOL  tRegReadStringW(HKEY hkey, const wchar_t *ValueName, wchar_t *Value, int size);		// 文字列・バイナリの読み込み

#ifdef _UNICODE
#define tRegReadString	tRegReadStringW
#else  /* _UNICODE */
#define tRegReadString	tRegReadStringA
#endif /* _UNICODE */

LibExport DWORD tRegReadIntegerA(HKEY hkey, const char    *ValueName, DWORD Def);					// 数値の読み出し
LibExport DWORD tRegReadIntegerW(HKEY hkey, const wchar_t *ValueName, DWORD Def);					// 数値の読み出し

#ifdef _UNICODE
#define tRegReadInteger	tRegReadIntegerW
#else  /* _UNICODE */
#define tRegReadInteger	tRegReadIntegerA
#endif /* _UNICODE */

LibExport BOOL  tRegWriteStringA(HKEY hkey, const char *ValueName,    const char *Value,    char rws_expand_flag);	// 文字列の書き込み
LibExport BOOL  tRegWriteStringW(HKEY hkey, const wchar_t *ValueName, const wchar_t *Value, char rws_expand_flag);	// 文字列の書き込み

#ifdef _UNICODE
#define tRegWriteString	tRegWriteStringW
#else  /* _UNICODE */
#define tRegWriteString	tRegWriteStringA
#endif /* _UNICODE */

LibExport BOOL  tRegWriteIntegerA(HKEY hkey, const char    *ValueName, DWORD Integer);				// 数値の書き込み
LibExport BOOL  tRegWriteIntegerW(HKEY hkey, const wchar_t *ValueName, DWORD Integer);				// 数値の書き込み

#ifdef _UNICODE
#define tRegWriteInteger	tRegWriteIntegerW
#else  /* _UNICODE */
#define tRegWriteInteger	tRegWriteIntegerA
#endif /* _UNICODE */

LibExport BOOL  tRegWriteBinaryA(HKEY hkey, const char    *ValueName, const char *Value, int size);		// バイナリの書き込み
LibExport BOOL  tRegWriteBinaryW(HKEY hkey, const wchar_t *ValueName, const char *Value, int size);		// バイナリの書き込み

#ifdef _UNICODE
#define tRegWriteBinary	tRegWriteBinaryW
#else  /* _UNICODE */
#define tRegWriteBinary	tRegWriteBinaryA
#endif /* _UNICODE */

LibExport BOOL  tRegReadStringForEditboxA(HKEY hKey, const char    *ValueName, HWND hDlg, int nIDDlgItem, const char    *Def); // レジストリから文字列を読み込み、そのままエディットボックスへ
LibExport BOOL  tRegReadStringForEditboxW(HKEY hKey, const wchar_t *ValueName, HWND hDlg, int nIDDlgItem, const wchar_t *Def); // レジストリから文字列を読み込み、そのままエディットボックスへ

#ifdef _UNICODE
#define tRegReadStringForEditbox	tRegReadStringForEditboxW
#else  /* _UNICODE */
#define tRegReadStringForEditbox	tRegReadStringForEditboxA
#endif /* _UNICODE */

LibExport BOOL  tRegReadIntegerForEditboxA(HKEY hkey, const char    *ValueName, HWND hDlg, int nIDDlgItem, DWORD Def, BOOL bSigned); // レジストリから数値を読みとり、そのままエディットボックスへ
LibExport BOOL  tRegReadIntegerForEditboxW(HKEY hkey, const wchar_t *ValueName, HWND hDlg, int nIDDlgItem, DWORD Def, BOOL bSigned); // レジストリから数値を読みとり、そのままエディットボックスへ

#ifdef _UNICODE
#define tRegReadIntegerForEditbox	tRegReadIntegerForEditboxW
#else  /* _UNICODE */
#define tRegReadIntegerForEditbox	tRegReadIntegerForEditboxA
#endif /* _UNICODE */

LibExport BOOL  tRegWriteStringFromEditboxDefA(HKEY hkey, const char    *ValueName, HWND hDlg, int nIDDlgItem, const char    *Def); // エディットボックスから文字列を読みとり、そのままレジストリへ
LibExport BOOL  tRegWriteStringFromEditboxDefW(HKEY hkey, const wchar_t *ValueName, HWND hDlg, int nIDDlgItem, const wchar_t *Def); // エディットボックスから文字列を読みとり、そのままレジストリへ

#ifdef _UNICODE
#define tRegWriteStringFromEditboxDef	tRegWriteStringFromEditboxDefW
#else  /* _UNICODE */
#define tRegWriteStringFromEditboxDef	tRegWriteStringFromEditboxDefA
#endif /* _UNICODE */

LibExport BOOL  tRegWriteStringFromEditboxA(HKEY hkey, const char    *ValueName, HWND hDlg, int nIDDlgItem, char rws_expand_flag); // エディットボックスから文字列を読みとり、そのままレジストリへ
LibExport BOOL  tRegWriteStringFromEditboxW(HKEY hkey, const wchar_t *ValueName, HWND hDlg, int nIDDlgItem, char rws_expand_flag); // エディットボックスから文字列を読みとり、そのままレジストリへ

#ifdef _UNICODE
#define tRegWriteStringFromEditbox	tRegWriteStringFromEditboxW
#else  /* _UNICODE */
#define tRegWriteStringFromEditbox	tRegWriteStringFromEditboxA
#endif /* _UNICODE */

LibExport BOOL  tRegWriteIntegerFromEditboxA(HKEY hkey, const char    *ValueName, HWND hDlg, int nIDDlgItem);	// エディットボックスから数値を読みとり、そのままレジストリへ
LibExport BOOL  tRegWriteIntegerFromEditboxW(HKEY hkey, const wchar_t *ValueName, HWND hDlg, int nIDDlgItem);	// エディットボックスから数値を読みとり、そのままレジストリへ

#ifdef _UNICODE
#define tRegWriteIntegerFromEditbox	tRegWriteIntegerFromEditboxW
#else  /* _UNICODE */
#define tRegWriteIntegerFromEditbox	tRegWriteIntegerFromEditboxA
#endif /* _UNICODE */

LibExport char    *mtRegReadStringA(HKEY hkey, const char    *ValueName, const char    *Def);					// 文字列を返す (あとでfreeすること)
LibExport wchar_t *mtRegReadStringW(HKEY hkey, const wchar_t *ValueName, const wchar_t *Def);					// 文字列を返す (あとでfreeすること)

#ifdef _UNICODE
#define mtRegReadString	mtRegReadStringW
#else  /* _UNICODE */
#define mtRegReadString	mtRegReadStringA
#endif /* _UNICODE */

LibExport BOOL  tRegReadMultiStringA(HKEY hkey, const char    *ValueName, char    *Value, int size);	// 複数行文字列の読み込み (\0→\r\n)
LibExport BOOL  tRegReadMultiStringW(HKEY hkey, const wchar_t *ValueName, wchar_t *Value, int size);	// 複数行文字列の読み込み (\0→\r\n)

#ifdef _UNICODE
#define tRegReadMultiString	tRegReadMultiStringW
#else  /* _UNICODE */
#define tRegReadMultiString	tRegReadMultiStringA
#endif /* _UNICODE */

LibExport BOOL  tRegWriteMultiStringA(HKEY hkey,const char    *ValueName, const char    *Value);			// 複数行文字列の書き込み (\r\n→\0)
LibExport BOOL  tRegWriteMultiStringW(HKEY hkey,const wchar_t *ValueName, const wchar_t *Value);			// 複数行文字列の書き込み (\r\n→\0)

#ifdef _UNICODE
#define tRegWriteMultiString	tRegWriteMultiStringW
#else  /* _UNICODE */
#define tRegWriteMultiString	tRegWriteMultiStringA
#endif /* _UNICODE */

LibExport char    *mtRegReadMultiStringA(HKEY hkey, const char    *ValueName);						// 複数行文字列の読み込み (あとでfreeすること)
LibExport wchar_t *mtRegReadMultiStringW(HKEY hkey, const wchar_t *ValueName);						// 複数行文字列の読み込み (あとでfreeすること)

#ifdef _UNICODE
#define mtRegReadMultiString	mtRegReadMultiStringW
#else  /* _UNICODE */
#define mtRegReadMultiString	mtRegReadMultiStringA
#endif /* _UNICODE */

LibExport BOOL  tRegReadMultiStringDirectA(HKEY hKey, const char    *entry, char    *buf, LPDWORD psize);					// 複数行文字列をレジストリから読み込む
LibExport BOOL  tRegReadMultiStringDirectW(HKEY hKey, const wchar_t *entry, wchar_t *buf, LPDWORD psize);					// 複数行文字列をレジストリから読み込む

#ifdef _UNICODE
#define tRegReadMultiStringDirect	tRegReadMultiStringDirectW
#else  /* _UNICODE */
#define tRegReadMultiStringDirect	tRegReadMultiStringDirectA
#endif /* _UNICODE */

LibExport BOOL  tRegWriteMultiStringDirectA(HKEY hKey, const char    *entry, const char    *buf, DWORD bufsize);			// 複数行文字列をレジストリへ書き込む
LibExport BOOL  tRegWriteMultiStringDirectW(HKEY hKey, const wchar_t *entry, const wchar_t *buf, DWORD bufsize);			// 複数行文字列をレジストリへ書き込む

#ifdef _UNICODE
#define tRegWriteMultiStringDirect	tRegWriteMultiStringDirectW
#else  /* _UNICODE */
#define tRegWriteMultiStringDirect	tRegWriteMultiStringDirectA
#endif /* _UNICODE */

LibExport char    *mtRegReadMultiStringDirectA(HKEY hKey, const char    *entry, LPDWORD psize);							// 複数行文字列をレジストリから読み込む (あとでfreeすること)
LibExport wchar_t *mtRegReadMultiStringDirectW(HKEY hKey, const wchar_t *entry, LPDWORD psize);							// 複数行文字列をレジストリから読み込む (あとでfreeすること)

#ifdef _UNICODE
#define mtRegReadMultiStringDirect	mtRegReadMultiStringDirectW
#else  /* _UNICODE */
#define mtRegReadMultiStringDirect	mtRegReadMultiStringDirectA
#endif /* _UNICODE */

LibExport BOOL  tRegMoveValuesA(HKEY hkSource, const char    *source, HKEY hkDest, const char    *dest); // hkSource\\source から hkDest\\dest へ、値をコピーし、hkSource\\source 下のすべての値を削除する
LibExport BOOL  tRegMoveValuesW(HKEY hkSource, const wchar_t *source, HKEY hkDest, const wchar_t *dest); // hkSource\\source から hkDest\\dest へ、値をコピーし、hkSource\\source 下のすべての値を削除する

#ifdef _UNICODE
#define tRegMoveValues	tRegMoveValuesW
#else  /* _UNICODE */
#define tRegMoveValues	tRegMoveValuesA
#endif /* _UNICODE */

LibExport HKEY  tRegHiveKeyA(const char    *hive);												// ハイブ(最上位レジストリキー)の名前を、ハイブのハンドルへ変換
LibExport HKEY  tRegHiveKeyW(const wchar_t *hive);												// ハイブ(最上位レジストリキー)の名前を、ハイブのハンドルへ変換

#ifdef _UNICODE
#define tRegHiveKey	tRegHiveKeyW
#else  /* _UNICODE */
#define tRegHiveKey	tRegHiveKeyA
#endif /* _UNICODE */

LibExport BOOL  tRegDeleteSubKeyA(HKEY hkey, const char    *subkey);							// サブキーの削除(その下にあるサブキーすべて削除)
LibExport BOOL  tRegDeleteSubKeyW(HKEY hkey, const wchar_t *subkey);							// サブキーの削除(その下にあるサブキーすべて削除)

#ifdef _UNICODE
#define tRegDeleteSubKey	tRegDeleteSubKeyW
#else  /* _UNICODE */
#define tRegDeleteSubKey	tRegDeleteSubKeyA
#endif /* _UNICODE */

LibExport BOOL  tRegRenValueA(HKEY hKey, const char    *oldname, const char    *newname);			// レジストリエントリの名前変更
LibExport BOOL  tRegRenValueW(HKEY hKey, const wchar_t *oldname, const wchar_t *newname);			// レジストリエントリの名前変更

#ifdef _UNICODE
#define tRegRenValue	tRegRenValueW
#else  /* _UNICODE */
#define tRegRenValue	tRegRenValueA
#endif /* _UNICODE */

LibExport BOOL  tRegCopyValueA(HKEY hKey, const char    *srcname, const char    *destname);		// レジストリエントリのコピー
LibExport BOOL  tRegCopyValueW(HKEY hKey, const wchar_t *srcname, const wchar_t *destname);		// レジストリエントリのコピー

#ifdef _UNICODE
#define tRegCopyValue	tRegCopyValueW
#else  /* _UNICODE */
#define tRegCopyValue	tRegCopyValueA
#endif /* _UNICODE */

LibExport DWORD numMultiStringA(const char    *msz, DWORD mszsize);				// 複数行文字列(行が\0で区切られ終端が\0\0)の行数を調べる
LibExport DWORD numMultiStringW(const wchar_t *msz, DWORD mszsize);				// 複数行文字列(行が\0で区切られ終端が\0\0)の行数を調べる

#ifdef _UNICODE
#define numMultiString	numMultiStringW
#else  /* _UNICODE */
#define numMultiString	numMultiStringA
#endif /* _UNICODE */

#ifndef tRegCloseKey
#define tRegCloseKey	RegCloseKey
#define	tRegDeleteKey	RegDeleteKey
#define tRegDeleteValue	RegDeleteValue
#endif  /* tRegCloseKey */

#ifndef TREG_SZ
#define TREG_SZ		0
#define TREG_EXPAND_SZ	1
#define TREG_MAYBE_SZ	2
#define TREG_NORMAL_SZ	3
#define TREG_OPEN_CREATE	1
#define TREG_OPEN_READONLY	2
#endif  /* TREG_SZ */

LibExport DWORD tiniNumSectionA( const char    *inifile );								// iniファイル中のセクションの数を数える
LibExport DWORD tiniNumSectionW( const wchar_t *inifile );								// iniファイル中のセクションの数を数える

#ifdef _UNICODE
#define tiniNumSection tiniNumSectionW
#else  /* _UNICODE */
#define tiniNumSection tiniNumSectionA
#endif /* _UNICODE */

LibExport DWORD tiniNumKeyA( const char    *inifile, const char    *section );				// iniファイルのセクション中のキーの数を数える
LibExport DWORD tiniNumKeyW( const wchar_t *inifile, const wchar_t *section );				// iniファイルのセクション中のキーの数を数える

#ifdef _UNICODE
#define tiniNumKey tiniNumKeyW
#else  /* _UNICODE */
#define tiniNumKey tiniNumKeyA
#endif /* _UNICODE */

LibExport char    *mtiniReadStringA( const char    *inifile, const char    *section, const char    *key, const char    *def );	// iniファイルから文字列を読み込む(使い終わったらfreeすること)
LibExport wchar_t *mtiniReadStringW( const wchar_t *inifile, const wchar_t *section, const wchar_t *key, const wchar_t *def );	// iniファイルから文字列を読み込む(使い終わったらfreeすること)

#ifdef _UNICODE
#define mtiniReadString mtiniReadStringW
#else  /* _UNICODE */
#define mtiniReadString mtiniReadStringA
#endif /* _UNICODE */

LibExport char    *mtiniEnumSectionA( const char    *inifile, DWORD n );					// iniファイルからセクションを列挙(使い終わったらfreeすること)
LibExport wchar_t *mtiniEnumSectionW( const wchar_t *inifile, DWORD n );					// iniファイルからセクションを列挙(使い終わったらfreeすること)

#ifdef _UNICODE
#define mtiniEnumSection mtiniEnumSectionW
#else  /* _UNICODE */
#define mtiniEnumSection mtiniEnumSectionA
#endif /* _UNICODE */

LibExport char    *mtiniEnumKeyA( const char    *inifile, const char    *section, DWORD n );	// iniファイルのセクションからキーを列挙(使い終わったらfreeすること)
LibExport wchar_t *mtiniEnumKeyW( const wchar_t *inifile, const wchar_t *section, DWORD n );	// iniファイルのセクションからキーを列挙(使い終わったらfreeすること)

#ifdef _UNICODE
#define mtiniEnumKey mtiniEnumKeyW
#else  /* _UNICODE */
#define mtiniEnumKey mtiniEnumKeyA
#endif /* _UNICODE */

LibExport BOOL tiniReadSectionA( const char    *inifile, const char    *section, char    *buf, DWORD bufsize ); // iniファイルのセクションを丸ごと読み込む
LibExport BOOL tiniReadSectionW( const wchar_t *inifile, const wchar_t *section, wchar_t *buf, DWORD bufsize ); // iniファイルのセクションを丸ごと読み込む

#ifdef _UNICODE
#define tiniReadSection tiniReadSectionW
#else  /* _UNICODE */
#define tiniReadSection tiniReadSectionA
#endif /* _UNICODE */

LibExport BOOL tiniWriteSectionA( const char    *inifile, const char    *section, const char    *buf );	// iniファイルのセクションを丸ごと書き込む
LibExport BOOL tiniWriteSectionW( const wchar_t *inifile, const wchar_t *section, const wchar_t *buf );	// iniファイルのセクションを丸ごと書き込む

#ifdef _UNICODE
#define tiniWriteSection tiniWriteSectionW
#else  /* _UNICODE */
#define tiniWriteSection tiniWriteSectionA
#endif /* _UNICODE */

LibExport char    *mtiniReadSectionA( const char    *inifile, const char    *section);		// iniファイルのセクションを丸ごと読み込む(使い終わったらfreeすること)
LibExport wchar_t *mtiniReadSectionW( const wchar_t *inifile, const wchar_t *section);		// iniファイルのセクションを丸ごと読み込む(使い終わったらfreeすること)

#ifdef _UNICODE
#define mtiniReadSection mtiniReadSectionW
#else  /* _UNICODE */
#define mtiniReadSection mtiniReadSectionA
#endif /* _UNICODE */

LibExport BOOL writePrivateProfileStringCTA( const char    *lpAppName, const char    *lpKeyName, const char    *lpString, const char    *lpFileName ); // GetPrivateProfileStringの仕様により、文字列が " や ' で囲まれていると、それが取り除かれてしまうので、' で囲っておく。
LibExport BOOL writePrivateProfileStringCTW( const wchar_t *lpAppName, const wchar_t *lpKeyName, const wchar_t *lpString, const wchar_t *lpFileName ); // GetPrivateProfileStringの仕様により、文字列が " や ' で囲まれていると、それが取り除かれてしまうので、' で囲っておく。

#ifdef _UNICODE
#define writePrivateProfileStringCT writePrivateProfileStringCTW
#else  /* _UNICODE */
#define writePrivateProfileStringCT writePrivateProfileStringCTA
#endif /* _UNICODE */

LibExport BOOL CreateUnicodeIniA( const char *inifile );
LibExport BOOL CreateUnicodeIniW( const wchar_t *inifile);

#ifdef _UNICODE
#define CreateUnicodeIni CreateUnicodeIniW
#else  /* _UNICODE */
#define CreateUnicodeIni CreateUnicodeIniA
#endif /* _UNICODE */

// 将来的には使えなくなるかもしれない関数 NtRenameKey (Ntdll.dll) を、とりあえず呼び出すための関数
LibExport LONG tRegRenameKeyW( HKEY hKey, const wchar_t *lpWSubKeyName, const wchar_t *lpWNewName );
LibExport LONG tRegRenameKeyA( HKEY hKey, const char *lpSubKeyName, const char *lpNewName );

#ifdef _UNICODE
#define tRegRenameKey tRegRenameKeyW
#else  /* _UNICODE */
#define tRegRenameKey tRegRenameKeyA
#endif /* _UNICODE */


#ifdef __cplusplus
class REGA {
    public:
		REGA() : hkey(NULL) {}		// コンストラクタ
		~REGA();					// デストラクタ
		bool OpenKey(HKEY root, const char *subkey, DWORD flag = 0);						// キーを開く
		bool OpenSubKey(HKEY root, const char *subkey, const char *subsubkey, DWORD t_create = 0);	// サブキーを開く
		inline int  ValueExist(const char *ValueName) const	// ValueName:存在を確認したい値の名前		// 値の存在を調べ、サイズを返す。存在しなければ-1
			{return tRegValueExistA(hkey, ValueName);}
		inline DWORD ValueSize(const char *ValueName) const // ValueName:存在を確認したい値の名前		// 単純に値のサイズを調べる。存在しなければ 0
			{return tRegValueSizeA(hkey, ValueName);}	
		inline DWORD ValueType(const char *ValueName) const // ValueName:存在を確認したい値の名前		// 値の型を調べる
			{return tRegValueTypeA(hkey, ValueName);}
		inline bool ReadString(const char *ValueName, char *Value, int size) const						// 文字列・バイナリの読み込み
			{return (tRegReadStringA(hkey, ValueName, Value, size)?true:false);}
		inline DWORD ReadInteger(const char *ValueName, DWORD Def = 0) const							// 数値の読み込み
			{return tRegReadIntegerA(hkey, ValueName, Def);}
		inline bool WriteString(const char *ValueName, const char *Value, char rws_expand_flag = 0) const	// 各種文字列の書き込み
			{return (tRegWriteStringA(hkey, ValueName, Value, rws_expand_flag)?true:false);}
		inline bool WriteInteger(const char *ValueName, DWORD Integer) const							// 数値の書き込み
			{return (tRegWriteIntegerA(hkey, ValueName, Integer)?true:false);}
		inline bool WriteBinary(const char *ValueName, const char *Value, int size) const				// バイナリの書き込み
			{return (tRegWriteBinaryA(hkey, ValueName, Value, size)?true:false);}
		inline bool ReadStringForEditbox(const char *ValueName, HWND hDlg, int nIDDlgItem, const char *Def = "") const	// 文字列レジストリ→エディットボックス
			{return (tRegReadStringForEditboxA(hkey, ValueName, hDlg, nIDDlgItem, Def)?true:false);}
		inline bool ReadIntegerForEditbox(const char *ValueName, HWND hDlg, int nIDDlgItem, DWORD Def = 0, bool bSigned = 0) const // 数値レジストリ→エディットボックス
			{return (tRegReadIntegerForEditboxA(hkey, ValueName, hDlg, nIDDlgItem, Def, (BOOL)bSigned)?true:false);}
		inline bool WriteStringFromEditbox(const char *ValueName, HWND hDlg, int nIDDlgItem, char rws_expand_flag = 0) const // 各種文字列エディットボックス→レジストリ
			{return (tRegWriteStringFromEditboxA(hkey, ValueName, hDlg, nIDDlgItem, rws_expand_flag)?true:false);}
		inline bool WriteStringFromEditbox(const char *ValueName, HWND hDlg, int nIDDlgItem, const char *Def) const //  通常文字列エディットボックス→レジストリ
			{return (tRegWriteStringFromEditboxDefA(hkey, ValueName, hDlg, nIDDlgItem, Def)?true:false);}
		inline bool WriteIntegerFromEditbox(const char *ValueName, HWND hDlg, int nIDDlgItem) const		// 数値エディットボックス→レジストリ
			{return (tRegWriteIntegerFromEditboxA(hkey, ValueName, hDlg, nIDDlgItem)?true:false);}
		char *new_ReadString(const char *ValueName, const char *Def=NULL) const;						// 文字列の読み込み (あとでdelete[]で解放すること)
		inline bool ReadMultiString(const char *ValueName, char *value, int size) const					// 複数行文字列の読み込み (\0→\r\n)
			{return (tRegReadMultiStringA(hkey, ValueName, value, size)?true:false);}
		inline bool WriteMultiString(const char *ValueName, const char *value) const					// 複数行文字列の書き込み (\r\n→\0)
			{return (tRegWriteMultiStringA(hkey, ValueName, value)?true:false);}
		char *new_ReadMultiString(const char *ValueName) const;											// 複数行文字列の読み込み (あとでdelete[]すること)
		inline bool ReadMultiStringDirect(const char *entry, char *buf, LPDWORD psize) const			// 複数行文字列をレジストリから読み込む
			{return (tRegReadMultiStringDirectA(hkey, entry, buf, psize)?true:false);}
		char *new_ReadMultiStringDirect(const char *entry, LPDWORD psize) const;						// 複数行文字列をレジストリから読み込む (あとでdelete[]すること)
		inline bool WriteMultiStringDirect(const char *entry, const char *buf, DWORD bufsize) const		// 複数行文字列をレジストリへ書き込む
			{return (tRegWriteMultiStringDirectA(hkey, entry, buf, bufsize)?true:false);}
		bool DeleteKey(const char *subkey) const;											// サブキーの削除
		bool DeleteSubKey(const char *subkey) const;										// サブキーの削除(その下にあるサブキーすべて削除)
		bool DeleteValue(const char *valuename) const;										// 値の削除
		bool CloseKey(void);																// キーを閉じる
		inline HKEY GetHKey(void) const															// 現在開いているレジストリキーのハンドルを返す
			{return hkey;}
		inline bool RenValue(const char *oldname, const char *newname) const							// レジストリエントリの名前変更
			{return (tRegRenValueA(hkey, oldname, newname)?true:false);}
		inline bool CopyValue(const char *srcname, const char *destname) const							// レジストリエントリのコピー
			{return (tRegCopyValueA(hkey, srcname, destname)?true:false);}

	private:
		HKEY hkey;
};

class REGW {
    public:
		REGW()  : hkey(NULL) {}		// コンストラクタ
		~REGW();					// デストラクタ
		bool OpenKey(HKEY root, const wchar_t *subkey, DWORD flag = 0);						// キーを開く
		bool OpenSubKey(HKEY root, const wchar_t *subkey, const wchar_t *subsubkey, DWORD t_create = 0);	// サブキーを開く
		inline int  ValueExist(const wchar_t *ValueName) const // ValueName:存在を確認したい値の名前		// 値の存在を調べ、サイズを返す。存在しなければ-1
			{return tRegValueExistW(hkey, ValueName);}
		inline DWORD ValueSize(const wchar_t *ValueName) const // ValueName:存在を確認したい値の名前		// 単純に値のサイズを調べる。存在しなければ 0
			{return tRegValueSizeW(hkey, ValueName);}	
		inline DWORD ValueType(const wchar_t *ValueName) const // ValueName:存在を確認したい値の名前		// 値の型を調べる
			{return tRegValueTypeW(hkey, ValueName);}
		inline bool ReadString(const wchar_t *ValueName, wchar_t *Value, int size) const					// 文字列・バイナリの読み込み
			{return (tRegReadStringW(hkey, ValueName, Value, size)?true:false);}
		inline DWORD ReadInteger(const wchar_t *ValueName, DWORD Def = 0) const								// 数値の読み込み
			{return tRegReadIntegerW(hkey, ValueName, Def);}
		inline bool WriteString(const wchar_t *ValueName, const wchar_t *Value, char rws_expand_flag = 0) const // 各種文字列の書き込み
			{return (tRegWriteStringW(hkey, ValueName, Value, rws_expand_flag)?true:false);}
		inline bool WriteInteger(const wchar_t *ValueName, DWORD Integer) const								// 数値の書き込み
			{return (tRegWriteIntegerW(hkey, ValueName, Integer)?true:false);}
		inline bool WriteBinary(const wchar_t *ValueName, const char *Value, int size) const				// バイナリの書き込み
			{return (tRegWriteBinaryW(hkey, ValueName, Value, size)?true:false);}
		inline bool ReadStringForEditbox(const wchar_t *ValueName, HWND hDlg, int nIDDlgItem, const wchar_t *Def = L"")	const // 文字列レジストリ→エディットボックス
			{return (tRegReadStringForEditboxW(hkey, ValueName, hDlg, nIDDlgItem, Def)?true:false);}
		inline bool ReadIntegerForEditbox(const wchar_t *ValueName, HWND hDlg, int nIDDlgItem, DWORD Def = 0, bool bSigned = 0) const // 数値レジストリ→エディットボックス
			{return (tRegReadIntegerForEditboxW(hkey, ValueName, hDlg, nIDDlgItem, Def, (BOOL)bSigned)?true:false);}
		inline bool WriteStringFromEditbox(const wchar_t *ValueName, HWND hDlg, int nIDDlgItem, char rws_expand_flag = 0) const // 各種文字列エディットボックス→レジストリ
			{return (tRegWriteStringFromEditboxW(hkey, ValueName, hDlg, nIDDlgItem, rws_expand_flag)?true:false);}
		inline bool WriteStringFromEditbox(const wchar_t *ValueName, HWND hDlg, int nIDDlgItem, const wchar_t *Def) const //  通常文字列エディットボックス→レジストリ
			{return (tRegWriteStringFromEditboxDefW(hkey, ValueName, hDlg, nIDDlgItem, Def)?true:false);}
		inline bool WriteIntegerFromEditbox(const wchar_t *ValueName, HWND hDlg, int nIDDlgItem) const		// 数値エディットボックス→レジストリ
			{return (tRegWriteIntegerFromEditboxW(hkey, ValueName, hDlg, nIDDlgItem)?true:false);}
		wchar_t *new_ReadString(const wchar_t *ValueName, const wchar_t *Def=NULL) const;					// 文字列の読み込み (あとでdelete[]で解放すること)
		inline bool ReadMultiString(const wchar_t *ValueName, wchar_t *value, int size)	const				// 複数行文字列の読み込み (\0→\r\n)
			{return (tRegReadMultiStringW(hkey, ValueName, value, size)?true:false);}
		inline bool WriteMultiString(const wchar_t *ValueName, const wchar_t *value) const					// 複数行文字列の書き込み (\r\n→\0)
			{return (tRegWriteMultiStringW(hkey, ValueName, value)?true:false);}
		wchar_t *new_ReadMultiString(const wchar_t *ValueName) const;										// 複数行文字列の読み込み (あとでdelete[]すること)
		inline bool ReadMultiStringDirect(const wchar_t *entry, wchar_t *buf, LPDWORD psize) const			// 複数行文字列をレジストリから読み込む
			{return (tRegReadMultiStringDirectW(hkey, entry, buf, psize)?true:false);}
		wchar_t *new_ReadMultiStringDirect(const wchar_t *entry, LPDWORD psize) const;						// 複数行文字列をレジストリから読み込む (あとでdelete[]すること)
		inline bool WriteMultiStringDirect(const wchar_t *entry, const wchar_t *buf, DWORD bufsize)	const	// 複数行文字列をレジストリへ書き込む
			{return (tRegWriteMultiStringDirectW(hkey, entry, buf, bufsize)?true:false);}
		bool DeleteKey(const wchar_t *subkey) const;										// サブキーの削除
		bool DeleteSubKey(const wchar_t *subkey) const;										// サブキーの削除(その下にあるサブキーすべて削除)
		bool DeleteValue(const wchar_t *valuename) const;									// 値の削除
		bool CloseKey(void);																// キーを閉じる
		inline HKEY GetHKey(void) const															// 現在開いているレジストリキーのハンドルを返す
			{return hkey;}
		inline bool RenValue(const wchar_t *oldname, const wchar_t *newname) const							// レジストリエントリの名前変更
			{return (tRegRenValueW(hkey, oldname, newname)?true:false);}
		inline bool CopyValue(const wchar_t *srcname, const wchar_t *destname) const						// レジストリエントリのコピー
			{return (tRegCopyValueW(hkey, srcname, destname)?true:false);}

	private:
		HKEY hkey;
};

#ifdef _UNICODE
#define REG	REGW
#else  /* _UNICODE */
#define REG	REGA
#endif /* _UNICODE */

#endif /* __cplusplus */

#endif /* MYLIB__ISREGCLASS__ */
