विंडो अनुप्रयोगों के लिए एक सरल WinAPI आवरण बनाना

कुछ समय पहले मुझे C ++ का उपयोग करके विंडोज के लिए एक विंडो लाइब्रेरी बनाने का शौक था। और आज मैं आपको बताऊंगा कि विन्डैप किए गए एप्लिकेशन बनाने के लिए WinAPI पर एक साधारण आवरण कैसे लिखें।

जैसा कि आप जानते हैं, नंगे एपीआई पर एक एप्लिकेशन में WinMain फ़ंक्शन (विंडो अनुप्रयोगों के लिए मुख्य के अनुरूप) में प्रसंस्करण संदेशों के लिए WinProc फ़ंक्शन होते हैं।

कक्षाओं में एपीआई कार्यों को लपेटने में मुख्य कठिनाई WinProc को छिपाने और एक सुगम संदेश प्रसंस्करण प्रणाली बनाने के लिए है।

हमारे रैपर में दो वर्ग शामिल होंगे: CApp और CWnd। पहला अनुप्रयोग वर्ग है, इसके अंदर मुख्य संदेश लूप है। दूसरा विंडो क्लास है।

सबसे पहले, एक आवेदन वर्ग लिखें। यह बहुत आसान है:

//
class CApp
{
public :
//
//
void Run()
{
MSG msg;
while (GetMessage(&msg,0,0,0)!=0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
};

* This source code was highlighted with Source Code Highlighter .

इसमें एक एकल रन फ़ंक्शन होता है, जिसके अंदर एक वादा लूप होता है।
लूप में, प्रोग्राम संदेशों को प्राप्त करता है और उन्हें विंडो फ़ंक्शन (WinProc) पर पुनर्निर्देशित करता है।

आगे हम CWnd क्लास बनाएंगे:

//
class CWnd
{
//
typedef LRESULT (CWnd::*FuncPointer)(LPARAM,WPARAM);

// -
struct POINTER
{
CWnd* wnd; // ,
FuncPointer func;
};

protected :
HWND _hwnd; //
map<UINT,POINTER> _msgmap;//

* This source code was highlighted with Source Code Highlighter .

इसमें विंडो का हैंडल (HWND) और संदेशों का मैप होता है।
हम पॉइंटर के प्रकार को हैंडलर फ़ंक्शन (फंकपॉइंटर) और पॉइंटर संरचना की भी घोषणा करते हैं। इस संरचना में एक फ़ंक्शन के लिए एक पॉइंटर और एक पॉइंटर को उस वर्ग के ऑब्जेक्ट में रखा जाता है जिससे वह संबंधित है।

फिर हम विंडो निर्माण कार्य को जोड़ते हैं:

//
bool Create(
HWND parent, // , 0 -
LPCWSTR text, //
DWORD exstyle,DWORD style, //
int x, int y, int w, int h, //
UINT id //
)
{
//
WNDCLASSEX wndc;
wndc.lpszClassName=L "MyWnd" ;
wndc.cbSize= sizeof (WNDCLASSEX);
wndc.lpfnWndProc=WNDPROC(_WndProc); //
wndc.cbClsExtra=0;
wndc.cbWndExtra=0;
wndc.hbrBackground=HBRUSH(COLOR_WINDOW); //
wndc.hInstance=GetModuleHandle(0); //
wndc.hCursor=LoadCursor(0,IDC_ARROW); //
wndc.style=CS_HREDRAW|CS_VREDRAW;
wndc.hIcon=0;
wndc.hIconSm=0;
wndc.lpszMenuName=0;
RegisterClassEx(&wndc);

//
_hwnd=CreateWindowEx(exstyle,L "MyWnd" ,text,
style|WS_CLIPCHILDREN, // WS_CLIPCHILDREN ,
x,y,w,h,parent,HMENU(id),
GetModuleHandle(0),
this //
);

if (!_hwnd) return false ;
return true ;
}

* This source code was highlighted with Source Code Highlighter .

इसमें, हम विंडो क्लास को रजिस्टर करते हैं और CreateWindowEx फ़ंक्शन का उपयोग करके स्वयं विंडो बनाते हैं।
हम Cwnd के एक सूचक से CreateWindowEx तक एक संकेतक भी पास करते हैं ताकि हम बाद में API हैंडल (HWND) और CWnd के हमारे उदाहरण को जोड़ सकें।

अब मुख्य बिंदु पर आते हैं।
हमारी कक्षा में एक विंडो फ़ंक्शन जोड़ें। यह स्थिर होना चाहिए।

//
//
static LRESULT CALLBACK _WndProc(HWND hwnd,UINT message,WPARAM wparam,LPARAM lparam)
{
CWnd *wnd=0;
// WM_NCCREATE WM_CREATE
//.
if (message==WM_NCCREATE)
{
// , CreateWindowEx
wnd=(CWnd*)LPCREATESTRUCT(lparam)->lpCreateParams;
// GWL_USERDATA
SetWindowLong(hwnd,GWL_USERDATA,LONG(LPCREATESTRUCT(lparam)->lpCreateParams));
wnd->_hwnd=hwnd;
}
// , GWL_USERDATA
wnd=(CWnd*)GetWindowLong(hwnd,GWL_USERDATA);
if (wnd)
{
//
map<UINT,POINTER>::iterator it;
it=wnd->_msgmap.find(message);

// ,
if (it==wnd->_msgmap.end()) return DefWindowProc(hwnd,message,wparam,lparam);
else
{
POINTER msg=it->second;
//
LRESULT result=(msg.wnd->*msg.func)(lparam,wparam);
if (result) return result;
}
}
return DefWindowProc(hwnd,message,wparam,lparam);
}
};

* This source code was highlighted with Source Code Highlighter .

इसमें निम्न होता है। पहले हम WM_NCCREATE संदेश को पकड़ते हैं। इसमें, हम पॉइंटरवॉन्डे को पॉइंटर पास करते हैं और इसे विंडो के GWL_USERDATA फ़ील्ड में सहेजते हैं। अब किसी भी समय हम हाथ पर केवल HWND के साथ CWnd उदाहरण के लिए एक संकेतक प्राप्त कर सकते हैं।
अगला, हम नक्शे में वर्तमान संदेश की तलाश करते हैं, और यदि यह है, तो इस नक्शे से हैंडलर को सूचक द्वारा कॉल करें।

अब हम एक फ़ंक्शन लिखते हैं जो मानचित्र में एक संदेश जोड़ देगा:

//
// - T - CWnd
template<typename T>
bool AddMessage(UINT message,CWnd* wnd,LRESULT (T::*funcpointer)(LPARAM,WPARAM))
{
if (!wnd || !funcpointer) return false ;

POINTER msg;
msg.wnd=wnd;
msg.func=reinterpret_cast<FuncPointer>(funcpointer);

_msgmap.insert(pair<UINT,POINTER>(message,msg));

return true ;
}

* This source code was highlighted with Source Code Highlighter .

यह एक बॉयलरप्लेट फ़ंक्शन है और यह निम्नलिखित कार्य करता है। किसी भी CWnd वंश सदस्य वर्ग के सदस्य फ़ंक्शन के लिए एक सूचक को एक सूचक में CWnd के सदस्य फ़ंक्शन में कनवर्ट करता है। सभी पॉइंटर्स को एक ही प्रकार पर लाने के लिए यह आवश्यक है।

बस, हमारा रैपर तैयार है।
उपयोग उदाहरण:

// CWnd
class CMyWnd: public CWnd
{
public :
CMyWnd()
{
// WM_CREATE WM_DESTROY
AddMessage(WM_CREATE, this ,&CMyWnd::OnCreate);
AddMessage(WM_DESTROY, this ,&CMyWnd::OnDestroy);
}
LRESULT OnCreate(LPARAM lparam,WPARAM wparam)
{
MessageBox(0,_T( "HelloHabr!" ),_T( "" ),0);
return 0;
}
LRESULT OnDestroy(LPARAM lparam,WPARAM wparam)
{
PostQuitMessage(0);
return 0;
}
};

int APIENTRY WinMain(HINSTANCE hinst,HINSTANCE prev,LPSTR cmd, int showcmd)
{
//
CMyWnd *wnd= new CMyWnd;
wnd->Create(0,L "HelloHabr!" ,0,WS_OVERLAPPEDWINDOW|WS_VISIBLE,300,300,500,400,0);

//
CApp *app= new CApp;
app->Run();
return 0;
}

* This source code was highlighted with Source Code Highlighter .

एक साधारण विंडो बनाने के लिए, हम CWnd से विरासत में आते हैं, संदेशों के लिए हैंडलर जोड़ते हैं, उन्हें मानचित्र में जोड़ते हैं और एप्लिकेशन तैयार होता है।