FAQ:WinAPI, VCPP Part 3 — различия между версиями

CString m_Temp;
 
m_Temp.LoadString(ID_MYSTRING);

// заполняем структуру LVITEM
LVITEM lvItem;
 
memset(&lvItem, 0, sizeof(lvItem));
 
lvItem.mask = LVIF_IMAGE; // меняться будет картинка
lvItem.iItem = ...; // индекс элемента списка (Zero-based)
lvItem.iSubItem	= 0;
lvItem.iImage = ...; //индекс иконки (из списка элемента)
 
pList->SetItem(&lvItem);

class Class2; // предопределение Class2
 
class Class1
{
	Class2* m_p2; // компилятор разрешит объявление указателя Class2*
 
	void F1(Class2* p); //компилятор разрешит объявление указателя Class2*
	void F2(Class1* p);
};

#include "class1.h"
#include "class2.h"
 
void Class1::F1(Class2* p)
{
	// ...
}
 
void Class1::F2(Class1* p)
{
	// ...
}

class Class1; // предопределение Class1
 
Class2
{
	Class1* m_p1; // компилятор разрешит объявление указателя Class1*
 
	void F3(Class1* p); // компилятор разрешит объявление указателя Class1*
};

#include "class2.h"
#include "class1.h"
 
void Class2::F3(Class1* p)
{
	// ...
}

void CMyWnd::некая_процедура()
{
	// для MFC
	CEdit* ed = (CEdit* ) GetDlgItem(ID_EDIT1);
	HWND hwnd = ed->GetSafeHwnd();
	if (hwnd)
	{
		// ...
	}
 
	// для Win32 API
	HWND hwnd = GetDlgItem(m_hWnd, ID_EDIT1);
	if (hwnd)
	{
		// ...
	}
}

pParent->PostMessage(WM_CLOSE);

::PostMessage(pParent->m_hWnd, WM_CLOSE, (WPARAM)0, (LPARAM)0);

// указатель на будущий буфер с BSTR.
// По сути, BSTR определён как typedef WCHAR* BSTR;
// то есть - указатель на 16-битный символ юникод.
BSTR bstrHE = 0;
 
// строка для конвертации
CString Str = "мой текст";
 
// Выделяем память и загружаем адрес блока в bstrHE
bstrHE = Str.AllocSysString();
 
// ...	
// тут работаем с bstrHE[]
// ...
 
// освобождаем память
SysFreeString(bstrHE);

void CPlayersPropsDialog::OnClose() 
{
	CDialog::OnClose();
	CDialog::OnCancel(); // добавлено
}

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment

::SendMessage(HWND_BROADCAST, WM_SETTINGCHANGE, 0, 0);

// глобальная переменная или член класса CMyDlg,
// инициализированный в OnInitDialog()
CBrush br(RGB(0, 0, 0));
 
HBRUSH CMyDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) 
{
	HBRUSH hbr = CMyDlg::OnCtlColor(pDC, pWnd, nCtlColor);
 
	// фон диалога (или View)
	if (nCtlColor == CTLCOLOR_DLG)
	{
		return (HBRUSH)br;
	}
 
	// фон элементов SCtatic, лежащих на форме (если нужно)
	if (nCtlColor == CTLCOLOR_STATIC)
	{
		// делаем фон текста статика прозрачным
		pDC->SetBkMode(TRANSPARENT);
		return (HBRUSH)br;
	}
 
	return hbr;
}

#include <afxpriv.h> // этот файл надо включить, там определёна WM_KICKIDLE
 
LRESULT CMyDialog::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
{
	if (message == WM_KICKIDLE)
	{
		// делаем апдейт для всех пунктов меню
		CMenu* pMainMenu = GetMenu();
		if (pMainMenu)
		{
			CCmdUI cmdUI;
			for (UINT n = 0; n < pMainMenu->GetMenuItemCount(); n++)
			{
				CMenu* pSubMenu = pMainMenu->GetSubMenu(n);
				if (!pSubMenu)
					continue;
 
				cmdUI.m_nIndexMax = pSubMenu->GetMenuItemCount();
				for (UINT i = 0; i < cmdUI.m_nIndexMax; i++)
				{
					cmdUI.m_nIndex = i;
					cmdUI.m_nID = pSubMenu->GetMenuItemID(i);
					cmdUI.m_pMenu = pSubMenu;
					cmdUI.DoUpdate(this, FALSE);
				}
			}
		}
	}
 
	return CDialog::DefWindowProc(message, wParam, lParam);
}

// этот обработчик уже добавлен визардом
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	if ( !CFrameWnd::PreCreateWindow(cs) )
		return FALSE;
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
 
	///////////////////////////////
	// добавленная часть
	{
		// убираем стиль
		cs.style& =~ WS_SYSMENU;
	}
	///////////////////////////////
 
	return TRUE;
}

// делаем кнопку неактивной
if (m_hWnd)
{
	CWnd* pw = 0;
	pw = GetDlgItem(IDC_1);
	if (pw)
	{
		pw->EnableWindow(0);
	}
}

virtual LRESULT WindowProc(
	UINT message,
	WPARAM wParam,
	LPARAM lParam 
);

LRESULT CMyEdit::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
{
	switch (message)
	{
		case WM_CHAR:
		{
			return 0;
		}
		break;
	}
 
	return CEdit::WindowProc(message, wParam, lParam);
}

// указатель на переменную-элемент управления
CListCtrl* pL = ...;
 
// получаем количество столбцов
int count = pL->GetHeaderCtrl()->GetItemCount();

// функция возвращант хендл иконки 
LRESULT SendMessage(hWnd, WM_GETICON, wParam, 0);
 
// hWnd == хендл окна приложения
// wParam == 
//	1)==ICON_BIG - получить большую иконку
//	2)==ICON_SMALL - получить маленькую иконку
//	3)==ICON_SMALL2 - получить маленькую иконку, если она определена
//				в приложении. Если её нет, то маленькую иконку, 
//				сгенерированную системой из большой иконки

// вырезает кусок строки
CString Mid(int nFirst) const;
CString Mid(int nFirst, int nCount) const;
 
// возвращает кусок строки (сначала или с конца)
CString Left(int nCount) const;
CString Right(int nCount) const;
 
// возвращает начальный кусок строки, в котором есть только
// символы из набора, представленного в lpszCharSet
CString SpanIncluding(LPCTSTR lpszCharSet) const;
 
// возвращает начальный кусок строки, в котором нет
// символов из набора, представленного в lpszCharSet
CString SpanExcluding(LPCTSTR lpszCharSet) const; 
 
// убирает "пробелоподобные" символы из самого начала строки.
// то есть - пробел, табуляцию (\t), возврат каретки, перевод строки (/r/n)
void TrimLeft();
 
// убирает все повторы символа из самого начала строки
void TrimLeft(TCHAR chTarget);
 
// убирает из самого начала строки все символа из набора lpszTargets 
void TrimLeft(LPCTSTR lpszTargets);
void TrimRight();
void TrimRight(TCHAR chTarget);
void TrimRight(LPCTSTR lpszTargets);
 
// поиск в строке
int Find(TCHAR ch) const;
int Find(LPCTSTR lpszSub) const;
int Find(TCHAR ch, int nStart) const;
int Find(LPCTSTR pstr, int nStart) const;
 
// поиск, начиная с конца
int ReverseFind(TCHAR ch) const;
 
// поиск позиции первого символа, одного из набора,
// представленного в lpszCharSet
int FindOneOf(LPCTSTR lpszCharSet) const;

pWnd->Invalidate(0);

pWnd->UpdateWindow();

CWnd* pWnd = ...; // окно, которое надо перерисовывать
 
for (int i = 0; i < 10000; i++)
{
	// меняется содержимое окна
	// ...
 
	// немедленная перерисовка
	pWnd->Invalidate(0);
	pWnd->UpdateWindow();
}

DWORD calltest()
{
	// будет выполнено только при первом вызове
	static DWORD callcount = 0;
	static DWORD str[1000] = {0}; 
 
	// будет выполняться каждый раз
	callcount++;
	return callcount;
}

HANDLE CreateFileMapping(
	HANDLE hFile, // хендл уже открытого файла
	LPSECURITY_ATTRIBUTES lpAttributes,
	DWORD flProtect, // способ открытия проекции
	DWORD dwMaximumSizeHigh, // размер файла (старшие 4 байта, обычно - 0)
	DWORD dwMaximumSizeLow, // размер файла (младшие 4 байта)
	LPCTSTR lpName
);

LPVOID MapViewOfFile(
	HANDLE hFileMappingObject, // хендл проекции
	DWORD dwDesiredAccess, // способ работы с проекцией
	DWORD dwFileOffsetHigh,
	DWORD dwFileOffsetLow, // смещение от начала файла (младшие 4 байта)
	SIZE_T dwNumberOfBytesToMap // длина в байтах (если 0 - то весь файл)
);

BOOL UnmapViewOfFile(
	LPCVOID lpBaseAddress // адрес, который вернула процедура MapViewOfFile
);

HANDLE hFile = ...; // хендл уже открытого файла
DWORD dwdFileLen = ...; // размер открытого файла
HANDLE hMapFile = 0; // хендл для проекции
 
// создаём проекцию "только для чтения"
hMapFile = ::CreateFileMapping(hFile, 0, PAGE_READONLY, 0, dwdFileLen, 0);
 
// хендл hFile можно закрыть уже здесь, в принципе,
// но мы сделаем это позже
 
// получаем доступ к проекции (тоже только для чтения)
BYTE* pbyFile = (BYTE*)::MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
 
///////////////////
// тут работаем с массивом pbyFile[dwdFileLen] как с обычным,
// только не забываем, что он открыт только для чтения
// ...
// ...
// ...
///////////////////
 
// отключаем файл данных от адресного пространства
UnmapViewOfFile(pbyFile);
 
// освобождаем хендл проекции
CloseHandle(hMapFile)
 
// освобождаем хендл открытого файла
CloseHandle(hFile);

CImageList m_ImageList;
CGridCtrL m_Grid1;
 
// ...
 
// неким образом создаётся список
m_ImageList.Create(...);
 
// ...
 
//вставляем в элемент управления
m_Grid1.SetImageList(&m_ImageList);

#include "atlconv.h"
#define HandleIsValid(H) (H != (HANDLE) - 1 && H != (HANDLE)0)
 
// *pDestDC - CDC, на который предполагается вывод картинки
// pchzFilePath - путь к файлу
// pWid - (возвращает) ширина картинки
// pHig - (возвращает) высота картинки
bool DrawBitmapFromFile(CDC* pDestDC, const char* pchzFilePath, int *pWid = 0, int *pHig = 0)
{
	bool result = false;
 
	if (pWid)
		*pWid = 0;
 
	if (pHig)
		*pHig = 0;
 
	int Wid = 0;
	int Hig = 0;
 
	IPicture* pPic = 0;
	try
	{
		IPicture* ptmpPic = 0;
		USES_CONVERSION;
		HRESULT hr;
 
		CString txt = pchzFilePath;
		hr = ::OleLoadPicturePath(
			const_cast<LPOLESTR>(T2COLE(txt)),
			0, 0, 0, IID_IPicture,
			reinterpret_cast<void **>(&ptmpPic)
			);
 
		if (hr == S_OK && ptmpPic)
		{
			pPic = ptmpPic;
		}
		else
		{
			throw 0;
		}
 
		OLE_XPOS_HIMETRIC cxSrc;
		OLE_YPOS_HIMETRIC cySrc;
 
		if (S_OK != pPic->get_Width(&cxSrc))
		{
			throw 0;
		}
 
		if (S_OK != pPic->get_Height(&cySrc))
		{
			throw 0;
		}
 
		Wid = cxSrc / 26;
		Hig = cySrc / 26;
 
		// рисуем
		if (S_OK != pPic->Render(pDestDC->GetSafeHdc(),
			0, Hig, Wid, -Hig, 0, 0, cxSrc, cySrc, 0))
		{
			throw 0;
		}
	}
	catch (...)
	{
		result = false;
	}
 
	if (pPic)
	{
		pPic->Release();
		pPic = 0;
	}
 
	if (pWid)
	{
		*pWid = Wid;
	}
 
	if (pHig)
	{
		*pHig = Hig;
	}
 
	return result;
}

//готовим данные
//выделяем из кучи память для данных
HANDLE hglbCopy = GlobalAlloc(GMEM_MOVEABLE,10);
if(!hglbCopy)return;
 
//получаем указатель
void* lpStr = GlobalLock(hglbCopy);
if(!lpStr)return;
 
//заполняем данные
strcpy((char*)lpStr,"my text");
 
//освобождаем указатель
GlobalUnlock(hglbCopy);
lpStr=0;
 
//открываем буфер обмена
OpenClipboard();
//очищаем
EmptyClipboard();
 
//текстовый формат
SetClipboardData(CF_TEXT,hglbCopy);
 
//закрываем буфер
CloseClipboard();

//Проверяем, что поддерживается нужный формат данных,
if(!IsClipboardFormatAvailable(CF_TEXT))return;
 
//открываем буфер обмена
OpenClipboard();
 
//достаём данные
 
//текстовый формат
HANDLE hglbCopy = GetClipboardData(CF_TEXT);
if(!hglbCopy)return;
 
//получаем указатель
void* lpStr = GlobalLock(hglbCopy);
if(!lpStr)return;
 
//читаем данные
char data[10];
memmove(data,lpStr,sizeof(data));
 
//освобождаем указатель
GlobalUnlock(hglbCopy);
lpStr=0;
 
//закрываем буфер
CloseClipboard();

BOOL CMyApp::InitInstance()
{
	//добыча полного имени экзешника
	CString csFullExeName;
	{
		CString csAppName=GetCommandLine();
		csAppName.Delete(0,1);
		csAppName.Replace('\"','\0');
		csFullExeName=(const char*)csAppName;
	}
	//теперь csFullExeName содержит искомый путь
 
	//...
	//...
}

#define def_exeNAMEup	"c:\\myprog_toupdate.exe"		//путь к старому файлу
#define def_exeNAMEdnld	"c:\\myprog_downloaded.exe"		//путь к новому файлу (уже "скачали":) )
#define def_keyUdate	"/update"
 
void CTESTFAQApp::UpdateItself()
{
	//добыча полного имени экзешника
	CString csFullExeName;
	{
		CString csAppName=GetCommandLine();
		csAppName.Delete(0,1);
		csAppName.Replace('\"','\0');
		csFullExeName=(const char*)csAppName;
	}
	//теперь csFullExeName - содержит искомый путь
 
	//делаем копию экзешника с другим именем
	CopyFile(csFullExeName,def_exeNAMEup,0);
 
	//передаём в параметры нового процесса ключ и путь к текущему файлу
	CString csParams=def_keyUdate;
	csParams+=" ";
	csParams+=csFullExeName;
 
	//запускаем копию
	STARTUPINFO si;
	PROCESS_INFORMATION pi;
	ZeroMemory(&si,sizeof(si));
	si.cb = sizeof(si);
	ZeroMemory(&pi,sizeof(pi));
	if(CreateProcess(def_exeNAMEup,def_keyUdate,0,0,0,0,0,0,&si,&pi))
	{
		//завершаем текущий процесс
		ExitFromMyApp();
	}
}
 
void CTESTFAQApp::ExitFromMyApp()
{
	exit(0);
}
 
BOOL CTESTFAQApp::InitInstance()
{
	//смотрим, не запущено ли для апдейта?
	CString txt;
	txt=m_lpCmdLine;
	if(txt.Find(def_keyUdate)==0)
	{
		//делаем айдейт
		txt.Replace(def_keyUdate,"");
		txt.TrimLeft();
 
		CString csFullExeName=txt;
 
		//берём откуда то уже скачанный файл обновления
		//...
		CString csFull_Downloaded_ExeName=def_exeNAMEdnld;
 
		//копируем файл (обновляем старый то есть)
		CopyFile(csFull_Downloaded_ExeName,csFullExeName,0);
 
		//запускаем обновлённого мученника
		STARTUPINFO si;
		PROCESS_INFORMATION pi;
		ZeroMemory(&si,sizeof(si));
		si.cb = sizeof(si);
		ZeroMemory(&pi,sizeof(pi));
		if(CreateProcess(csFullExeName,0,0,0,0,0,0,0,&si,&pi))
 
		ExitFromMyApp();
 
	}
	//...
	//...
}

//описание структуры
struct coder
{
	//utf8->unicode
	static wchar_t* utf8_to_unicode__dontForgetDeleteArr(const char *utf8_string)
	{
		wchar_t* pRes=0;
		int res_len=0;
 
		//тест на возможность преобразования
		res_len=MultiByteToWideChar(CP_UTF8,0,utf8_string,-1,0,0);
		if(!res_len)
		{
			return 0;
		}
 
		//выделяем память
		pRes = new wchar_t[res_len];
		if(!pRes)
		{
			return 0;
		}
 
		//преобразование
		if(!MultiByteToWideChar(CP_UTF8,0,utf8_string,-1,pRes,res_len))
		{
			delete [] pRes;
			return 0;
		}
 
		return pRes;
	}
 
	//unicode->1251
	static char * unicode_to_1251__dontForgetDeleteArr(const wchar_t *unicode_string)
	{
		char* pRes=0;
		int res_len=0;
 
		//тест на возможность преобразования
		res_len = WideCharToMultiByte(1251,0,unicode_string,-1,0,0,0,0);
		if(!res_len)
		{
			return 0;
		}
 
		//выделяем память
		pRes=new char[res_len];
		if(!pRes)
		{
			return 0;
		}
 
		//преобразование
		if(!WideCharToMultiByte(1251,0,unicode_string,-1,pRes,res_len,0,0))
		{
			delete [] pRes;
			return 0;
		}
 
		return pRes;
	}
 
	//процедура с примером
	static void Example()
	{
		wchar_t* unicode_string=0;
		char* cp1251_string=0;
 
		//исходный текст
		char utf8_string[] = "UTF-8 + русский текст";
 
		for(;;)
		{
 
			unicode_string=utf8_to_unicode__dontForgetDeleteArr(utf8_string);
			if(!unicode_string)
			{
				AfxMessageBox("Не удалось конвертировать в unicode!");
				break;
			}
 
			cp1251_string = unicode_to_1251__dontForgetDeleteArr(unicode_string);
 
			if(!cp1251_string)
			{
				AfxMessageBox("Не удалось конвертировать из unicode!");
				break;
			}
 
			break;
		}
 
		//cp1251_string - результат
		AfxMessageBox(cp1251_string);
 
		//не забываем удалить массивы
		if(unicode_string)
		{
			delete [] unicode_string;
			unicode_string=0;
		}
 
		if(cp1251_string)
		{
			delete [] cp1251_string;
			cp1251_string=0;
		}
	}
};
 
//вызов примера
coder::Example();