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

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();