//--------------------------------------------------------------------------------
//
//【IMEのON/OFF】
//
//(SDK/MFC)
/////////////////////////////////////////////////////////////////////////////
#include "imm.h"
/////////////////////////////////////////////////////////////////////////////
// IMEをON／OFFする
// hWnd：目的のウィンドウハンドル
// bOn：TRUE…ON／FALSE…OFF

void ImeOn(HWND hWnd, BOOL bOn)
{
	// ハンドルを取得する
	HIMC hIMC = ImmGetContext(hWnd) ;

	// IMEのON／OFF
	ImmSetOpenStatus(hIMC, bOn) ;

	// 取得したハンドルを開放する
	ImmReleaseContext(hWnd, hIMC) ;
}

//--------------------------------------------------------------------------------
//
//【IMEの状態を取得する】
//
//(SDK/MFC)
/////////////////////////////////////////////////////////////////////////////
#include "imm.h"
/////////////////////////////////////////////////////////////////////////////
// IMEの状態を返す
// 戻り値：TRUE…IME ON／FALSE…IME OFF

BOOL IsImeOn(HWND hWnd)
{
	// hWndは目的のウィンドウハンドル
	HIMC hIMC = ImmGetContext(hWnd) ;

	// IMEの状態取得
	BOOL bResult = ImmGetOpenStatus(hIMC) ;

	// 取得したハンドルを開放する
	ImmReleaseContext(hWnd, hIMC) ;

	return bResult ;
}

//--------------------------------------------------------------------------------
//
//【特定のウィンドウでIMEを起動できないようにする】
//
// IMEを起動できなくしたい ウィンドウのハンドルをhWndとすると

	ImmAssociateContext(hWnd, NULL) ; 

//--------------------------------------------------------------------------------
//
//【途中でアプリケーションを終了させる】
//
//(SDK)
/////////////////////////////////////////////////////////////////////////////
{
	// hWndはメインウィンドウのハンドル
	PostMessage(hWnd, WM_CLOSE, 0, 0) ;
}

//(MFC)
/////////////////////////////////////////////////////////////////////////////
{
	AfxGetMainWnd()->PostMessage(WM_CLOSE) ;
}

//--------------------------------------------------------------------------------
//
//【ウィンドウ間で文字列の送信】
//
//●送り側
//(SDK/MFC)
/////////////////////////////////////////////////////////////////////////////
// 文字列送信
void SendText(HWND hwndTo, LPCTSTR lpszText)
{
	COPYDATASTRUCT cds ;
	cds.dwData = 0 ;
	cds.lpData = (void*)lpszText ;
	cds.cbData = lstrlen(lpszText) + 1 ; // 終端のNULLも送る
	// 文字列送信
	SendMessage(hwndTo, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds) ;
}

//●受け側
//(SDK)
/////////////////////////////////////////////////////////////////////////////
// ウィンドウプロシージャ内のWM_COPYDATAハンドラ部分

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch(message){
		case WM_COPYDATA :
			HWND			 hwndFrom = (HWND)wParam ;
			COPYDATASTRUCT* pcds	 = (COPYDATASTRUCT*)lParam ;
			
			MessageBox(hWnd, (LPCTSTR)pcds->lpData, "", MB_OK) ;
			return 0 ;
		default :
			break ;
	}
	return (DefWindowProc(hWnd, message, wParam, lParam)) ;
}

//(MFC)
/////////////////////////////////////////////////////////////////////////////
// クラスウィザードで追加されたWM_COPYDATAハンドラ

BOOL CMainFrame::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct) 
{
	MessageBox((LPCTSTR)pCopyDataStruct->lpData) ;
	return CFrameWnd::OnCopyData(pWnd, pCopyDataStruct) ;
}

//--------------------------------------------------------------------------------
//
//【NTか95かを判別する】
//
//(SDK/MFC)
/////////////////////////////////////////////////////////////////////////////
{
	OSVERSIONINFO osInfo ;
	osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO) ;
	GetVersionEx(&osInfo) ;
	if(osInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS){
		// Windows 95の時の処理
	}
	else if(osInfo.dwPlatformId == VER_PLATFORM_WIN32_NT){
		// Windows NTの時の処理
	}
}

//--------------------------------------------------------------------------------
//
//【ショートカットの作り方】
//
//(MFC)
/////////////////////////////////////////////////////////////////////////////
#include "shlobj.h"

void CTestDialog::OnTest() 
{
	CString strTarget ;
	CString strLink ;

	m_ed1.GetWindowText(strTarget) ;
	strLink = strTarget ;
	strLink += "のショートカット.lnk" ;

	CreateLinkFile(strLink, "", strTarget) ;
}

/////////////////////////////////////////////////////////////////////////////
// ショートカットを作成する関数
BOOL CreateLinkFile(LPCTSTR lpszShortcutFile,	// 作成する[*.lnk]のフルパス名
					LPCTSTR lpszDescription,	// ディスクリプション名
					LPCTSTR lpszTargetFile)		// リンク元のファイルのフルパス名
{
	BOOL bRet = FALSE ;
	HRESULT hResult ;
	IShellLink* psl ; 

	// COMの初期化
	CoInitialize(NULL) ;
	// IShellLink インターフェースの取得
	hResult = CoCreateInstance(
							CLSID_ShellLink,
							NULL, CLSCTX_INPROC_SERVER,
							IID_IShellLink,
							(void **)&psl) ;
	if(SUCCEEDED(hResult)){
		IPersistFile* ppf ;

		// IPersistFileインターフェースの取得
		hResult = psl->QueryInterface(IID_IPersistFile, (void **)&ppf) ;
		if(SUCCEEDED(hResult)){
			WCHAR wszShortcutFile[MAX_PATH] ; // ユニコード用のバッファ

			// リンク元のファイルのパスをセットする
			hResult = psl->SetPath(lpszTargetFile) ;
			if(SUCCEEDED(hResult)){
				// ショートカットファイルのディスクリプションをセット
				hResult = psl->SetDescription(lpszDescription) ;
				if(SUCCEEDED(hResult)){
					MultiByteToWideChar(CP_ACP, 0, lpszShortcutFile, -1, wszShortcutFile, MAX_PATH) ;
					hResult = ppf->Save(wszShortcutFile, TRUE) ;
					if(SUCCEEDED(hResult)) 
						bRet = TRUE ;
				}
			}
			ppf->Release() ;
		}
		psl->Release() ;
	}

	CoUninitialize() ;

	return bRet ;
}

//--------------------------------------------------------------------------------
//
//【NumLockのON/OFF】
//
//(SDK/MFC)
/////////////////////////////////////////////////////////////////////////////
{
	// NumLock押下
	keybd_event(VK_NUMLOCK, 0, 0, 0) ;
	keybd_event(VK_NUMLOCK, 0, KEYEVENTF_KEYUP, 0) ;
}

//--------------------------------------------------------------------------------
//
//【MFCでのSystemImageListの使い方】
//
//(MFC)
/////////////////////////////////////////////////////////////////////////////
{
	SHFILEINFO shfi ;
	// システムイメージリストのハンドルを取得
	HIMAGELIST hSystemImageList = (HIMAGELIST)SHGetFileInfo(………) ;

	CImageList imagelist ;
	imagelist.Attach(hSystemImageList) ;
	// 必要な処理
			:
			:
	// 処理が終わったら、DestroyされないためにDetachする
	imagelist.Detach() ;
}

//--------------------------------------------------------------------------------
//
//【長い処理をする時の対策】
//
//(SDK/MFC)
/////////////////////////////////////////////////////////////////////////////
void	YieldMessage()
{
	MSG	msg ;
	if(PeekMessage(&msg, (HWND)NULL, 0, 0, PM_REMOVE)){
		TranslateMessage(&msg) ;
		DispatchMessage(&msg) ;
	}
}

//--------------------------------------------------------------------------------
//
//【現在のユーザ名を取得する】
//
//(SDK/MFC)
/////////////////////////////////////////////////////////////////////////////
{
	char szUserName[256] ;
	DWORD dwBufferSize = 256 ;

	// ユーザ名の取得
	GetUserName(szUserName, &dwBufferSize) ;

	MessageBox(NULL, szUserName, "現在のユーザ名", MB_OK) ;
}

//--------------------------------------------------------------------------------
//
//【デスクトップのフォルダ名取得】
//
#include "winnetwk.h"
#include "shlobj.h"

//(SDK)
/////////////////////////////////////////////////////////////////////////////
{
	char szPath[MAX_PATH];
	ITEMIDLIST* pidl;
	IMalloc* pMalloc;

	if(SUCCEEDED(SHGetMalloc(&pMalloc))){
		SHGetSpecialFolderLocation(GetDesktopWindow(), CSIDL_DESKTOP, &pidl) ;
		SHGetPathFromIDList(pidl, szPath) ;

		MessageBox(NULL, szPath, "デスクトップのフォルダ", MB_OK) ;

		pMalloc->lpVtbl->Free(pMalloc, pidl) ;
		pMalloc->lpVtbl->Release(pMalloc) ;
	}
}

//(MFC)
/////////////////////////////////////////////////////////////////////////////
{
	char szPath[MAX_PATH] ;
	ITEMIDLIST* pidl ;
	LPMALLOC pMalloc ;

	if(SUCCEEDED(SHGetMalloc(&pMalloc))){
		SHGetSpecialFolderLocation(::GetDesktopWindow(), CSIDL_DESKTOP, &pidl) ;
		SHGetPathFromIDList(pidl, szPath) ;

		::MessageBox(NULL, szPath, "デスクトップのフォルダ", MB_OK) ;

		pMalloc->Free(pidl) ;
		pMalloc->Release() ;
	}
}

//--------------------------------------------------------------------------------
//
//【解像度を切り替える】
//
//(SDK)
/////////////////////////////////////////////////////////////////////////////
// ダイアログプロシージャ内のWM_INITDIALOGハンドラ部分

LRESULT CALLBACK TestDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch(message){
		case WM_INITDIALOG :
			DEVMODE devm ;
			char szText[256] ;
			DWORD dwModeIndex ;
			HWND hwndListBox = GetDlgItem(hDlg, IDC_LISTBOX) ;

			// 使用可能なディスプレイモードを列挙
			for(dwModeIndex=0 ; dwModeIndex < 64 ; dwModeIndex++){
				if(!EnumDisplaySettings(NULL, dwModeIndex, &devm))
					break ;
				wsprintf(szText, "[%2d] %dbitｶﾗｰ, %4d x %4d, "
						"dmDisplayFlags=%d, 周波数 %d",
						dwModeIndex, devm.dmBitsPerPel, devm.dmPelsWidth,
						devm.dmPelsHeight, devm.dmDisplayFlags, devm.dmDisplayFrequency) ;
				// リストボックスにディスプレイモードを表示
				SendMessage(hwndListBox, LB_ADDSTRING, 0, (LPARAM)szText) ;
			}
			return TRUE ;
		default :
			break ;
	}
	return FALSE ;
}
/////////////////////////////////////////////////////////////////////////////
void OnTest(HWND hWnd)
{
	DEVMODE devm ;
	HWND hwndListBox = GetDlgItem(hWnd, IDC_LISTBOX) ;

	// リストボックスで選択したインデックスを取得
	int nSelected = SendMessage(hwndListBox, LB_GETCURSEL, 0, 0) ;
	
	// ディスプレイモードの取得
	if(EnumDisplaySettings(NULL, nSelected, &devm)){
		// ディスプレイモードを変更
		ChangeDisplaySettings(&devm, 0) ;
	}
}

//(MFC)
/////////////////////////////////////////////////////////////////////////////
// WM_INITDIALOGハンドラ

BOOL CTestDialog::OnInitDialog()
{
	CDialog::OnInitDialog();

		:
		:

	DEVMODE devm ;
	char szText[256] ;

	// 使用可能なディスプレイモードを列挙
	for(DWORD dwModeIndex=0 ; dwModeIndex < 64 ; dwModeIndex++){
		if(!EnumDisplaySettings(NULL, dwModeIndex, &devm))
			break ;
		wsprintf(szText, "[%2d] %dbitｶﾗｰ, %4d x %4d, "
				"dmDisplayFlags=%d, 周波数 %d",
				dwModeIndex, devm.dmBitsPerPel, devm.dmPelsWidth,
				devm.dmPelsHeight, devm.dmDisplayFlags, devm.dmDisplayFrequency) ;
		// リストボックスにディスプレイモードを表示
		// m_wndListBoxはCListBox型のオブジェクト
		m_wndListBox.AddString(szText) ;
	}
	return TRUE ;	// TRUE を返すとコントロールに設定したフォーカスは失われません。
}
/////////////////////////////////////////////////////////////////////////////
void CTestDialog::OnTest() 
{
	DEVMODE devm ;
	// リストボックスで選択したインデックスを取得
	int nSelected = m_wndListBox.GetCurSel() ;
	
	// ディスプレイモードの取得
	if(EnumDisplaySettings(NULL, nSelected, &devm)){
		// ディスプレイモードを変更
		ChangeDisplaySettings(&devm, 0) ;
	}
}

//--------------------------------------------------------------------------------
//
//【フォントの設定の仕方】
//
//(SDK)
/////////////////////////////////////////////////////////////////////////////
// ダイアログプロシージャ

LRESULT CALLBACK TestDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch(message){
		case WM_INITDIALOG :
			HWND hwndStatic = GetDlgItem(hDlg, IDC_STATIC1) ;

			// フォントの作成
			g_hFont = CreateFont(20,0,0,0,FW_NORMAL,FALSE,FALSE,0,SHIFTJIS_CHARSET,
				OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
				DEFAULT_PITCH,"ＭＳ Ｐゴシック") ;
			// フォントの設定
			SendMessage(hwndStatic, WM_SETFONT, (WPARAM)g_hFont, MAKELPARAM(FALSE,0)) ;
			return TRUE ;
		case WM_DESTROY :
			// フォントの削除
			DeleteObject(g_hFont) ;
			return 0 ;
		default :
			break ;
	}
	return FALSE ;
}

//(MFC)
/////////////////////////////////////////////////////////////////////////////
// コンストラクタ
CTestDialog::CTestDialog()
{
	// フォントの作成
	// m_fontはCFontオブジェクトでCTestDialogのメンバ
	m_font.CreateFont(20,0,0,0,FW_NORMAL,FALSE,FALSE,0,
		SHIFTJIS_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
		DEFAULT_PITCH,"ＭＳ Ｐゴシック") ;
}

/////////////////////////////////////////////////////////////////////////////
// クラスウィザードによってインプリメントされたWM_INITDIALOGハンドラ
CTestDialog:OnInitDialog()
{
	CDialog::OnInitDialog();

	// ここでコントロールにフォントをセット
	// m_staticはCStaticオブジェクト
	m_static.SetFont(&m_font) ;

	return TRUE ;
}

//--------------------------------------------------------------------------------
//
//【仮想画面で高速描画】
//
//(MFC)
/////////////////////////////////////////////////////////////////////////////
//[TestView.h]
/////////////////////////////////////////////////////////////////////////////
class CTestView : public CView
{
		:
		:

	CDC m_dcBuffer ;
	CBitmap m_bmpBuffer ;

	void BufferInit() ;
	void BufferDraw(CDC* pDC) ;
		:
		:
}
/////////////////////////////////////////////////////////////////////////////
//[TestView.cpp]
/////////////////////////////////////////////////////////////////////////////
// 仮想画面の作成
void CTestView::BufferInit()
{
	CRect rcClient ;
	GetClientRect(rcClient) ;
	CClientDC dc(this) ;
	// m_dcBufferはCDC型のメンバ変数
	m_dcBuffer.CreateCompatibleDC(&dc) ;
	// m_bmpBufferはCBitmap型のメンバ変数
	m_bmpBuffer.CreateCompatibleBitmap(&dc, rcClient.Width(), rcClient.Height()) ;
	m_dcBuffer.SelectObject(&m_bmpBuffer) ;

	m_bBufDraw = FALSE ;
}
/////////////////////////////////////////////////////////////////////////////
// 仮想画面への描画(従来のOnDrawに相当)
void CTestView::BufferDraw(CDC* pDC)
{
	// 必要な描画処理を行う
}
/////////////////////////////////////////////////////////////////////////////
// 画面への描画は仮想画面（ビットマップ）の転送のみ
void CTestView::OnDraw(CDC* pDC)
{
	CRect rectClip ;
	// 描画すべき領域の取得
	int nClip = pDC->GetClipBox(&rectClip) ;
	if(nClip == ERROR || nClip == NULLREGION)
		return ;

	pDC->BitBlt(rectClip.left, rectClip.top, rectClip.Width(), rectClip.Height(),
			&m_dcBuffer, rectClip.left, rectClip.top, SRCCOPY) ;
}
/////////////////////////////////////////////////////////////////////////////
// クラスウィザードで追加したOnInitialUpdate()関数
void CTestView::OnInitialUpdate() 
{
	CView::OnInitialUpdate();
	
	// 仮想画面の初期化
	BufferInit() ;	
}

//--------------------------------------------------------------------------------
//
//【現在の日付と時刻を取得】
//
//(SDK/MFC)
/////////////////////////////////////////////////////////////////////////////
{
	SYSTEMTIME st ;
	char szData[256] ;
	// 現在時刻の取得
	GetLocalTime(&st) ;
	// データの作成
	wsprintf(szData, TEXT("%d/%02d/%02d %02d:%02d:%02d"),
		st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond) ;
}

//--------------------------------------------------------------------------------
//
//【次のコントロールに移動】
//
//(SDK/MFC)
/////////////////////////////////////////////////////////////////////////////
{
	// 次のコントロールに移動
	keybd_event(VK_TAB, 0, 0, 0) ;
	keybd_event(VK_TAB, 0, KEYEVENTF_KEYUP, 0) ;
}

{
	// 前のコントロールに移動
	keybd_event(VK_SHIFT, 0, 0, 0) ;
	keybd_event(VK_TAB,   0, 0, 0) ;
	keybd_event(VK_TAB,   0, KEYEVENTF_KEYUP, 0) ;
	keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0) ;
}

//--------------------------------------------------------------------------------
//
//【レジストリの使い方】
//
//(SDK)
/////////////////////////////////////////////////////////////////////////////
//[Register.h]
/////////////////////////////////////////////////////////////////////////////
void SetRegistryKey(LPCTSTR lpszRegistryKey) ;
BOOL WriteRegInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, int nValue) ;
UINT GetRegInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, int nDefault) ;
BOOL WriteRegString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszValue) ;
void GetRegString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszDefault, 
					LPTSTR lpReturnedString, DWORD nSize) ;

HKEY EmxCreateRegKey(LPCTSTR lpszKey, HKEY hKey) ;
BOOL EmxSetRegDword(LPCTSTR lpszValueName, DWORD dwData, HKEY hKey) ;
BOOL EmxGetRegDword(LPCTSTR lpszValueName, DWORD* lpdwBuff, HKEY hKey) ;
BOOL EmxSetRegString(LPCTSTR lpszValueName, LPCSTR lpcszString, HKEY hKey) ;
BOOL EmxGetRegString(LPCTSTR lpszValueName, LPTSTR lpReturnedString, DWORD nSize, HKEY hKey) ;

/////////////////////////////////////////////////////////////////////////////
//[Register.c]
/////////////////////////////////////////////////////////////////////////////
#include "windows.h"
#include "Registry.h"

static HKEY g_hKey = NULL ;
/////////////////////////////////////////////////////////////////////////////
//
// ルートキーの設定
//

void SetRegistryKey(LPCTSTR lpszRegistryKey)
{
	char szOpenRegistry[MAX_PATH] = {"Software\\"} ;

	lstrcat(szOpenRegistry, lpszRegistryKey) ;
	g_hKey = EmxCreateRegKey(szOpenRegistry, HKEY_CURRENT_USER) ;
}
/////////////////////////////////////////////////////////////////////////////
//
// int値の書き込み
//

BOOL WriteRegInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, int nValue)
{
	HKEY hOpenKey ;
	
	if(g_hKey){
		hOpenKey = EmxCreateRegKey(lpszSection, g_hKey) ;
		if(hOpenKey)
			return EmxSetRegDword(lpszEntry, nValue, hOpenKey) ;
	}
	return FALSE ;
}
/////////////////////////////////////////////////////////////////////////////
//
// UINT値の取得
//

UINT GetRegInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, int nDefault)
{
	UINT uResult = nDefault ;
	HKEY hOpenKey ;
	
	if(g_hKey){
		hOpenKey = EmxCreateRegKey(lpszSection, g_hKey) ;
		if(hOpenKey){
			if(!EmxGetRegDword(lpszEntry, &uResult, hOpenKey))
				uResult = nDefault ;
		}
	}
	return uResult ;
}
/////////////////////////////////////////////////////////////////////////////
//
// 文字列の書き込み
//

BOOL WriteRegString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszValue)
{
	HKEY hOpenKey ;
	
	if(g_hKey){
		hOpenKey = EmxCreateRegKey(lpszSection, g_hKey) ;
		if(hOpenKey)
			return EmxSetRegString(lpszEntry, lpszValue, hOpenKey) ;
	}
	return FALSE ;
}
/////////////////////////////////////////////////////////////////////////////
//
// 文字列の取得
//

void GetRegString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszDefault, 
					LPTSTR lpReturnedString, DWORD nSize)
{
	HKEY hOpenKey ;
	
	if(g_hKey){
		hOpenKey = EmxCreateRegKey(lpszSection, g_hKey) ;
		if(hOpenKey){
			if(EmxGetRegString(lpszEntry, lpReturnedString, nSize, hOpenKey))
				return ;
		}
	}
	lstrcpy(lpReturnedString, lpszDefault) ;
}
/////////////////////////////////////////////////////////////////////////////
//
// キーの作成
//

HKEY EmxCreateRegKey(LPCTSTR lpszKey, HKEY hKey)
{
	DWORD dwDisposition ;
	HKEY hOpenedKey ;

	if(RegCreateKeyEx(hKey, lpszKey, 0, "", REG_OPTION_NON_VOLATILE, 
		KEY_ALL_ACCESS, NULL, &hOpenedKey, &dwDisposition) != ERROR_SUCCESS)
			hOpenedKey = NULL ;
	// 失敗したらNULLを返す
	return hOpenedKey ;
}
/////////////////////////////////////////////////////////////////////////////
//
// DWORD値の書き込み
//

BOOL EmxSetRegDword(LPCTSTR lpszValueName, DWORD dwData, HKEY hKey)
{
	DWORD	dwBuffer = dwData ;

	if(RegSetValueEx(hKey, lpszValueName, 0, REG_DWORD, 
		(LPBYTE)&dwBuffer, sizeof(DWORD)) != ERROR_SUCCESS)
			return FALSE ;

	return TRUE ;
}
/////////////////////////////////////////////////////////////////////////////
//
// DWORD値の取得
//

BOOL EmxGetRegDword(LPCTSTR lpszValueName, DWORD* lpdwBuff, HKEY hKey)
{
	DWORD	dwType ;
	DWORD	dwBufferSize = sizeof(DWORD) ;

	//ASSERT(g_hKey);
	if(RegQueryValueEx(hKey, lpszValueName, 0, &dwType,
		(LPBYTE)lpdwBuff, &dwBufferSize) != ERROR_SUCCESS)
		return FALSE ;

	return TRUE ;
}
/////////////////////////////////////////////////////////////////////////////
//
// 文字列の書き込み
//

BOOL EmxSetRegString(LPCTSTR lpszValueName, LPCSTR lpcszString, HKEY hKey)
{
	DWORD	dwBufferSize = lstrlen(lpcszString) ;

	if(RegSetValueEx(hKey, lpszValueName, 0, REG_SZ,
		(LPBYTE)lpcszString, dwBufferSize) != ERROR_SUCCESS)
			return FALSE ;

	return TRUE ;
}
/////////////////////////////////////////////////////////////////////////////
//
// 文字列の取得
//

BOOL EmxGetRegString(LPCTSTR lpszValueName, LPTSTR lpReturnedString, DWORD nSize, HKEY hKey)
{
	DWORD	dwType ;
	DWORD	dwBufferSize = nSize ;

	if(RegQueryValueEx(hKey, lpszValueName, 0, &dwType,
		(LPBYTE)lpReturnedString, &dwBufferSize) != ERROR_SUCCESS)
			return FALSE ;

	return TRUE ;
}

//--------------------------------------------------------------------------------
//
//【クライアント領域をキャプチャーしてクリップボードにコピーする】
//

{
	CDC memDC ;
	CBitmap bm ;
	CRect rect ;

	// クライアント領域の矩形を取得します
	GetClientRect(&rect) ;

	// デバイスコンテキストを取得します
	CDC* pDC = GetDC() ;

	// メモリデバイスコンテキストを作成します。
	memDC.CreateCompatibleDC(pDC) ;

	// ビットマップを作成します
	bm.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height()) ;

	// ビットマップオブジェクトを選択します。
	// (後で元に戻すために現在のオブジェクトをとっておきます）
	CBitmap* pOldBmp = memDC.SelectObject(&bm) ;

	// 画面イメージをコピーします
	memDC.StretchBlt(0, 0, rect.Width(), rect.Height(), pDC, 0, 0, rect.Width(), rect.Height(), SRCCOPY) ;

	// クリップボードをオープンします
	OpenClipboard() ;

	// クリップボードをクリアします
	::EmptyClipboard() ;

	// クリップボードにビットマップをコピーします
	::SetClipboardData(CF_BITMAP, bm.GetSafeHandle()) ;

	// クリップボードをクローズします
	::CloseClipboard() ;

	// オブジェクトを切り離します
	bm.Detach() ;

	// オブジェクトを元に戻します。
	memDC.SelectObject(pOldBmp) ;
}

//--------------------------------------------------------------------------------
//
//【タスクバーの位置を取得する】
//
// ウィンドウクラス名に"Shell_TrayWnd"を指定してウィンドウを検索することによりタスクバーのウィンドウを検索できます。
{
	CRect rect ;
	CWnd* pWnd = FindWindow(_T("Shell_TrayWnd"), NULL) ;
	if(pWnd){
		pWnd->GetWindowRect(&rect) ;
		TRACE(_T("タスクバーの位置(left, top, right, bottom)は %d, %d, %d, %d です\n"),
						rect.left, rect.top, rect.right, rect.bottom) ;
	}
}

//--------------------------------------------------------------------------------
//
//【CRectTrackerクラスを使って矩形をマウスで移動させる】
//

// MFCのCRectTrackerクラスを使うと 矩形をマウスで簡単に移動させることができます。
// 以下に簡単なサンプルを示します。
// (1) AppWizardを使って プロジェクトRectTrackerTestを作成します。
//
// (2) クラスウィザードを使って、CRectTrackerTestViewクラスに メンバ変数 CRectTracker m_trackerを追加します。
// （ビュークラスのメンバとすべきかどうかは設計に依存すると思いますが、今回はCRectTrackerの説明だけのアプリケーションなのでとりあえずビュークラスのメンバとします。
//
// (3) CRectTrackerTestViewクラスのコンストラクタで m_trackerを初期化します。 
	m_tracker.m_rect.left = 10 ; // 左端の座標です
	m_tracker.m_rect.top = 10 ; // 上端の座標です
	m_tracker.m_rect.right = 101 ; // 右端の座標です
	m_tracker.m_rect.bottom = 101 ; // 下端の座標です

	m_tracker.m_nStyle |= CRectTracker::solidLine ; // 外の枠線のスタイルを指定します

// (4) CRectTrackerTestView::OnDraw(CDC* pDC)にm_trackerの描画処理を追加します 
	m_tracker.Draw(pDC) ;

// (5) クラスウィザードを使って、CRectTrackerTestViewクラスに WM_LBUTTONDOWNのメッセージハンドラを追加します。 
void CRectTrackerTestView::OnLButtonDown(UINT nFlags, CPoint point)
{
	// クリックされた位置がm_tracker内か検査します
	if(m_tracker.HitTest(point) < 0){
		// HitTest()の結果がマイナスの場合 クリックされた位置は
		// m_trackerの外側です
	}
	else{
		// トラッキング処理を行います
		m_tracker.Track(this, point, FALSE) ;
		// 再描画します
		InvalidateRect(NULL) ;
	}
	
	CView::OnLButtonDown(nFlags, point) ;
}

//--------------------------------------------------------------------------------
//
//【ステータスバーに文字を出力する】
//
//ステータスバーに文字を出力するにはCStatusBarクラスのSetPaneText()を使います。
{
	// メインフレームウィンドウのポインタを取得します

	CFrameWnd* pWnd = (CFrameWnd*)AfxGetApp()->m_pMainWnd ;

	// ステータスバーのポインタを取得します
	CStatusBar* pStatusBar = (CStatusBar*)pWnd->GetMessageBar() ;

	// それぞれのペインに文字を出力します
	pStatusBar->SetPaneText(0, _T("Pane 0")) ;
	pStatusBar->SetPaneText(1, _T("Pane 1")) ;
	pStatusBar->SetPaneText(2, _T("Pane 2")) ;
}

//--------------------------------------------------------------------------------
//
//【時間のかかる処理の間マウスカーソルを砂時計にする】
//
// 時間のかかる処理の間マウスカーソルを砂時計にするマウスカーソルを砂時計にするのは非常に簡単です。
// MFCのCWaitCursorクラスのオブジェクトを宣言するだけです。
// APIのSetCursor()を使ってカーソルを変更する方法もありますが、これだと自分でまた 元に戻さないといけません。
// CWaitCursorはデストラクタでカーソルを元に戻してくれるので、自分で元に戻す必要がありません。 
    
// この例ではxxx::foo()が呼ばれると、マウスカーソルが砂時計になり、xxx::foo()を抜けると元に戻ります。
void Test::foo()
{    
	CWaitCursor wait ;
	// (時間のかかる処理)
}
     

//--------------------------------------------------------------------------------
//
//【特定のウィンドウ上でカーソルを変更する】
//
// CWnd::OnSetCursor()をオーバーライドして ::SetCursor()を呼び出します。 例えばリソースエディタで作成したマウスカーソル(IDC_XXX)に変更したい場合は
// OnSetCursor()を以下のようにオーバーライドします。 
CTestWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)  
{ 
	::SetCursor(AfxGetApp()->LoadCursor(IDC_XXX)) ; 
	return TRUE ; 
} 

//--------------------------------------------------------------------------------
//
//【起動引数を取得するには？】
//

// CWinAppのメンバ変数 m_lpCmdLineに格納されています。 
BOOL CTestApp::InitInstance()
{
	if(m_lpCmdLine[0] == _T('\0')){
		// 新しい (空の) ドキュメントを作成します。
		OnFileNew() ;
	}
	else{
		// 最初のコマンド ライン引数として渡されたファイルを開きます。
		OpenDocumentFile(m_lpCmdLine) ;
	}
}

//--------------------------------------------------------------------------------
//
//【アプリケーションクラスのオブジェクトにアクセスするには？】
//

// AfxGetApp()を使うとプログラムのどこからでもアプリケーションオブジェクトのポインタが取得できます。
{
	// アプリケーションメインウィンドポインタを取得
	CWnd* m_pMainWnd = AfxGetApp()->m_pMainWnd ;
	// アプリケーションメインウィンドポインタからメインフレームを取得
	CMainFrame* pMain = (CMainFrame*)m_pMainWnd ;
	// 次MDIを取得
	pMain->MDINext() ;
}

//--------------------------------------------------------------------------------
//
//【メインウィンドウのサイズを変えるには?】
//

//	AfxGetMainWnd()->MoveWindow()で変更できます。 
{
	RECT rcWindow ;
	// レジストリから前回のウィンドウ位置を取得
	// SetRegistryKey()の引数はプログラマ固有の文字列にする
	SetRegistryKey("ComposerName\\FooApp") ;
	rcWindow.left	= GetRegInt("Settings", "left", 0) ;
	rcWindow.top	= GetRegInt("Settings", "top", 0) ;
	rcWindow.right	= GetRegInt("Settings", "right", 200) ;
	rcWindow.bottom	= GetRegInt("Settings", "bottom", 150) ;
	// ウィンドウ位置修正
	AfxGetMainWnd()->MoveWindow(rcWindow.left, rcWindow.top,
		rcWindow.right - rcWindow.left, rcWindow.bottom - rcWindow.top, FALSE) ;

//--------------------------------------------------------------------------------
//
//【拡張子にアプリケーションを関連付けるには?】
//

//	CWinApp::RegisterShellFileTypes()を使います。 

//--------------------------------------------------------------------------------
//
//【現在アクティブなウィンドウを取得するには？】
//
//	CWnd::GetForegroundWindow()を使います。 
{
	CWnd *p = GetForegroundWindow() ;
}

//--------------------------------------------------------------------------------
//
//【ツールバーの有効／無効を切り替えるには？】
//
	UPDATE_COMMAND_UIのメッセージハンドラを追加し、pCmdUI->Enable()で切り替えます。 

//--------------------------------------------------------------------------------
//
//【レジストリにアクセスする】
//
// まずはじめにCWinAppクラスのSetRegistryKey()でレジストリキーを設定します。
// その後、CWinAppクラスの以下のメンバ関数を使ってレジストリ値の取得/設定ができます。 
	GetProfileString 
	GetProfileInt 
	WriteProfileString 
	WriteProfileInt 

//--------------------------------------------------------------------------------
//
//【SendMessage()とPostMessage()の違いは？】
//

	SendMessage()の場合、相手がそのメッセージを処理するまで自分に制御が戻りません。
	PostMessage()の場合 メッセージをメッセージキューに入れるだけですぐにリターンします。

//--------------------------------------------------------------------------------
//
//【自アプリのパスを取得するには？】
//

	GetModuleFileName()を使います。自アプリのパスを取得する場合は第一引数は NULLでいいです。

//--------------------------------------------------------------------------------
//
//【拡張子に関連付けられたアプリケーションを取得するには？】
//
	FindExecutable()を使います 

//--------------------------------------------------------------------------------
//
//【ドライブのタイプを取得するには？】
//
	GetDriveType()を使います。【ドライブの存在チェック】を参照。 

//--------------------------------------------------------------------------------
//
//【ディスクの空き容量を取得するには？】
//
//	GetDiskFreeSpace[Ex]()を使います。 
//====================================================================
//  int CheckDiskFreeSpace(char *name, ULONG Warning)
//--------------------------------------------------------------------
//	機能   : ﾃﾞｨｽｸの空き容量をﾁｪｯｸする｡
//	引数   : char *name
//		ﾃｷｽﾄﾌｧｲﾙ名
//		ULONG Warning
//		警告を出す残り容量（ﾒｶﾞﾊﾞｲﾄ）
//--------------------------------------------------------------------
//	戻り値 : DISK_OK      = 正常終了(0)
//           DISK_WARNING = 容量警告(1)
//           DISK_ERR     = 書込不可能(-1)
//====================================================================
int CModemPort::CheckDiskFreeSpace(char *name, ULONG Warning)
{
	BOOL success ;
	ULARGE_INTEGER freeBytesToCaller, totalBytes, freeBytes ;
	ULONG WarningBytes ;
	char  drive[4] ;
	
	// ﾄﾞﾗｲﾌﾞを取得する。
	drive[0] = '\0' ;
	strncat(drive, name, 3) ;
	
	// 空きﾃﾞｨｽｸｻｲｽﾞを取得する。
	success = GetDiskFreeSpaceEx(
				drive,
				&freeBytesToCaller,
				&totalBytes,
				&freeBytes) ;
	if(!success)
		return DISK_ERR ;
	
	// 容量警告をﾊﾞｲﾄ単位に変換する。
	WarningBytes = Warning * 1024 * 1024 ;
	
	// 容量ﾁｪｯｸをする
	if (freeBytes.QuadPart <= WarningBytes)
		return DISK_WARNING ;
	else
		return DISK_OK ;
}

//--------------------------------------------------------------------------------
//
//【特定のキー（例えばシフトキー）が押されている状態か判断するには？】
//
//	GetKeyState()を使います。
//	以下は シフトキーが押されているかどうか判断するプログラムのサンプルです。
{
	if(GetKeyState(VK_SHIFT) & 0x0100){
		// シフトキーが押されている
	}
	else{
		// シフトキーは押されていない
	}
}

//--------------------------------------------------------------------------------
//
//【コンピュータ名を取得する】
//
// GetComputerName()を使ってコンピュータ名を取得できます。
// 以下サンプルプログラムです。 
{
	TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1] ;
	DWORD dwNameLen = MAX_COMPUTERNAME_LENGTH ;
	
	if(!::GetComputerName(szComputerName, &dwNameLen))
		TRACE(_T("コンピュータ名を取得できませんでした\n")) ;
	else
		TRACE(_T("コンピュータ名は %s です\n"),szComputerName) ;
}