http://nopaste.gamedev.pl/?id=4746 – program, w którym rysujemy ścieżkę ruchu dla Spybot’a – Tracker’a. Zapisuje on wynik w pliku nagłówkowym .nqh, jako dwie tablice zawierające kąty i odległości. Elementy tablic, zgodnie z językiem NQC, nie mogą być inicjowane z poziomu programisty, stąd funkcja initiate().

Obrót zgodny z ruchem wskazówek zegara jest oznaczany jako dodatni, przeciwny jako ujemny. Kąt obrotu nigdy nie może być większy od 180°. Jest to zasługa tego fragmentu:

if (fOrientation > fAngle)
{
    if (fOrientation - fAngle <= 180)
        fTurnAngle = fOrientation - fAngle ;
    else
        fTurnAngle = -1 * (360 - fOrientation + fAngle) ;
}
else if (fOrientation < fAngle)
{
    if (fAngle - fOrientation <= 180)
        fTurnAngle = - (fAngle - fOrientation) ;
    else
        fTurnAngle = 360 - fAngle + fOrientation ;
}
else fTurnAngle = 0 ;

Drugi program, napisany w NQC jest uruchamiany osobno, po podłączeniu robota do komputera. Dołącza plik nagłówkowy z danymi, jest bardzo prosty w budowie: http://nopaste.gamedev.pl/?id=4747

Problemem jest to, że nie znalazłem funkcji odpowiadającej za zwolnienie silników, przez co robot jest niedokładny. Obrót robota jest mierzony w centysekundach (1/100s = 1cs), a nie w stopniach, czy chociaż radianach.  W dodatku system robota nie obsługuje liczb innych niż całkowite. Kolejnym ograniczeniem jest pamięć robota, która może przechować jedynie 15 waypoint’ów.

Sistem operasi Windows menawarkan banyak kemudahan bukan hanya bagi pengguna tetapi juga bagi programmer. Kemudahan tersebut dikarenakan windows mempunyai banyak fungsi-fungsi API (Application Programming Interface) yang bisa dimanfaatkan. Fungsi-fungsi tersebut biasanya dinamakan WinAPI.

Beberapa fungsi WinAPI yang biasanya digunakan adalah untuk mendapatkan lokasi folder-folder spesial atau folder-folder khusus milik Windows dan mendapatkan beberapa informasi Windows.

Yang dimaksud dengan folder-folder spesial misalnya adalah folder system32, windows, start menu, program files, my documents dll. Sedangkan informasi windows diantaranya nama komputer, nama user yang sedang aktif, prosessor yang digunakan dll.

OK, tanpa banyak basa-basi lagi langsung kita luncurkan Delphi kesayangan kita…

Pertama buat form seperti berikut:

Berikutnya program pada Button1 (Get All) event OnClick:

procedure TForm1.Button1Click(Sender: TObject);
var
pId : PItemIDList;
dir : array[0..MAX_PATH] of char;
len : Cardinal;
begin
//Untuk mendapatkan drive tempat instalasi windows
GetEnvironmentVariable('SystemDrive', @dir, MAX_PATH);
Edit1.Text := String(dir);

//Untuk mendapatkan lokasi folder windows
GetWindowsDirectory(@dir, MAX_PATH);
Edit2.Text := String(dir);

//Untuk mendapatkan lokasi folder system32
GetSystemDirectory(@dir, MAX_PATH);
Edit3.Text := String(dir);

//Untuk mendapatkan lokasi folder Program Files
GetEnvironmentVariable('ProgramFiles', @dir, MAX_PATH);
Edit4.Text := String(dir);

//Untuk mendapatkan lokasi folder Desktop untuk semua user
SHGetSpecialFolderLocation(Handle, CSIDL_COMMON_DESKTOPDIRECTORY, pId);
SHGetPathFromIDList(pId, dir);
Edit5.Text := String(dir);

//Untuk mendapatkan lokasi folder Desktop untuk user yang aktif
SHGetSpecialFolderLocation(Handle, CSIDL_DESKTOPDIRECTORY, pId);
SHGetPathFromIDList(pId, dir);
Edit6.Text := String(dir);

//Untuk mendapatkan lokasi folder Start Menu untuk semua user
SHGetSpecialFolderLocation(Handle, CSIDL_COMMON_STARTMENU, pId);
SHGetPathFromIDList(pId, dir);
Edit7.Text := String(dir);

//Untuk mendapatkan lokasi folder Start Menu untuk user yang aktif
SHGetSpecialFolderLocation(Handle, CSIDL_STARTMENU, pId);
SHGetPathFromIDList(pId, dir);
Edit8.Text := String(dir);

//Untuk mendapatkan nama komputer
len := MAX_COMPUTERNAME_LENGTH + 1;
GetComputerName(@dir, len);
Edit9.Text := String(dir);

//Untuk mendapatkan nama user yang sedang login
len := 255;
GetUserName(@dir, len);
Edit10.Text := String(dir);

//Untuk mendapatkan lokasi folder Document dari user yang aktif
SHGetSpecialFolderLocation(Handle, CSIDL_PERSONAL, pId);
SHGetPathFromIDList(pId, dir);
Edit11.Text := String(dir);

//Untuk mendapatkan informasi jumlah prosessor yang digunakan
GetEnvironmentVariable('NUMBER_OF_PROCESSORS', @dir, MAX_PATH);
Edit12.Text := String(dir);

//Untuk mendapatkan informasi nama prosessor yang digunakan
GetEnvironmentVariable('PROCESSOR_IDENTIFIER', @dir, MAX_PATH);
Edit13.Text := String(dir);

//Untuk mendapatkan informasi nama OS yang digunakan
GetEnvironmentVariable('OS', @dir, MAX_PATH);
Edit14.Text := String(dir);

//Untuk mendapatkan informasi resolusi layar
Edit15.Text := IntToStr(GetSystemMetrics(SM_CXSCREEN)) +
' x ' +
IntToStr(GetSystemMetrics(SM_CYSCREEN));
end;

Hasil setelah running:

Fungsi-fungsi tersebut hanya sebagian kecil saja hasil explorasi saya pribadi, masih banyak fungsi-fungsi yang lainnya yang belum saya explore karena keterbatasan waktu. Untuk itu silahkan Anda mencarinya lewat tutorial-tutorial yang banyak tersebar di belantara Internet.

Atau bagi anda yang berkeinginan untuk mengembara di “hutan” WinAPI silahkan baca manual dari Windows API.

Download script

Using the Native API function NtQuerySystemInformation you can list all open handles from all processes.

program ListAllOpenHandles;

{$APPTYPE CONSOLE}

uses
  PSApi,
  Windows,
  SysUtils;

const
SystemHandleInformation       = $10;
STATUS_SUCCESS        	      = $00000000;
STATUS_BUFFER_OVERFLOW        = $80000005;
STATUS_INFO_LENGTH_MISMATCH   = $C0000004;
DefaulBUFFERSIZE              = $100000;

type
 OBJECT_INFORMATION_CLASS = (ObjectBasicInformation,ObjectNameInformation,ObjectTypeInformation,ObjectAllTypesInformation,ObjectHandleInformation );

 SYSTEM_HANDLE=packed record
	uIdProcess:ULONG;
	ObjectType:UCHAR;
	Flags     :UCHAR;
	Handle    :Word;
	pObject   : Pointer;
	GrantedAccess:ACCESS_MASK;
 end;

 PSYSTEM_HANDLE      = ^SYSTEM_HANDLE;
 SYSTEM_HANDLE_ARRAY = Array[0..0] of SYSTEM_HANDLE;
 PSYSTEM_HANDLE_ARRAY= ^SYSTEM_HANDLE_ARRAY;

  SYSTEM_HANDLE_INFORMATION=packed record
	uCount:ULONG;
	Handles:SYSTEM_HANDLE_ARRAY;
 end;
 PSYSTEM_HANDLE_INFORMATION=^SYSTEM_HANDLE_INFORMATION;

 TNtQuerySystemInformation=function (SystemInformationClass:DWORD; SystemInformation: pointer; SystemInformationLength:DWORD;  ReturnLength:PDWORD):THandle; stdcall;
 TNtQueryObject           =function (ObjectHandle:cardinal; ObjectInformationClass:OBJECT_INFORMATION_CLASS; ObjectInformation: pointer; Length:ULONG;ResultLength:PDWORD):THandle;stdcall;

 UNICODE_STRING=packed record
    Length       :Word;
    MaximumLength:Word;
    Buffer       : PWideChar;
 end;

 OBJECT_NAME_INFORMATION=UNICODE_STRING;
 POBJECT_NAME_INFORMATION=^OBJECT_NAME_INFORMATION;

Var
 NTQueryObject           :TNtQueryObject;
 NTQuerySystemInformation:TNTQuerySystemInformation;

function GetObjectInfo(hObject:cardinal; objInfoClass:OBJECT_INFORMATION_CLASS):LPWSTR;
var
 pObjectInfo:POBJECT_NAME_INFORMATION;
 HDummy     :THandle;
 dwSize     : DWORD;
begin
  Result:=nil;
		dwSize      := sizeof(OBJECT_NAME_INFORMATION);
		pObjectInfo := AllocMem(dwSize);
		HDummy      := NTQueryObject(hObject, objInfoClass, pObjectInfo,dwSize, @dwSize);

		if((HDummy = STATUS_BUFFER_OVERFLOW) or (HDummy = STATUS_INFO_LENGTH_MISMATCH)) then
    begin
			FreeMem(pObjectInfo);
			pObjectInfo := AllocMem(dwSize);
			HDummy      := NTQueryObject(hObject, objInfoClass, pObjectInfo,dwSize, @dwSize);
		end;

		if((HDummy >= STATUS_SUCCESS) and (pObjectInfo.Buffer <> nil)) then
		begin
			Result := AllocMem(pObjectInfo.Length + sizeof(WCHAR));
			CopyMemory(result, pObjectInfo.Buffer, pObjectInfo.Length);
		end;
		FreeMem(pObjectInfo);
end;

procedure EnumerateOpenFiles();
var
 sDummy      : string;
 hProcess    : THandle;
 hObject     : THandle;
 ResultLength: DWORD;
 aBufferSize : DWORD;
 aIndex      : Integer;
 pHandleInfo : PSYSTEM_HANDLE_INFORMATION;
 HDummy      : THandle;
 lpwsName    : PWideChar;
 lpwsType    : PWideChar;
 lpszProcess : PAnsiChar;
begin
    AbufferSize      := DefaulBUFFERSIZE;
		pHandleInfo      := AllocMem(AbufferSize);
		HDummy           := NTQuerySystemInformation(DWORD(SystemHandleInformation), pHandleInfo,AbufferSize, @ResultLength);  //Get the list of handles

		if(HDummy = STATUS_SUCCESS) then  //If no error continue
    begin

      for aIndex:=0 to pHandleInfo^.uCount-1 do   //iterate the list
      begin
				hProcess := OpenProcess(PROCESS_DUP_HANDLE or PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, FALSE, pHandleInfo.Handles[aIndex].uIdProcess);  //open the process to get aditional info
				if(hProcess <> INVALID_HANDLE_VALUE) then  //Check valid handle
        begin
					hObject := 0;
					if DuplicateHandle(hProcess, pHandleInfo.Handles[aIndex].Handle,GetCurrentProcess(), @hObject, STANDARD_RIGHTS_REQUIRED,FALSE, 0) then  //Get  a copy of the original handle
          begin
						lpwsName := GetObjectInfo(hObject, ObjectNameInformation); //Get the filename linked to the handle
						if (lpwsName <> nil)  then
            begin
							lpwsType    := GetObjectInfo(hObject, ObjectTypeInformation);
							lpszProcess := AllocMem(MAX_PATH);

							if GetModuleFileNameEx(hProcess, 0,lpszProcess, MAX_PATH)<>0 then  //get the name of the process
               sDummy:=ExtractFileName(lpszProcess)
              else
               sDummy:= 'System Process';

              Writeln('PID      ',pHandleInfo.Handles[aIndex].uIdProcess);
              Writeln('Handle   ',pHandleInfo.Handles[aIndex].Handle);
              Writeln('Process  ',sDummy);
              Writeln('FileName ',string(lpwsName));
              Writeln;

              FreeMem(lpwsName);
              FreeMem(lpwsType);
              FreeMem(lpszProcess);
						end;
						CloseHandle(hObject);
					end;
					CloseHandle(hProcess);
				end;
			end;
		end;
		FreeMem(pHandleInfo);

end;

begin
  try
    NTQueryObject            := GetProcAddress(GetModuleHandle('NTDLL.DLL'), 'NtQueryObject');
    NTQuerySystemInformation := GetProcAddress(GetModuleHandle('NTDLL.DLL'), 'NtQuerySystemInformation');
  	if (@NTQuerySystemInformation<>nil) and (@NTQuerySystemInformation<>nil) then
    EnumerateOpenFiles();
    Readln;
  except
    on E:Exception do
      Writeln(E.Classname, ': ', E.Message);
  end;
end.

Вот обернул ScrollBar в класс. Реализовывалось под свои нужды, поэтому работа ведется только со стандартными скроллбарами контролов(т.е. с вертикальным, горизонтальным или сразу с обоими). Выкладываю код:

class ScrollBar : Window
{
public:
	ScrollBar(HWND hParent)
	{
		_hParent = hParent;
	}

	void enableScrollBar(UINT wSBflags, UINT wArrows)
	{
		::EnableScrollBar(_hParent, wSBflags, wArrows);
	}

	void getScrollBarInfo(LONG idObject, PSCROLLBARINFO psbi)
	{
		::GetScrollBarInfo(_hParent, idObject, psbi);
	}

	void getScrollInfo(int fnBar, LPSCROLLINFO lpsi)
	{
		::GetScrollInfo(_hParent, fnBar, lpsi);
	}

	void scrollWindow(int dx, int dy, const RECT *prcScroll, UINT flags)
	{
		::ScrollWindowEx(_hParent, dx, dy, prcScroll, NULL, NULL, NULL, flags);
	}

	void setScrollInfo(int fnBar, LPCSCROLLINFO lpsi, BOOL fRedraw = TRUE)
	{
		::SetScrollInfo(_hParent, fnBar, lpsi, fRedraw);
	}

	void showScrollBar(int wBar, BOOL bShow = TRUE)
	{
		::ShowScrollBar(_hParent, wBar, bShow);
	}

	static WORD getScrollingReguest(WPARAM wParam)
	{
		return LOWORD(wParam);
	}

};

В принципе дополнить класс для работы со скроллбаром как с отдельным контролом не проблема, может быть как-нибудь займусь(что там заниматься: пару строчек дописать и все )

Kilka dni temu znalazłem starego Spybota w moim zbiorze “Technic’sów”. Kto się tym bawił ten wie co to jest, a kto nie… niech łapie linka
Robotowi można wgrywać różne misje z dostarczonego w zestawie CD-ROM’u (którego nie mam), ale można też programować go w konwencjonalny sposób. Wykorzystując język NQC (Not Quite C).
Mam już klika pomysłów na wykorzystanie modułu, ale niestety dużym ograniczeniem jest to, że posiada on tylko dwa silniki (w dodatku zamontowane na stałe), czujnik dotykowy i marnej jakości czujnik optyczny. Na początek pobawię się z tym co mam, a jeśli mnie wciągnie to może pomyślę nad zakupem nowszych komputerów od LEGO o znacznie większych możliwościach.

Wszystko byłoby super, gdyby nie to, że szkoła zajmuje mi bardzo dużo czasu. :/ Dlatego też nie mogę powiedzieć kiedy zacznę pisać nową wersję mojego ‘malarza kodu’ z wykorzystaniem WinAPI.

Написал оберточку над хедером:

class Header : public Window
{
public:

	Header(HWND hParent, HINSTANCE hInst)
	{
		RECT rcParent;
		HDLAYOUT hdl;
		WINDOWPOS wp;
		::InitCommonControls(); 

		_hSelf = ::CreateWindowEx(0, WC_HEADER, (LPCTSTR) NULL,
								  WS_CHILD | HDS_BUTTONS |  HDS_HORZ | WS_BORDER,
								  0, 0, 0, 0, hParent, 0, _hInst,
								  (LPVOID) NULL);
		HFONT hDefaultFont = (HFONT)::GetStockObject(DEFAULT_GUI_FONT);
		::SendMessage(_hSelf,WM_SETFONT,(WPARAM)hDefaultFont,0);
		::GetClientRect(hParent, &rcParent); 

		hdl.prc = &rcParent;
		hdl.pwpos = ℘
		::SendMessage(_hSelf, HDM_LAYOUT, 0, (LPARAM) &hdl);
		::SetWindowPos(_hSelf, wp.hwndInsertAfter, wp.x, wp.y,
			wp.cx, wp.cy, wp.flags | SWP_SHOWWINDOW);
	};

	int insertItem(int iInsertAfter, int nWidth, LPWSTR lpsz)
	{
		HDITEM hdi;
		int index; 

		hdi.mask = HDI_TEXT | HDI_FORMAT | HDI_WIDTH;
		hdi.pszText = lpsz;
		hdi.cxy = nWidth;
		hdi.cchTextMax = wcslen(lpsz);
		hdi.fmt = HDF_LEFT | HDF_STRING; 

		index = SendMessage(_hSelf, HDM_INSERTITEM,
			(WPARAM) iInsertAfter, (LPARAM) &hdi);
		return index;
	} 

	int getHeight()
	{
		RECT rc;
		::SendMessage(_hSelf, HDM_GETITEMRECT, 0, (LPARAM)&rc);
		return rc.bottom;
	}
};

Несколько замечаний по этому поводу:

• Код практически слизан с примеров из MSDN(этого практически нельзя было не сделать, т.к. “есть два вида программирования на WinApi: так, как в MSDN и неправильно” )
• Не забывайте из оконной процедуры родительского окна хедера возвращать по умолчанию FALSE(это чревато непонятными глюками)
• Реализовно естественно далеко не все, но необходимый мне минимум(если кому надо, то MSDN в руки и пошел)

Вообще сейчас как-то давно не брался ни за свой менеджер, ни за контрол для него, т.к. сейчас мало времени

Решил писать контрол с нуля. Учитывая специфику приложения вот, что я думаю сделать:
1. Завести контейнер, где я буду хранить все узлы контрола. Узел будет иметь следующий вид:

struct node
{
    nodeinfo * ii; //вся информация, которая хранится в узле
    int level; //уровень
}

Отрисовывать я буду в цикле, просто смещая каждый узел на itm->level * someConst влево. Получится своеобразнае дерево. Просто здесь мне так можно сделать, т.к. дочерние узлы у меня в любом случае будут добавляться сразу после родительских
2. Выделение и раскрытие\закрытие узлов буду делать немного извращенно: просто ловить WM_LBUTTONDOWN, определять по координатам выбранный узел, производить изменения, потом перерисовывать контрол
3. Естественно буду использовать header control и scroll bar, логику которых придется писать полностью самостоятельно

Решил изменить интерфейс для более удобной настройки горячих клавиш. Для этого необходимо реализовать контрол, который часто называют TreeListView(т.е. скрещенный ListView и TreeView) на WinApi(что является достаточно сложной работой). В результате должно получится что-то вроде этого:

Буду делать

Решил добавить в ListBox’е со списком плагинов к каждому элементу кнопочку для вызова настроек плагина(если она необходима). Решил рисовать ее сам(поверьте, так меньше геммороя):

if (plugin->isNeedSettings())
{
	HTHEME hTheme = ::OpenThemeData(_hSelf, L"Button");
	rc.left = 280;
	rc.top += 5;
	rc.right = 360;
	rc.bottom -=35;
	if (IsThemeActive())
	{
		if (pushed && (lpdis->itemState & ODS_SELECTED))
			::DrawThemeBackground(hTheme, lpdis->hDC, BP_PUSHBUTTON, PBS_PRESSED, &rc, NULL);
		else
			::DrawThemeBackground(hTheme, lpdis->hDC, BP_PUSHBUTTON, PBS_NORMAL, &rc, NULL);
		::DrawThemeText(hTheme, lpdis->hDC, BP_PUSHBUTTON, PBS_NORMAL, L"Settings...", wcslen(L"Settings..."), DT_SINGLELINE | DT_VCENTER | DT_CENTER, 0, &rc);
	}
	else
	{
		if (pushed && (lpdis->itemState & ODS_SELECTED))
			::DrawFrameControl(lpdis->hDC, &rc, DFC_BUTTON, DFCS_BUTTONPUSH | DFCS_PUSHED);
		else
			::DrawFrameControl(lpdis->hDC, &rc, DFC_BUTTON, DFCS_BUTTONPUSH);
		::DrawText(lpdis->hDC, L"Settings...", wcslen(L"Settings..."), &rc, DT_CENTER);
	}
	::CloseThemeData(hTheme);
}

Казалось бы все должно отрисоваться, как надо, однако вот, что получается при классической теме Windows(в других все нормально):

В общем, нужно разбираться
Кстати, добавлена иконка в трее, поработал над диалогом настроек программы. Написал себе корявенькое TODO на ближайшее время:

• Реализовать OSD-сообщения для плагинов(ну, и сама программа может будет их использовать) – даже не брался
• Реализовать диалог настроек и их чтение/запись – сам диалог уже работает(там просто была идиотская ошибка, из-за которой у меня неделю не получалось нормально его сделать), осталось чтение/запись
• Кнопки на листбоксе(и не только для вызова настроек плагина) – почти сделано(проблема описана выше)

Как все это доделаю, думаю, можно будет бету выдать в свет

Postanowiłem zrobić porządek ze sobą i na blogu. Wiem… to dziwnie brzmi

Ale do rzeczy. Do tej pory moje zainteresowanie programowaniem przypominało taką… jakby to nazwać… O! sinusoidę, właśnie. Od teraz mam zamiar regularnie zgłębiać moją wiedzę na ten temat, choć wiem, że może być to trudniejsze. Śpieszę z wyjaśnieniem – od września zaczynam naukę w liceum. Nie wiem jak będzie… nowi ludzie, nowi znajomi, mniej czasu… cóż, pożyjemy zobaczymy.

Co do sprawy bloga. Chciałem po prostu odświeżyć linki i zmienić wygląd, bo ten niebieski top mi się znudził. Niestety w tej chwili nie mam dostępu do mojego dysku twardego na PeCecie – wysłałem kartę graficzną do serwisu miesiąc temu , no i jeszcze się ślimory nie wyrobiły. :/
Tak więc nowy upload zrobię za tydzień, może dwa.

Wkrótce planuję wypuścić na świat nową wersję mojego Koloryzatora Składni – tym razem w wersji graficznej z wykorzystaniem WinAPI. Muszę tylko zgłębić wiedzę o okienkach.

Witam, kilka dni temu zamówiłem sobie podręcznik: Programowanie Windows Charlesa Petzold’a…

Od tamtej pory nic, tylko siedzę przed laptopem z książką w ręku. Nauczyłem się już trochę i mam na dysku kilka malutkich programów, ale ciekawych

Muszę przyznać, że dowiedziałem się sporo na temat samego działania systemu, jego architektury i rozwoju. Polecam tą publikację wszystkim, którzy jeszcze nie mieli kontaktu z WinAPI, a także zaawansowanym programistom. Tam zebrana jest znaczna część danych z msdn i w dodatku opisana po polsku zrozumiałym językiem.

Wszystkie kursy internetowe przy tym podręczniku wypadają conajmniej słabo. Jeszcze raz polecam, mimo niemałej cenki.

Win32 API Reference
Cẩm Nang Tra Cứu WinAPI Bỏ Túi

Ban đầu, Fri3ng3R tính dịch các hàm và các kiểu dữ liệu thường dùng trong WinAPI để dễ tham khảo. Nhưng vì chưa có thời gian rãnh nên chỉ mới dịch được 1 phần bài “Các kiểu dữ liệu thường dùng trong WinAPI“, cho nên sau này nếu rãnh sẽ dịch tiếp và dịch thêm bài “Danh Sach Tra Cứu Các Hàm Trong WinAPI“. Hôm qua, tình cờ lục lọi lại trong đóng tài liệu ebook cũ trên máy thấy lại được cuốn tra cứu này, mặc dù khá cũ, và không đầy đủ như MSDN mới nhất nhưng những hàm, hằng số, các định danh cơ bản thường dùng trong WinAPI thì có khá đầy đủ và chi tiết. Download tại đây.

Thông tin về tài liệu:

• Định dạng: HLP
• Dung lượng: 24MB
• Mức độ sử dụng: Dễ
• Phần mềm cần thiết để sử dụng: Không
• Đánh giá: 3/5

Have fun.

Đây là bộ tài liệu tra cứu các kiểu dữ liệu thường dùng trong WinAPI, được sưu tầm, tham khảo và dịch lại từ nhiều nguồn tài liệu khác nhau. Vì năng lực của  Fri3ng3R còn hạn chế nên bài viết này còn rất nhiều thiếu sót, mong các bạn ủng hộ, đóng góp và bổ sung thêm. Xin cảm ơn nhiều. Tham khảo thêm tại đây.

Danh sách được sắp xếp theo 2 kiểu nhằm giúp cho việc tra cứu 1 cách dễ dàng.

I. Sắp Xếp Theo ABC:

ATOM – atom (atom a string table reference)
BOOL – (INT) Kiểu logic, có giá trị là True hay False.
BOOLEAN – (BYTE) Kiểu logic, có giá trị là True hay False.
BSTR (OLECHAR*) Kiểu con trỏ đến chuỗi cơ bản hay chuỗi nhị phân 32-bit, kết thúc bằng 2 kí tự Null 0. Được sự dụng trong lập trình COM.
BYTE – (unsigned char) Kiểu số nguyên không dấu 8-bit.
CCHAR – Kiểu kí tự 8-bit (Windows ANSI).
CHAR  – Kiểu kí tự 8-bit (Windows ANSI).
DWORD – (unsigned long) Kiểu số nguyên không dấu 32-bit.
DWORD32 – Kiểu số nguyên không dấu 32-bit.
DWORD64 – Kiểu số nguyên không dấu 64-bit.
DWORD_PTR – Kiểu số nguyên không dấu 32-bit. Sử dụng khi cần chuyển kiểu con trỏ DWORD để tính toán, và là kiểu cho các tham số 32-bit có thể mở rộng thành kiểu 64-bit trong hệ điều hành Windows 64-bit.
FLOAT – (float) Kiểu số thực dấu chấm động.
GLOBALHANDLE – (HANDLE) Kiểu mã điều khiển toàn cục
HACCEL – (HANDLE) Kiểu mã điều khiển đến bảng mô tả phím tắt Accelerator.
HANDLE – (void*) Kiểu mã điều khiển của một đối tượng (một số nguyên 32-bit không dấu).
HBITMAP – (HANDLE) Kiểu mã điều khiển của 1 đối tượng ảnh Bitmap.
HBRUSH – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Brush (cọ vẽ).
HCONV – (HANDLE) Kiểu mã điều khiển của 1 DDE (Dynamic Data Exchange).
HCONVLIST – Kiểu mã điều khiển của 1danh sách DDE.
HCURSOR – (HICON) Kiểu mã điều khiển của 1 đối tượng Cursor (con trỏ chuột).
HDC – (HANDLE)  Kiểu mã điều khiển của 1 Device Context (DC).
HDDEDATA – Kiểu mã điều khiển của 1 chuỗi DDE
HDESK – (HANDLE) Kiểu mã điều khiển của Desktop.
HDLG – (HANDLE) Kiểu mã điều khiển của hộp thoại Dialog.
HDROP – Kiểu mã điều khiển của 1 cấu trúc thả nội bộ.
HDWP – Kiểu mã điều khiển của 1  vị trí của cấu trúc của cửa sổ mở rộng.
HENHMETAFILE – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Metafile tăng cường.
HFILE – (int hay short)  Kiểu mã điều khiển của 1 đối tượng tập tin, được mở bằng hàm OpenFile chứ không phải hàm CreateFile.
HFONT – (HANDLE) Kiểu mã điều khiển của đối tượng Font.
HGDIOBJ – (HANDLE (void NEAR*)) Kiểu mã điều khiển của 1 đối tượng đồ họa GDI.
HGLOBAL – (HANDLE) Kiểu mã điều khiển của 1 khối nhớ toàn cục.
HHOOK – (HANDLE) Kiểu mã điều khiển của 1 hàm Hook.
HICON – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Icon (biểu tượng).
HIMAGELIST – Kiểu mã điều khiển của 1 đối tượng ImageList.
HIMC – Kiểu mã điều khiển của 1 bộ gõ ngôn ngữ của Windows.
HINSTANCE – (HANDLE) Kiểu mã điều khiển của 1 Hinstance.
HKEY – (HANDLE) Kiểu mã điều khiển của 1 khóa Registry.
HKL – (HANDLE) Kiểu mã điều khiển của Input Locale.
HLOCAL – (HANDLE) Kiểu mã điều khiển của 1 khối nhớ cục bộ.
HMEMU – (HANDLE) Kiểu mã điều khiển của 1đối tượng Menu.
HMETAFILE – (HANDLE)  Kiểu mã điều khiển của 1đối tượng Meta-file.
HMIDIIN – Kiểu mã điều khiển của 1 MIDI (Musical Instrument Digital Interface).
HMIDIOUT – Kiểu mã điều khiển của việc xuất tập tin MIDI.
HMMIO – Kiểu mã điều khiển của 1đối tượng Document.
HMODULE – (HINSTANCE) Kiểu mã điều khiển của 1 Module. Lưu trữ địa chỉ bắt đầu của Module.
HMONITOR – (HANDLE) Kiểu mã điều khiển của 1 màn hình hiện thị.
HPALETTE – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Hpalette (bảng màu).
HPEN – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Pen (bút vẽ).
HRGN – (HANDLE) Kiểu mã điều khiển của 1 miền Domain.
HRSRC – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Resource.
HSZ – (HANDLE) Kiểu mã điều khiển của 1 chuỗi DEE.
HWAVEIN – Kiểu mã điều khiển của nhập tập tin âm thanh dạng Wav.
HWAVEOUT – Kiểu mã điều khiển của xuất tập tin âm thanh dạng Wav.
HWINSTA – (HANDLE)  Kiểu mã điều khiển của 1 trạm làm việc trong mạng nội bộ.
HWND – (HANDLE) Kiểu mã điều khiển của 1 cửa sổ (một số nguyên 32-bit không dấu).
INT – (int) Kiểu số nguyên có dấu 32-bit.
INT32 – Kiểu số nguyên có dấu 32-bit.
INT64 – Kiểu số nguyên có dấu 64-bit.
INT_PTR – Kiểu số nguyên có dấu 32-bit. Sử dụng khi cần chuyển kiểu con trỏ INT để tính toán.
LOCALHANDLE – (HANDLE) Kiểu mã điều khiển cục bộ.
LONG – (long) Kiểu số nguyên có dấu 32-bit.
LONG32 – Kiểu số nguyên có dấu 32-bit.
LONG64 – Kiểu số nguyên có dấu 64-bit.
LONGLONG – (__int64 hay double) Kiểu số nguyên có dấu 64-bit.
LONG_PTR – Kiểu số nguyên có dấu 32-bit. Sử dụng khi cần chuyển kiểu con trỏ LONG để tính toán.
LPBYTE – (BYTE far*) Kiểu con trỏ đến số kiểu BYTE.
LPBOOL – (BOOL far*) Kiểu con trỏ đến kiểu BOOL.
LPCOLESTR (const OLECHAR*) Kiểu con trỏ hằng đến OLECHAR.
LPCSTR – (CONST CHAR *) Kiểu con trỏ đến 1chuỗi kí tự hằng, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
LPCTSTR – (LPCWSTR hay LPCSTR) Nếu Unicode được định nghĩa, kiểu con trỏ hằng này tương đương với LPCWSTR; ngược lại sẽ tương đương với LPCSTR.
LPCWCH – (CONST WCHAR FAR*) Kiểu con trỏ long đến 1chuỗi kí tự hằng WCHAR.
LPCWSTR – (CONST WCHAR FAR*) Kiểu con trỏ long đến 1chuỗi kí tự hằng WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
LPDWORD – (DWORD far*) Kiểu con trỏ đến số kiểu DWORD.
LPINT – (INT far*) Kiểu con trỏ đến số kiểu INT.
LPLONG – (LONG far*) Kiểu con trỏ đến số kiểu LONG.
LPOLESTR – (OLECHAR*) Kiểu con trỏ đến OLECHAR.
LPHANDLE – (HANDLE FAR*) Kiểu con trỏ đến kiểu HANDLE.
LPHWAVEIN – Kiểu con trỏ đến kiểu HWAVEIN.
LPHWAVEOUT – Kiểu con trỏ đến kiểu HWAVEOUT.
LPSTR – (CHAR *) Kiểu con trỏ long đến 1chuỗi kí tự, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
LPTCH – (LPWSTR hay LPSTR) Nếu Unicode được định nghĩa, kiểu con trỏ này tương đương với LPWSTR; ngược lại sẽ tương đương với LPSTR.
LPTSTR – (LPWSTR hay LPSTR) Nếu Unicode được định nghĩa, kiểu con trỏ này tương đương với LPWSTR; ngược lại sẽ tương đương với LPSTR.
LPWORD – (WORD far*) Kiểu con trỏ đến số kiểu WORD.
LPWSTR – (WCHAR FAR*) Kiểu con trỏ đến 1chuỗi kí tự WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
NPSTR – (CHAR *) Kiểu con trỏ đến 1chuỗi kí tự, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
NWPSTR – (WCHAR*) Kiểu con trỏ đến 1chuỗi kí tự WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
OLECHAR (wchar_t) Kiểu kí tự UNICODE 32-bit.
PBYTE – (BYTE near*) Kiểu con trỏ đến số kiểu BYTE.
PBOOL – (BOOL near*) Kiểu con trỏ đến kiểu BOOL.
PBOOLEAN – (BOOLEAN*) Kiểu con trỏ đến kiểu BOOLEAN.
PCHAR – (CHAR *) Kiểu con trỏ đến 1chuỗi kí tự.
PCSTR – (CONST CHAR *) Kiểu con trỏ đến 1chuỗi kí tự hằng, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
PCTSTR – (PCWSTR hay PCSTR) Nếu Unicode được định nghĩa, kiểu con trỏ hằng này tương đương với PCWSTR; ngược lại sẽ tương đương với PCSTR.
PCWCH – (CONST WCHAR*) Kiểu con trỏ đến 1chuỗi kí tự hằng WCHAR.
PCWSTR – (CONST WCHAR*) Kiểu con trỏ đến 1chuỗi kí tự hằng WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
PDWORD – (DWORD near*) Kiểu con trỏ đến số kiểu DWORD.
PFLOAT – (FLOAT near*) Kiểu con trỏ đến kiểu FLOAT.
PHANDLE – (HANDLE NEAR*) Kiểu con trỏ đến kiểu HANDLE.
PINT – (INT near*) Kiểu con trỏ đến số kiểu INT.
PLONG – (LONG near*) Kiểu con trỏ đến số kiểu LONG.
PLONGLONG – (LONGLONG*) Kiểu con trỏ đến số kiểu LONGLONG.
PSHORT – (SHORT*) Kiểu con trỏ đến số kiểu SHORT.
PSTR – (CHAR *) Kiểu con trỏ đến 1chuỗi kí tự, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
PSZ – (char *) Kiểu con trỏ đến 1 chuỗi kí tự, kết thúc bằng 0.
PTBYTE – (WCHAR * hay unsigned char *) Kiểu con trỏ đến số kiểu TBYTE.
PTCH – (LPWSTR hay LPSTR) Nếu Unicode được định nghĩa, kiểu con trỏ này tương đương với LPWSTR; ngược lại sẽ tương đương với LPSTR.
PTCHAR – (WCHAR* hay CHAR *) Kiểu con trỏ đến 1 chuỗi kí tự TCHAR.
PTSTR – (LPWSTR hay LPSTR) Nếu Unicode được định nghĩa, kiểu con trỏ này tương đương với LPWSTR; ngược lại sẽ tương đương với LPSTR.
PUCHAR – (UCHAR*) Kiểu con trỏ đến chuỗi kí tự UCHAR.
PUINT – (UINT*) Kiểu con trỏ đến số kiểu UINT.
PULONG – (ULONG*) Kiểu con trỏ đến số kiểu ULONG.
PULONGLONG – (ULONGLONG*) Kiểu con trỏ đến số kiểu ULONGLONG.
PUSHORT – (USHORT*) Kiểu con trỏ đến số kiểu USHORT.
PWCH – (WCHAR*) Kiểu con trỏ đến WCHAR.
PWCHAR – (WCHAR*) Kiểu con trỏ đến WCHAR.
PWSTR – (WCHAR*) Kiểu con trỏ đến 1chuỗi kí tự WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
PWORD – (WORD near*) Kiểu con trỏ đến số kiểu WORD.
SC_HANDLE – Kiểu mã điều khiển của 1 dịch vụ quản lí cơ sở dữ liệu.
SC_LOCK – Kiểu mã điều khiển của ràng buộc dịch vụ quản lí cơ sở dữ liệu
SERVICE_STATUS_HANDLE – Kiểu mã điều khiển của 1 trạng thái dịch vụ.
SHORT – (short) Kiểu số nguyên ngắn 16-bit (có dấu).
SPHANDLE – (HANDLE NEAR*) Kiểu con trỏ đến kiểu HANDLE.
TBYTE – (WCHAR hay unsigned char) Nếu Unicode được định nghĩa, kiểu này tương đương với WCHAR; ngược lại tương đương với CHAR không dấu.
TCHAR – Nếu cờ hiệu UNICODE được định nghĩa, kiểu này tương đương với WCHAR; ngược lại sẽ tương đương với CHAR.
UCHAR – (unsigned char) Kiểu kí tự không dấu.
UINT – (unsigned int) Kiểu số nguyên INT không dấu.
UINT32 – Kiểu số nguyên không dấu 32-bit.
UINT64 – Kiểu số nguyên không dấu 64-bit.
UINT_PTR – Kiểu số nguyên không dấu 32-bit. Sử dụng khi cần chuyển kiểu con trỏ UINT để tính toán.
ULONG – (unsigned long) Kiểu số nguyên LONG không dấu.
ULONG32 – Kiểu số nguyên LONG không dấu 32-bit.
ULONG64 – Kiểu số nguyên LONG không dấu 64-bit.
ULONGLONG – (unsigned __int64 hay double) Kiểu số nguyên có không dấu 64-bit.
ULONG_PTR – Kiểu con trỏ đến số nguyên không dấu của LONG_PTR.
USHORT – (unsigned short) Kiểu số nguyên ngắn (không dấu).
WCHAR – (wchar_t) Kiểu kí tự Unicode 16-bit.
WORD – (unsigned short)  Kiểu số nguyên ngắn không dấu 16 bit.

———————————————————————————

II. Sắp Xếp Theo Từng Kiểu:

1. Kiểu Kí Tự:
CHAR  – Kiểu kí tự 8-bit (Windows ANSI).
CCHAR – Kiểu kí tự 8-bit (Windows ANSI).
PSZ – (char *) Kiểu con trỏ đến 1 chuỗi kí tự, kết thúc bằng 0.
PCHAR – (CHAR *) Kiểu con trỏ đến 1chuỗi kí tự.
PSTR – (CHAR *) Kiểu con trỏ đến 1chuỗi kí tự, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
LPSTR – (CHAR *) Kiểu con trỏ long đến 1chuỗi kí tự, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
NPSTR – (CHAR *) Kiểu con trỏ đến 1chuỗi kí tự, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
PCSTR – (CONST CHAR *) Kiểu con trỏ đến 1chuỗi kí tự hằng, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
LPCSTR – (CONST CHAR *) Kiểu con trỏ đến 1chuỗi kí tự hằng, kết thúc bằng 0. Đây là chuỗi dạng ANSI 8 bit/kí tự.
WCHAR – (wchar_t) Kiểu kí tự Unicode 16-bit.
PWCH – (WCHAR*) Kiểu con trỏ đến WCHAR.
PWCHAR – (WCHAR*) Kiểu con trỏ đến WCHAR.
PWSTR – (WCHAR*) Kiểu con trỏ đến 1chuỗi kí tự WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
LPWSTR – (WCHAR FAR*) Kiểu con trỏ đến 1chuỗi kí tự WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
NWPSTR – (WCHAR*) Kiểu con trỏ đến 1chuỗi kí tự WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
PCWCH – (CONST WCHAR*) Kiểu con trỏ đến 1chuỗi kí tự hằng WCHAR.
LPCWCH – (CONST WCHAR FAR*) Kiểu con trỏ long đến 1chuỗi kí tự hằng WCHAR.
PCWSTR – (CONST WCHAR*) Kiểu con trỏ đến 1chuỗi kí tự hằng WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
LPCWSTR – (CONST WCHAR FAR*) Kiểu con trỏ long đến 1chuỗi kí tự hằng WCHAR, kết thúc bằng 0. Đây là chuỗi dạng Unicode 16 bit/kí tự.
TCHAR – Nếu cờ hiệu UNICODE được định nghĩa, kiểu này tương đương với WCHAR; ngược lại sẽ tương đương với CHAR.
PTCHAR – (WCHAR* hay CHAR *) Kiểu con trỏ đến 1 chuỗi kí tự TCHAR.
PTCH – (LPWSTR hay LPSTR) Nếu Unicode được định nghĩa, kiểu con trỏ này tương đương với LPWSTR; ngược lại sẽ tương đương với LPSTR.
LPTCH – (LPWSTR hay LPSTR) Nếu Unicode được định nghĩa, kiểu con trỏ này tương đương với LPWSTR; ngược lại sẽ tương đương với LPSTR.
PTSTR – (LPWSTR hay LPSTR) Nếu Unicode được định nghĩa, kiểu con trỏ này tương đương với LPWSTR; ngược lại sẽ tương đương với LPSTR.
LPTSTR – (LPWSTR hay LPSTR) Nếu Unicode được định nghĩa, kiểu con trỏ này tương đương với LPWSTR; ngược lại sẽ tương đương với LPSTR.
PCTSTR – (PCWSTR hay PCSTR) Nếu Unicode được định nghĩa, kiểu con trỏ hằng này tương đương với PCWSTR; ngược lại sẽ tương đương với PCSTR.
LPCTSTR – (LPCWSTR hay LPCSTR) Nếu Unicode được định nghĩa, kiểu con trỏ hằng này tương đương với LPCWSTR; ngược lại sẽ tương đương với LPCSTR.
UCHAR – (unsigned char) Kiểu kí tự không dấu.
PUCHAR – (UCHAR*) Kiểu con trỏ đến chuỗi kí tự UCHAR.
BSTR (OLECHAR*) Kiểu con trỏ đến chuỗi cơ bản hay chuỗi nhị phân 32-bit, kết thúc bằng 2 kí tự Null 0. Được sự dụng trong lập trình COM.
OLECHAR (wchar_t) Kiểu kí tự UNICODE 32-bit.
LPOLESTR (OLECHAR*) Kiểu con trỏ đến OLECHAR.
LPCOLESTR (const OLECHAR*) Kiểu con trỏ hằng đến OLECHAR.

———————————————————————————

2. Kiểu Số:
BYTE – (unsigned char) Kiểu số nguyên không dấu 8-bit.
PBYTE – (BYTE near*) Kiểu con trỏ đến số kiểu BYTE.
LPBYTE – (BYTE far*) Kiểu con trỏ đến số kiểu BYTE.
TBYTE – (WCHAR hay unsigned char) Nếu Unicode được định nghĩa, kiểu này tương đương với WCHAR; ngược lại tương đương với CHAR không dấu.
PTBYTE – (WCHAR * hay unsigned char *) Kiểu con trỏ đến số kiểu TBYTE.
BOOL – (INT) Kiểu logic, có giá trị là True hay False.
PBOOL – (BOOL near*) Kiểu con trỏ đến kiểu BOOL.
LPBOOL – (BOOL far*) Kiểu con trỏ đến kiểu BOOL.
BOOLEAN – (BYTE) Kiểu logic, có giá trị là True hay False.
PBOOLEAN – (BOOLEAN*) Kiểu con trỏ đến kiểu BOOLEAN.
SHORT – (short) Kiểu số nguyên ngắn 16-bit (có dấu).
PSHORT – (SHORT*) Kiểu con trỏ đến số kiểu SHORT.
USHORT – (unsigned short) Kiểu số nguyên ngắn (không dấu).
PUSHORT – (USHORT*) Kiểu con trỏ đến số kiểu USHORT.
INT – (int) Kiểu số nguyên có dấu 32-bit.
INT32 – Kiểu số nguyên có dấu 32-bit.
INT64 – Kiểu số nguyên có dấu 64-bit.
INT_PTR – Kiểu số nguyên có dấu 32-bit. Sử dụng khi cần chuyển kiểu con trỏ INT để tính toán.
PINT – (INT near*) Kiểu con trỏ đến số kiểu INT.
LPINT – (INT far*) Kiểu con trỏ đến số kiểu INT.
UINT – (unsigned int) Kiểu số nguyên INT không dấu.
UINT32 – Kiểu số nguyên không dấu 32-bit.
UINT64 – Kiểu số nguyên không dấu 64-bit.
UINT_PTR – Kiểu số nguyên không dấu 32-bit. Sử dụng khi cần chuyển kiểu con trỏ UINT để tính toán.
PUINT – (UINT*) Kiểu con trỏ đến số kiểu UINT.
LONG – (long) Kiểu số nguyên có dấu 32-bit.
LONG32 – Kiểu số nguyên có dấu 32-bit.
LONG64 – Kiểu số nguyên có dấu 64-bit.
LONGLONG – (__int64 hay double) Kiểu số nguyên có dấu 64-bit.
LONG_PTR – Kiểu số nguyên có dấu 32-bit. Sử dụng khi cần chuyển kiểu con trỏ LONG để tính toán.
PLONG – (LONG near*) Kiểu con trỏ đến số kiểu LONG.
LPLONG – (LONG far*) Kiểu con trỏ đến số kiểu LONG.
PLONGLONG – (LONGLONG*) Kiểu con trỏ đến số kiểu LONGLONG.
ULONG – (unsigned long) Kiểu số nguyên LONG không dấu.
ULONG32 – Kiểu số nguyên LONG không dấu 32-bit.
ULONG64 – Kiểu số nguyên LONG không dấu 64-bit.
ULONGLONG – (unsigned __int64 hay double) Kiểu số nguyên có không dấu 64-bit.
ULONG_PTR – Kiểu con trỏ đến số nguyên không dấu của LONG_PTR.
PULONG – (ULONG*) Kiểu con trỏ đến số kiểu ULONG.
PULONGLONG – (ULONGLONG*) Kiểu con trỏ đến số kiểu ULONGLONG.
WORD – (unsigned short)  Kiểu số nguyên ngắn không dấu 16 bit.
PWORD – (WORD near*) Kiểu con trỏ đến số kiểu WORD.
LPWORD – (WORD far*) Kiểu con trỏ đến số kiểu WORD.
DWORD – (unsigned long) Kiểu số nguyên không dấu 32-bit.
DWORD32 – Kiểu số nguyên không dấu 32-bit.
DWORD64 – Kiểu số nguyên không dấu 64-bit.
DWORD_PTR – Kiểu số nguyên không dấu 32-bit. Sử dụng khi cần chuyển kiểu con trỏ DWORD để tính toán, và là kiểu cho các tham số 32-bit có thể mở rộng thành kiểu 64-bit trong hệ điều hành Windows 64-bit.
PDWORD – (DWORD near*) Kiểu con trỏ đến số kiểu DWORD.
LPDWORD – (DWORD far*) Kiểu con trỏ đến số kiểu DWORD.
FLOAT – (float) Kiểu số thực dấu chấm động.
PFLOAT – (FLOAT near*) Kiểu con trỏ đến kiểu FLOAT.

———————————————————————————

3. Kiểu Mã Điều Khiển:
HANDLE – (void*) Kiểu mã điều khiển của một đối tượng (một số nguyên 32-bit không dấu)
PHANDLE – (HANDLE NEAR*) Kiểu con trỏ đến kiểu HANDLE.
SPHANDLE – (HANDLE NEAR*) Kiểu con trỏ đến kiểu HANDLE.
LPHANDLE – (HANDLE FAR*) Kiểu con trỏ đến kiểu HANDLE.
GLOBALHANDLE – (HANDLE) Kiểu mã điều khiển toàn cục
HDC – (HANDLE)  Kiểu mã điều khiển của 1 Device Context (DC).
HBITMAP – (HANDLE) Kiểu mã điều khiển của 1 đối tượng ảnh Bitmap.
HBRUSH – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Brush (cọ vẽ).
HICON – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Icon (biểu tượng).
HCURSOR – (HICON) Kiểu mã điều khiển của 1 đối tượng Cursor (con trỏ chuột).
HPALETTE – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Hpalette (bảng màu).
HPEN – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Pen (bút vẽ).
HCONV – (HANDLE) Kiểu mã điều khiển của 1 DDE (Dynamic Data Exchange).
HACCEL – (HANDLE) Kiểu mã điều khiển đến bảng mô tả phím tắt Accelerator.
HCONVLIST – Kiểu mã điều khiển của 1danh sách DDE.
HDDEDATA – Kiểu mã điều khiển của 1 chuỗi DDE
HDESK – (HANDLE) Kiểu mã điều khiển của Desktop.
HDLG – (HANDLE) Kiểu mã điều khiển của hộp thoại Dialog.
HDROP – Kiểu mã điều khiển của 1 cấu trúc thả nội bộ.
HDWP – Kiểu mã điều khiển của 1  vị trí của cấu trúc của cửa sổ mở rộng.
HENHMETAFILE – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Metafile tăng cường.
HFILE – (int hay short)  Kiểu mã điều khiển của 1 đối tượng tập tin, được mở bằng hàm OpenFile chứ không phải hàm CreateFile.
HFONT – (HANDLE) Kiểu mã điều khiển của đối tượng Font.
HGDIOBJ – (HANDLE (void NEAR*)) Kiểu mã điều khiển của 1 đối tượng đồ họa GDI.
HGLOBAL – (HANDLE) Kiểu mã điều khiển của 1 khối nhớ toàn cục.
HHOOK – (HANDLE) Kiểu mã điều khiển của 1 hàm Hook.
HIMAGELIST – Kiểu mã điều khiển của 1 đối tượng ImageList.
HIMC – Kiểu mã điều khiển của 1 bộ gõ ngôn ngữ của Windows.
HINSTANCE – (HANDLE) Kiểu mã điều khiển của 1 Hinstance.
HKEY – (HANDLE) Kiểu mã điều khiển của 1 khóa Registry.
HKL – (HANDLE) Kiểu mã điều khiển của Input Locale.
HLOCAL – (HANDLE) Kiểu mã điều khiển của 1 khối nhớ cục bộ.
HMEMU – (HANDLE) Kiểu mã điều khiển của 1đối tượng Menu.
HMETAFILE – (HANDLE)  Kiểu mã điều khiển của 1đối tượng Meta-file.
HMIDIIN – Kiểu mã điều khiển của 1 MIDI (Musical Instrument Digital Interface)
HMIDIOUT – Kiểu mã điều khiển của việc xuất tập tin MIDI.
HMMIO – Kiểu mã điều khiển của 1đối tượng Document.
HMODULE – (HINSTANCE) Kiểu mã điều khiển của 1 Module. Lưu trữ địa chỉ bắt đầu của Module.
HMONITOR – (HANDLE) Kiểu mã điều khiển của 1 màn hình hiện thị.
HRGN – (HANDLE) Kiểu mã điều khiển của 1 miền Domain.
HRSRC – (HANDLE) Kiểu mã điều khiển của 1 đối tượng Resource.
HSZ – (HANDLE) Kiểu mã điều khiển của 1 chuỗi DEE.
HWAVEIN – Kiểu mã điều khiển của nhập tập tin âm thanh dạng Wav.
HWAVEOUT – Kiểu mã điều khiển của xuất tập tin âm thanh dạng Wav.
LPHWAVEIN – Kiểu con trỏ đến kiểu HWAVEIN.
LPHWAVEOUT – Kiểu con trỏ đến kiểu HWAVEOUT.
HWINSTA – (HANDLE)  Kiểu mã điều khiển của 1 trạm làm việc trong mạng nội bộ.
HWND – (HANDLE) Kiểu mã điều khiển của 1 cửa sổ (một số nguyên 32-bit không dấu).
LOCALHANDLE – (HANDLE) Kiểu mã điều khiển cục bộ.
SC_HANDLE – Kiểu mã điều khiển của 1 dịch vụ quản lí cơ sở dữ liệu.
SC_LOCK – Kiểu mã điều khiển của ràng buộc dịch vụ quản lí cơ sở dữ liệu
SERVICE_STATUS_HANDLE – Kiểu mã điều khiển của 1 trạng thái dịch vụ.

~Fri3ng3R~

Um zu überprüfen ob eine Freigabe existiert, könnte ich jetzt auch schreiben, ihr findet alles in der msdn. Aber da ich selber solche Antworten in Foren etc. hasse, möchte ich meine Funktion dafür veröffentlichen.

bool isShareExist(const QString &shareName)
{
   wchar_t zShareName[MAX_PATH];
  
   QStringToWCHAR_T(shareName, zShareName);
   SHARE_INFO_0 pInfo;
   NET_API_STATUS status = NetShareGetInfo(
                                                               NULL,
                                                               reinterpret_cast<LPSTR>(zShareName),
                                                               0,
                                                               reinterpret_cast<LPBYTE*>(&pInfo));
   bool ok = false;
   switch(status)
   {
      case NERR_Success:
         ok = true;
         break;
      case ERROR_ACCESS_DENIED:
         QMessageBox::critical(0, "Fehler", "Sie verfügen nicht über die Berechtigung, Informationen über Freigaben auszulesen.");
         break;
      case ERROR_INVALID_PARAMETER:
         QMessageBox::critical(0, "Fehler", "Fehler im Systemaufruf: Ungültiger Parameter beim Auslesen von Informationen über Freigaben.");
         break;
      case ERROR_NOT_ENOUGH_MEMORY:
         QMessageBox::critical(0, "Fehler", "Nicht genügend verfügbarer Speicher um die Information auszulesen.");
         break;
      case ERROR_MORE_DATA:
         ok = true;
         break;
      case NERR_BufTooSmall:
         QMessageBox::critical(0, "Fehler", "Der übergebene Puffer ist für die benötigte Information zur klein.")
         break;
      default:
         ok = false;
         break;
   }
   return ok;
}

Gruß

Rudolf Grauberger

Für ein Projekt musste ich überprüfen ob ein Dienst installiert ist, da mit der Win API gewöhnungsbedürftig ist umzugehen, stelle ich diese Funktion allen zur Verfügung.

bool isInstalled(const QString &serviceName, const QString &serviceDisplayName)
{
   SC_HANDLE schSCManager = OpenSCManagerA(
                                                                    NULL,
                                                                    NULL,
                                                                   SC_MANAGER_CONNECT);

   if (schSCManager == NULL)
   {
      return false;
   }

   std::string zServiceName = serviceName;
  
   const int bufferSize = 4096;
   unsigned long buffer = bufferSize;
   char displayName[serviceDisplayName.lengt()];
  
   strcpy(displayName, serviceDisplayName.toLocal8Bit().data());
  
  
   BOOL bSuccess = GetServiceDisplayName(
                                          schSCManager,
                                          zServiceName.c_str(),
                                          displayName,
                                          &buffer);

   return bSuccess;
}

Diese Funktinalität ist ggf. dem einen oder anderen nützlich.

Viel Spaß mit dieser Funktion

Gruß

Rudolf Grauberger

Initially I practiced game development with QBasic 1.0 on an 8086 and an 80286.  I ascended to Turbo Pascal 6 on a 486.  This was using the borland graphics interface(BGI) library.  You can usually spot this library in play by the presence of a file named “egavga.bgi”.

I utilized some shareware or freeware ‘basic’ compiler to put some of those QBasic games into a standalone executable form(.exe file).

Next up, from the internet I obtained DJGPP c++ along with ALLEGRO library and installed it on a dos-based 486-dx2 66mhz, and performed some sprite editing with a dos image editor.  Everything up to this point was dos-based game development.

Feeling the  lure of the intenet I tried making a game applet in Java but applets suck.  I had with me an academic version of Visual c++ 6 on CD but I lost it so I basically had to make do with “alternative freeware c++ stuff” until Visual Studio Express was released.  Thus I spent a long time using Borland c++ 5.5 command line tools as I introduced myself to WINAPI.

As I started learning about OpenGL I made a 3D Pong-clone, and a simple polygon car travelling around a simple polygonal terrain.

Of all this, much of it ended up lost as hard disks began to fail.

Currently I’ve been working on a project that requires me to inject a DLL to an external program, and create a window under that process.
Looking on the web, there are really very few resources explaining how to do this.

I don’t know if this is the ‘correct’ way to do this, but it works.
The basic idea behind it:

• On inject
  • Create new thread
• On new thread
  • Register window class
  • CreateWindowEx + ShowWindow
  • GetMessage and send them to a WndProc

Right so, starting off.
Create a new Windows DLL and add windows.h as an include
Now on the DLLMain, the entrypoint for the DLL, you want to add the code to create a new thread:

BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call,LPVOID lpReserved)
{
	if(ul_reason_for_call==DLL_PROCESS_ATTACH) {
		inj_hModule = hModule;
		CreateThread(0, NULL, ThreadProc, (LPVOID)L"Window Title", NULL, NULL);
	}
	return TRUE;
}

Im passing our new windows title as the lParam for the tread, this is not necessary – and in this situation, silly.
Now we have a new thread, which has its start routine at ThreadProc
You will also need to create a new variable where we can store our modules handle:

HINSTANCE  inj_hModule;          //Injected Modules Handle

So now, lets set up our window.
We are going to create a function to register our window:

BOOL RegisterDLLWindowClass(wchar_t szClassName[])
{
    WNDCLASSEX wc;
    wc.hInstance =  inj_hModule;
    wc.lpszClassName = (LPCWSTR)szClassName;
    wc.lpfnWndProc = DLLWindowProc;
    wc.style = CS_DBLCLKS;
    wc.cbSize = sizeof (WNDCLASSEX);
    wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wc.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    wc.lpszMenuName = NULL;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
    if (!RegisterClassEx (&wc))
		return 0;
}

This function will register whatever class name is passed to it, again, in this situation it is unnecessary, you could just write:

wc.lpszClassName = (LPCWSTR)L"InjectedDLLWindowClass";

Now, we are going to make a function to create a menu for our window, to check that the messages are being received
Firstly, define two IDs for our menu

#define MYMENU_EXIT         (WM_APP + 101)
#define MYMENU_MESSAGEBOX   (WM_APP + 102)

Now the code for creating menus is fairly simple, we will just create 2 basic popup menus with two test buttons on, one to close the window, and one to display a messagebox.

HMENU CreateDLLWindowMenu()
{
	HMENU hMenu;
	hMenu = CreateMenu();
	HMENU hMenuPopup;
	if(hMenu==NULL)
           return FALSE;
	hMenuPopup = CreatePopupMenu();
	AppendMenu (hMenuPopup, MF_STRING, MYMENU_EXIT, TEXT("Exit"));
	AppendMenu (hMenu, MF_POPUP, (UINT_PTR) hMenuPopup, TEXT("File")); 

	hMenuPopup = CreatePopupMenu();
	AppendMenu (hMenuPopup, MF_STRING,MYMENU_MESSAGEBOX, TEXT("MessageBox")); 
	AppendMenu (hMenu, MF_POPUP, (UINT_PTR) hMenuPopup, TEXT("Test")); 
	return hMenu;
}

That returns a handle to our new menu, which we can pass to the CreateWindowEx function.
So, now lets deal with out ThreadProc, the start routine for the thread.
To begin with, I cast the lParam from a LPVOID – which contains our window name – back to a wchar_t
I then use the CreateDLLWindowMenu function and RegisterDLLWindowClass to be used in CreateWindowEx
Then just create the window, show it and handle the messages:

DWORD WINAPI ThreadProc( LPVOID lpParam )
{
	MSG messages;
	wchar_t *pString = reinterpret_cast<wchar_t * > (lpParam);
	HMENU hMenu = CreateDLLWindowMenu();
	RegisterDLLWindowClass(L"InjectedDLLWindowClass");
	prnt_hWnd = FindWindow(L"Window Injected Into ClassName", L"Window Injected Into Caption");
	HWND hwnd = CreateWindowEx (0, L"InjectedDLLWindowClass", pString, WS_EX_PALETTEWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 300, prnt_hWnd, hMenu,inj_hModule, NULL );
	ShowWindow (hwnd, SW_SHOWNORMAL);
	while (GetMessage (&messages, NULL, 0, 0))
	{
		TranslateMessage(&messages);
        	DispatchMessage(&messages);
	}
	return 1;
}

Since I wanted this window to have a parent, I used FindWindow to locate the handle, and passed that to the CreateWindowEx, you would need to add another HWND to your globals:

HWND       prnt_hWnd;            //Parent Window Handle

Now we need to set up our WndProc for the new window, this is stated in the RegisterDLLWindowClass:

wc.lpfnWndProc = DLLWindowProc;

So we create the WndProc and handle the messages that we will receive from the Menu (Exit and MessageBox)

LRESULT CALLBACK DLLWindowProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
		case WM_COMMAND:
               switch(wParam)
               {
                    case MYMENU_EXIT:
						SendMessage(hwnd, WM_CLOSE, 0, 0);
                        break;
                    case MYMENU_MESSAGEBOX:
						MessageBox(hwnd, L"Test", L"MessageBox",MB_OK);
                        break;
               }
               break;
		case WM_DESTROY:
			PostQuitMessage (0);
			break;
		default:
			return DefWindowProc (hwnd, message, wParam, lParam);
    }
    return 0;
}

Now if you were to inject this DLL into another process, you would get something that looked like this:

Below is the complete code listing.

#include "stdafx.h"
#include "windows.h"

#define MYMENU_EXIT         (WM_APP + 101)
#define MYMENU_MESSAGEBOX   (WM_APP + 102) 

HINSTANCE  inj_hModule;          //Injected Modules Handle
HWND       prnt_hWnd;            //Parent Window Handle

//WndProc for the new window
LRESULT CALLBACK DLLWindowProc (HWND, UINT, WPARAM, LPARAM);

//Register our windows Class
BOOL RegisterDLLWindowClass(wchar_t szClassName[])
{
    WNDCLASSEX wc;
    wc.hInstance =  inj_hModule;
	wc.lpszClassName = (LPCWSTR)L"InjectedDLLWindowClass";
    wc.lpszClassName = (LPCWSTR)szClassName;
    wc.lpfnWndProc = DLLWindowProc;
    wc.style = CS_DBLCLKS;
    wc.cbSize = sizeof (WNDCLASSEX);
    wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wc.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    wc.lpszMenuName = NULL;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
    if (!RegisterClassEx (&wc))
		return 0;
}
//Creating our windows Menu
HMENU CreateDLLWindowMenu()
{
	HMENU hMenu;
	hMenu = CreateMenu();
	HMENU hMenuPopup;
    if(hMenu==NULL)
        return FALSE;
    hMenuPopup = CreatePopupMenu();
	AppendMenu (hMenuPopup, MF_STRING, MYMENU_EXIT, TEXT("Exit"));
    AppendMenu (hMenu, MF_POPUP, (UINT_PTR) hMenuPopup, TEXT("File")); 

	hMenuPopup = CreatePopupMenu();
    AppendMenu (hMenuPopup, MF_STRING,MYMENU_MESSAGEBOX, TEXT("MessageBox")); 
    AppendMenu (hMenu, MF_POPUP, (UINT_PTR) hMenuPopup, TEXT("Test")); 
	return hMenu;
}

//The new thread
DWORD WINAPI ThreadProc( LPVOID lpParam )
{
    MSG messages;
	wchar_t *pString = reinterpret_cast<wchar_t * > (lpParam);
	HMENU hMenu = CreateDLLWindowMenu();
	RegisterDLLWindowClass(L"InjectedDLLWindowClass");
	prnt_hWnd = FindWindow(L"Window Injected Into ClassName", L"Window Injected Into Caption");
	HWND hwnd = CreateWindowEx (0, L"InjectedDLLWindowClass", pString, WS_EX_PALETTEWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 300, prnt_hWnd, hMenu,inj_hModule, NULL );
	ShowWindow (hwnd, SW_SHOWNORMAL);
    while (GetMessage (&messages, NULL, 0, 0))
    {
		TranslateMessage(&messages);
        DispatchMessage(&messages);
    }
    return 1;
}
//Our new windows proc
LRESULT CALLBACK DLLWindowProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
		case WM_COMMAND:
               switch(wParam)
               {
                    case MYMENU_EXIT:
						SendMessage(hwnd, WM_CLOSE, 0, 0);
                        break;
                    case MYMENU_MESSAGEBOX:
						MessageBox(hwnd, L"Test", L"MessageBox",MB_OK);
                        break;
               }
               break;
		case WM_DESTROY:
			PostQuitMessage (0);
			break;
		default:
			return DefWindowProc (hwnd, message, wParam, lParam);
    }
    return 0;
}

BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call,LPVOID lpReserved)
{
	if(ul_reason_for_call==DLL_PROCESS_ATTACH) {
		inj_hModule = hModule;
		CreateThread(0, NULL, ThreadProc, (LPVOID)L"Window Title", NULL, NULL);
	}
	return TRUE;
}

I mentioned accessing native Win32 APIs by .Net some time ago.

Today I came across a Sourceforge project called Managed Windows API, which provides a set of class to access various aspects of Win32. A couple of tools illustrate the use of the library.

I like TreeSizeSharp, a re-implementation of the TreeSize tool I often use if I find there’s not enough free space on my disks (again).

Hi there!

Se tinha uma coisa que me segurava quando estava começando a programar era subdividir meu programa. Sério. Até que isso se tornou insuportável quando tive que fazer um trabalho na facu, e escolhi usar OpenGL. DIgo, o usuário precisava digitar o que ele queria desenhar, entrar com os valores das medidas, e eu precisava desenhar. Oh Gosh! Minha saída foi usar threads, no que foi meu primeiro contado com Win32 API.

Sim, o trabalho ficou muito bom. Aliás, foi um puta trabalho em conjunto, meu, do Ports e do Baldim.

Tinha feito na época um .c todo comentado, tim-tim por tim-tim, até para futuras consultas. Pois bem, segue abaixo:

 /*
    só para constar:
        DWORD = double word;
    ora, WORD é um tipo do tamanho básico da sua máquina;
    assim sendo, se vc tá programando para uma máquina x86 (32 bits), uma WORD terá 32 bits [4 bytes]
    e adivinha? uma variável do tipo DWORD terá o dobro!! (nesse caso, 64 bits, ou 8bytes)

    Agora, se vc é fodão e tá programando para uma plataforma 64 bits, então vc pega tudo oq eu falei acima,
    e multiplica por 2 !
    =)

    ooooutra coisa
        LPVOID = void *

    simples assim.
    */

#include <cstdlib>
#include <iostream>
#define WIN32_LEAN_AND_MEAN //para deixar a importação da windows.h mais 'light'
#include <windows.h> //todas funções aqui listadas estão no windows.h.
using namespace std;

DWORD WINAPI Thread(LPVOID);
/*
    Defini a função que será minha thread. O nome Thread não é reservado, ou seja, se eu quisesse que minha
    thread chamasse pnc, faria:
        DWORD WINAPI pnc(LPVOID);
    sem problemas.

    Como vc pode ver, a API do Windows utiliza ponteiros para controlar uma Thread. Por isso que vc passa um ponteiro na
    chamada. Segue abaixo a definição oficial:

    DWORD (WINAPI *LPTHREAD_START_ROUTINE)(LPVOID)

*/

int main(int argc, char *argv[])
{
    DWORD id_da_thread;
    HANDLE manipulador_thread = CreateThread(0,0,Thread,0,CREATE_SUSPENDED,&id_da_thread); //retorna 0 se não criou, e o handle se criou
    int estado;
/*

    HANDLE WINAPI CreateThread(
    LPSECURITY_ATTRIBUTES ThreadAtt,
    SIZE_T Tamanho_da_Stack,
    LPTHREAD_START_ROUTINE sua_thread,
    LPVOID argumento,
    DWORD flags,
    LPDWORD id_da_sua_thread
    );  

    ThreadAtt:
    ponteiro para uma estrutura do tipo LPSECURITY_ATTRIBUTES que contém atributos de segurança da Thread.
    Se passado como ZERO, a Thread é criada com atributos padrões.

    Tamanho_da_Stack:
    tamanho que vc precisarah inicialmente da stack em bytes. Se ZERO, o sistema 'define' um tamanho padrão.
    Só é bom vc mexer nisso se vc souber oq vc tá fazendo...

    Argumento:
    um argumento opcional para a sua thread.

    Flags:
    Esse é importante: define o comportamento da Thread logo após ser criada.
    Vc pergunta: 'Mas como assim??'
    Eu digo:
        Se vc coloca um zero nisso, sua thread será 'executada automaticamente' ao ser criada...
        Ou seja, vai começar a executar o código que vc colocou lá, 'sozinha'.
        Agora, se vc colocar "CREATE_SUSPENDED" (sem as aspas, por favor), acontecerá o seguinte: a thread será criada,
        mas ela estará no 'pause', ou seja, ele existirá lá, bonitinha, e esperará vc dizer: 'rode filha, rode".
        Vc diz: "Meu Deus, como eu faço pra dizer 'rode filha, rode' ???
        Fácil. Graças a Deus tem uma função chamada ResumeThread(HANDLE manipulador_thread) que faz isso pra vc!
        Ficou com dúvidas sobre o ResumeThread()? Tem a sintaxe lá embaixo..!!

    ThreadId:
    ponteiro (sim, ponteiro.. por isso que usei o '&') para uma variável do tipo DWORD que irá armazenar a identificação
    da Thread. Se ZERO, o argumento é ignorado. 

    A função CreateThread() retorna um Handle para a thread criada, do contrário, é retornado um Handle Nulo, ou seja, ZERO.
*/

    if ( manipulador_thread == 0 ){ // não criou, manipulador é zero
        cout << "Não pude criar a thread" << endl;
        return 0;
    }

    cout << "Legal, criei a thread, vou exibir uma janela da sua main.." << endl;
    system("pause");
    MessageBox(0,"MENSAGEM DA MAIN","Minha primeira Thread",0);

    cout << "Ok, agora vou \"resumir\" a thread..." << endl ;
    cout << "Fica esperto que assim que eu resumir, abrira um messagebox... " << endl;
    system("pause");

    if ( (ResumeThread(manipulador_thread)) == 0 ){
        cout << "Não consegui resumir a thread!!" << endl;
        exit(-1);
    }
    cout << "Thread resumida com sucesso..." << endl;

    cout << "Bye!" << endl;

    WaitForSingleObject(manipulador_thread, INFINITE);
/*
    DWORD WINAPI WaitForSingleObject(HANDLE manipulador_thread,DWORD tempo);

    manipulador_thread:
    manipulador da Thread;

    tempo:
    tempo em milisegundos que o programa deve aguardar.
    Caso a constante "INFINITE" seja especificada, o programa aguarda o tempo necessário até que a Thread seja finalizada,
    retornando um valor.

    é como se fosse um timer..
    ele vê: "Hum, já se passaram XXX milisegundos.. hora de 'matar' a thread..!"
*/

/*

    Então temos algumas funções importantes:

    *********************************
    BOOL  TerminateThread ( HANDLE seu_manipulador_thread, DWORD codigo_saida );

    OK, aqui é fácil, certo?
    vc vai terminar a Thread cuja seu manipulador manipula (foda-se a redundância), e vc também saberá
    se vc obteve sucesso no que vc tava rodando nela.. (basicamente é o return que vc implementou nela.)

    foda né?
    mas não é só isso...
    se vc reparou, essa função tem um retorno booleano! Se vc receber 0 é pq vc NÃO conseguiu 'matar' a thread.
    Bom, isso significa que vc se fodeu? Provavelmente sim, mas não necessariamente.
    MAS, se vc receber um 0 (false) é pq deu tudo certo (torça por isso...+) ).
    *********************************

    ****************
    CloseHandle(th);

    Esse acho que não precisa dizer mais nada, a não ser que é um pseudo-free().
    Lembre-se: chame-a por último... seja esperto.
    ****************
    */

    system("pause");
    TerminateThread(manipulador_thread,0);
    CloseHandle(manipulador_thread);
    return 0;

}
/* FUNCOES IMPORTANTES:

**************
    DWORD WINAPI SuspendThread(HANDLE manipulador_thread);

     maipulador_handle:
            manipulador da thread que se deseja pausar;

        A função retorna 1 se a thread especificada for interrompida corretamente,
        ou retorna 0, se o processo falhar.
*************

*************
DWORD WINAPI ResumeThread(HANDLE manipulador_thread);

     manipulador_thread:
            manipulador da thread que se deseja resumir;

    A função retorna o valor 1 se a thread for resumida corretamente,
    ou retorna 0, se falhar.
**************

*/

//aqui começa minha thread

DWORD WINAPI Thread(LPVOID valor)
{
    MessageBox(0,"Mensagem da Thread","Aprendendo a mexer com Thread",0);
    return 0;
}

Espero que isso te ajude. É realmente muito simples… você cria, cria uma thread – mandando como parâmetro sua função, e então só controla seu funcionamento – pausa, suspende, continua, mata, etc…

Esse post é para aqueles que acham que foi o “Java que inventou as threads”. Tsc tsc…

Whoa!

Todos sabemos o que é o Twitter, e sim, gostamos pra caramba dele! Não tem a poluição gentalha gente feia inconveniência costumeira do Orkut, e só por esse fato já deveria ser adorado. Enfim, isso é opinião, e a minha – e como você está no meu blog, por favor, respeite.

Senta que lá vem a história: Há tempos que queria fazer uma integração C com Java. Bom, então surgiu uma grande oportunidade, uma vez que a biblioteca mais digna que acessa a biblioteca do Twitter que achei foi a JTwitter, que realmente é muito boa e fácil de usar. Enfim, já tinha feito, há algum tempo (em tempos remotos de Infra na Amdocs), um código em C++ que listava os processos que estavam rodando. (De certo modo, acho que é meio redundante a última frase, mas whatever)

Lá vai um resumo: Tranformei meu código em C++ numa dll e, utilizando um negócio bem porco (como Java, em geral), chamado JNI (Java Native Interface), fiz a integração do meu código em Java – que também utilizava a biblioteca JTwitter. Fiz um enhancement tolo para que reconhecesse mensagens enviadas diretamente para mim no Twitter, assim minha gororoba auto interagia com o meu suposto amigo, respondendo-o se eu estava ou não rodando tal processo  no momento. Sabe, falando agora, parece-me uma idéia tão ridícula… Mas foda-se.

Ingredientes:

- Saber como se acessa a API do WindowsX para listar processos. Tão ridículo que me dá comichões. Mas isso é assunto para outra hora.
- Saber como criar uma dll  – basicamente:

gcc -shared -o minhadll.dll meuobjeto.o

- Saber como fazer a integração de C com Java.

Acho que o que vale explorar é esse último tópico. É facil – verdade – mas precisa de atenção. Vou descrever, depois mostro na prática.

Basicamente, você cria um código em Java que carrega uma dll – ignore o fato de ela não existir; pelo menos por enquanto. Ao tentar rodá-lo, obviamente você terá um erro de linkagem. Mas não queremos que funcione! Queremos só ver como seria feita a chamada dessa dll em C. Rápido demais? Certo. Repare que, mesmo dando erro, seu javac gerou um .class! Amazing. Mas isso não justifica minha fala agorinha. Não? Claro que sim!

Existe um utiliário que a Sun bota na JDK dela, se não me engano desde a 1.1, chamado Javah (esse nome definitivamente me lembra os trocadilhos com Java, em tempos de técnico), que basicamente te gera headers e códigos em C a partir de uma .class.

Agora sim! Tudo se encaixa. Pseudo-criamos um código em Java com linkagem para nossa futura dll, vemos como fica a chamada em C/C++ usando o javah, fazemos um merge com nosso código na dll, compilamos-a, e enfim recompilamos nossa classe em Java que terá acesso ao Twitter!

Boralah, mãos a obra!

Código da DLL:

nomeei carinhosamente de TesteTwitter.cpp

#include <jni.h>
#include "TesteTwitter.h"
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include
<psapi.h>
#define     SIZE    1024

//some prototypes
int update_processes_array( DWORD *processes_array,
                            DWORD array_size,
                            DWORD *hm_processes,
                            DWORD bytes_returned);
int imprime_processo(DWORD pid);                            

/*
Procura o processo $nome. Se estiver rodando retorna seu PID, senão retorna 0
*/
int procura_processo(char * nome_processo){
    DWORD  * processes_array ; //array de processos, contem PIDs, e é do tamanho de SIZE
    DWORD  bytes_returned; //quantos processos tem no processes_array
    DWORD  array_size; //double word que armazenará o SIZE definido
    DWORD  hm_processes; //how many processes 
    HANDLE handle_processo;
    int i; //contador
    char nome[1024]; //armazenará o nome do módulo, null se der pau
    char *nome_upper; //diferencas de case
    //char * nome_processo_upper;
    nome_upper = (char *) malloc(sizeof(char)*1024);
    //nome_processo_upper = (char *) malloc(sizeof(char)*1024);

    if (nome_processo == NULL &#124;&#124; strlen(nome_processo) < 4 )
    // evita burrice, lembre-se: vc tá no windows, o strlen(processo) mínimo que vc tem é 4,
    // ou seja, .xxx  - extensão, meu fillho!
    {
        return 0; //fala que não achou
    }
    strcpy(nome,"null");//como dito 
    array_size = SIZE; //blah
    //alloc memory for processes' array
    processes_array = ( DWORD * ) malloc( sizeof(DWORD) * SIZE );
    //atualiza o array de processos 
    if ( hm_processes = update_processes_array(processes_array, array_size, &hm_processes, bytes_returned) ){
        printf("Array de Processos atualizado com sucesso");
    }else{
        printf("Erro ao atualizar lista de processos");
        return 0;
    }

    printf("\nNo momento, temos %d processos.", hm_processes);
    for (i=0; i<hm_processes; i++){
        //tenta pegar um handle pro processo, but retorna null se der pau
         handle_processo = OpenProcess(PROCESS_QUERY_INFORMATION &#124; PROCESS_VM_READ, FALSE, processes_array[i]);
         //consegui? então pega o moduleBaseName!
         if( handle_processo != NULL){
             HMODULE vetor_handle_modulo;
             DWORD tamanho;
             if(EnumProcessModules(handle_processo, &vetor_handle_modulo, sizeof(vetor_handle_modulo), &tamanho)){
                 GetModuleBaseName( handle_processo, vetor_handle_modulo, nome, sizeof(nome)/sizeof(char));
             }
        }

        nome_upper = strupr(strdup(nome));
        nome_processo = strupr(strdup(nome_processo));
        if(! strcmp(nome_processo,nome_upper) ){  //ve se o processo atual (processes_array[i]) é o processo que estamos looking for.
            printf("\nAchei o %s", nome);
            CloseHandle(handle_processo);
            return (int)processes_array[i];
        }
    }
    printf("\nProcess %s not found!",nome_processo);
}

bool get_Processes( DWORD * processes_array,
                    DWORD size_processes_array,
                    DWORD *bytes_returned)
{

    if ( EnumProcesses( processes_array , size_processes_array , bytes_returned ) )
        return true;
    else
        return false;

}

/*
Recebe um PID e imprime (ou pelo menos tenta imprimir) seu module name
*/
int imprime_processo( DWORD pid ){
     //armazenará o nome do módulo, null se der pau
     char nome[1024];
     strcpy(nome,"null");
     //tenta pegar um handle pro processo, but retorna null se der pau
     HANDLE handle_processo = OpenProcess(PROCESS_QUERY_INFORMATION &#124; PROCESS_VM_READ, FALSE, pid);
     //consegui? então pega o moduleBaseName!
     if( handle_processo != NULL){
         HMODULE vetor_handle_modulo;
         DWORD tamanho;
         if(EnumProcessModules(handle_processo, &vetor_handle_modulo, sizeof(vetor_handle_modulo), &tamanho)){
             GetModuleBaseName( handle_processo, vetor_handle_modulo, nome, sizeof(nome)/sizeof(char));
         }
    }
    printf("%u  -  %s", pid, nome);
    CloseHandle(handle_processo);
    if(pid)
        return pid;
    return 0;
}

/*
returns:
    < -1  >     -    if fails on get_processes function
    < >= 0 >    -    how many processes are running at this moment
*/
int update_processes_array( DWORD *processes_array,
                            DWORD array_size,
                            DWORD *hm_processes,
                            DWORD bytes_returned){
    if (! get_Processes( processes_array , array_size , &bytes_returned) )
            return -1;
        else
            return *hm_processes = bytes_returned / sizeof(DWORD) ;

}

JNIEXPORT jint JNICALL Java_TesteTwitter_escreve(JNIEnv *env , jobject obj, jstring processo)
{
//Meu Deus, que palavras feias são essas! Pois é, também acho. Isso vem do .h gerado ao vc rodar o javah
//que, aliás, não disse comofas:
// javah classe_java
//ele vai te gerar um .h. A partir dele, vc se vira.
        int resultado = 0;
        jboolean iscopy; //boolean do java
        const char  *nome_processo = (env) -> GetStringUTFChars(processo,&iscopy);
        if (nome_processo == NULL){
            return 0; // erro em alocação de memória
        }
        printf("\n%s\n",nome_processo);
        resultado = procura_processo((char *)nome_processo);
        return resultado;
}

Seria legal se você tirasse, depois de entender o código e vê-lo rodar, todos os printf()’s da DLL. Isso não se faz.

Você também vai precisar de um arquivo .def, contendo informações básicas, tipo:

Java_Programa_método-a-ser-exportado

EXPORTS
Java_TesteTwitter_escreve

Agora, bora compilar isso. Pay attention here!!

Primeiro você vai gerar um .o, nos moldes simples:

gcc -c -I"path que vc quiser incluir (onde estiverem libraries que vc botou no include, por exemplo)" -o nome_do_objeto.o sourcecode.cpp

Importante você saber que, como você está usando a JNI.h, você precisa colocar o Path de seu header e implementação (JDK_folder\include e JDK_folder\include\win32). Ficaria algo do gênero:

gcc -c -I"C:\Arquivos de programas\java\jdk1.6.0_11\include" -I"C:\Arquivos de programas\java\jdk1.6.0_11\include\win32" -o TesteTwitter.o TesteTwitter.cpp

Agora que você já tem seu nome_do_objeto.o, mande bala:

gcc -shared -o"meu_path\minhadll.dll" "meu_path\nome_do_objeto.o" "meu_path\meu_file_de_definicao.def" -lpsapi

//ou, pegando na sua mão,

gcc -shared -o"C:\Users\Cael\TesteTwitter.dll"  "C:\users\Cael\TesteTwitter.o" "C:\Users\cael\TesteTwitter.def" -lpsapi

//coisa que vc precisa saber: -lpsapi diz ao gcc que vc está usando rotinas da biblioteca PSAPI. Óbvio.

Se tudo der certo, você tem sua DLL!

Agora vamos a parte do Java (eu sei, eu sei, fazer o quê.. )

import java.util.List;
import winterwell.jtwitter.*; //dando import na library JTwitter
import winterwell.jtwitter.Twitter.Message;

public class TesteTwitter {
    static long ultimo=45871821; //ID da mensagem que, a partir dela, o código irá responder
    public native int escreve(String processo);   
    static{
    System.load("C:/Users/Cael/TesteTwitter.dll");
    System.out.println("Loaded");
    }
    public static void main(String[] args) {
        int PID;
        List<Message> lista;
        Message mensagem;
        Twitter cael = new Twitter("meu_login","minha_senha"); //preciso te lembrar de alterar?
        while (1==1){
            try {
                Thread.currentThread().sleep(60000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(cael.getRateLimitStatus());
            lista=cael.getDirectMessages();
            if (lista.size() > 0){
                mensagem = lista.get(0);
                System.out.println(mensagem.getText());
                if (mensagem.getId() != ultimo){

                    /*DEBUGGER*/

                    System.out.println("Mensagem nova!");
                    System.out.println("DE: " + mensagem.getSender());
                    System.out.println("TEXTO: " + mensagem.getText());

                    /*END*/

                    PID = new TesteTwitter().escreve(mensagem.getText());
                    if (PID !=0){
                        cael.setStatus("@" + mensagem.getSender().screenName +  " Sim, estou rodando o " + mensagem.getText() + ". PID " + PID);
                    }else{
                        cael.setStatus("@" + mensagem.getSender().screenName +  " Não estou rodando o " + mensagem.getText() + ". Retorno da API (PID) " + PID );

                    }
                    ultimo = mensagem.getId();
                    System.out.println("Twitter respondido!");
                    System.out.println("Para " + mensagem.getSender());
                    System.out.println("ULTIMO = " + ultimo);
                }           
            }
        }
    }
}

Warnings:

- O Twitter tem uma política de acesso aos seus dados via API. Sugiro que você dê uma pesquisada, antes que tenha sua conta bloqueada (como eu) por algumas horas. Isso te explica o Sleep() no código.

- Sim, o código tá muito verbose. Portanto, altere-o do jeito que você quiser.

- A variável estática ultimo está sendo atualizada durante a execução. E somente durante. Você pode alterá-la, salvá-la, armazená-la do jeito que você quiser após rodar o código. Senão, toda vez que você rodar, ele vai responder tudo de novo. Eu ainda estou no CTRL+C/V, pois não quero gastar muito tempo com esse assunto, e porque, principalmente, odeio Java.

Fiz uns updates para criar e matar processos remotamente, coisa fácil. Vá na pagina do msdn que te passei o link, comece a fuçar por lá. Mas cuidado com isso, não deixe ninguém rodar processo remotamente na sua máquina. Ou deixe.

Dúvidas, sugestões, declarações de amor ou xingamentos, comente.

Abraços,

Cael

I like Fallout. Since 10 years I still play Fallout2 at least once a year. And I got an idea to use Fallout characters for my desktop application. I decided to get original FRM files, add them as application resources and then convert them to bitmaps.
It took just a few minutes to find FRM file format specs here and a couple of useful programs:

• unDAT 1.01 – for extracting resource files out of game .dat archives.
• Viewer for FALLOUT2 v1.3 – for viewing unpacked FRM files.

I used Cyberdog as main character, and the Child as additional character. Cyberdog runs after mouse cursor, and 3 children just walk on a screen. Additionally, children are running from Cyberdog.

This is the project and exe file (as usual, rename .doc to .zip after downloading). Enjoy! Btw, program has no interface. Use Task Manager to exit