1. घर
  2. सवाल और जवाब
  3. Win32 API

Win32 API

2010-05-22 11 views
8

का उपयोग करके एकाधिक विंडो कैसे बनाएं I मुझे बहुत सारे ट्यूटोरियल और आलेख दिखाई देते हैं जो मुझे दिखाते हैं कि एक साधारण विंडोज प्रोग्राम कैसे बनाना है, जो कि बहुत अच्छा है लेकिन उनमें से कोई भी मुझे कई विंडो बनाने का तरीका दिखाता है।Win32 API

अभी मैं काम कर रहा है कोड है कि बनाता है और एक स्तरित खिड़की खींचता है और मैं GDI का उपयोग कर कुछ भी मैं इस पर चाहते हैं आकर्षित करने के लिए सामान Blit सकते हैं, यह चारों ओर आदि

खींचें यह पारदर्शी बनाने के भी, लेकिन मैं चाहता था एक दूसरा आयताकार क्षेत्र जिसे मैं आकर्षित कर सकता हूं, चारों ओर खींच सकता हूं, आदि। दूसरे शब्दों में, दूसरी विंडो। शायद यह एक बाल खिड़की होना चाहते हैं। सवाल यह है कि मैं इसे कैसे बना सकता हूं?

इसके अलावा, यदि कोई भी विंडोज एपीआई में विंडो प्रबंधन के लिए लेख या ट्यूटोरियल जैसे किसी भी अच्छे संसाधन (ऑनलाइन अधिमानतः) जानता है, तो कृपया साझा करें।

स्रोत

2010-05-22 Steven Lu

उत्तर

6

आप CreateWindow (हिट कर सकते हैं) एक बार से अधिक अगर आप चाहते हैं। आपके WinMain में संदेश लूप WinMain द्वारा बनाई गई सभी विंडो में ईवेंट पास करेगा। यदि आप चाहें तो पहले दो के हैंडल होने के लिए आप दो ओवरलैप्ड विंडो भी बना सकते हैं और दूसरी की पैरेंट विंडो सेट कर सकते हैं।

स्रोत

2010-05-22 02:04:30 JustJeff

+0

मुझे यह काम मिल गया, अंततः। यह काम करता है जब मैंने अपनी दिनचर्या को संशोधित किया जो विंडोज़ को एक अलग क्लासनाम स्ट्रिंग का उपयोग करके विंडो क्लास को पंजीकृत करने की अनुमति देकर बनाता है। यदि कार्यक्षमता को वही रहना चाहिए तो मुझे दूसरी विंडो के लिए एक अलग विंडो क्लास बनाने की आवश्यकता क्यों होगी? –

+0

@ स्टेवन लू: सुनिश्चित नहीं है। परीक्षण जो मैंने केवल एक पंजीकृत विंडो विंडो को दोबारा जांचने के लिए भाग लिया था और दो बार बनाएँविंडो बनाने में सक्षम था। बेशक, इसका मतलब है कि वे एक WNDProc साझा करते हैं। आपके पास WNDProc के अंदर स्थिर डेटा नहीं है, है ना? – JustJeff

+0

मैं अभी भी एक ही विंडो प्रो का उपयोग कर रहा था, लेकिन इसे एक अलग विंडो क्लास होना था, यानी मुझे 'RegisterClassEx' को एक अलग' WNDCLASSEX :: lpszClassName' के साथ कॉल करना पड़ा। क्या यह सामान्य है? –

2

आप CreateWindow/CreateWindowEx का उपयोग करके जितनी चाहें उतनी खिड़कियां बना सकते हैं, जैसा कि आप चाहते हैं (मालिक/बच्चे) के बीच संबंधों के साथ।

आप एक खिड़की "स्वामित्व" के साथ अन्य द्वारा बना सकते हैं:

SetWindowLongPtr(hwnd, GWLP_HWNDPARENT, (LONG_PTR) hwndParent);

बच्चे के लिए एक खिड़की बदलने के लिए, SetParent का उपयोग करें।

ध्यान दें कि SetWindowLongPtrGWLP_HWNDPARENT के साथ कॉल सेटपैंट के रूप में व्यवहार नहीं करता है (एमएसडीएन इस पर गलत है)। GWLP_HWNDPARENT विंडो को "बच्चे" में परिवर्तित नहीं करता है, बल्कि "स्वामित्व" के लिए।

स्रोत

2010-05-22 02:05:19

+0

आप निर्माता विंडो हैंडल को 'CreateWindow [Ex]' कॉल ('hWndParent' पैरामीटर) में पास करके मालिक/स्वामित्व वाले संबंध बनाते हैं। यदि 'WS_CHILD' विंडो शैली मौजूद नहीं है, तो' hWndParent' स्वामी होगा। यदि ऐसा है, तो 'hWndParent' पैरेंट विंडो को नामित करेगा, और इसके बजाय अभिभावक/बाल संबंध स्थापित किया जाएगा। – IInspectable

7

एक से अधिक विंडो बनाने के लिए, दूसरी विंडो बनाने के लिए पहली विंडो बनाने के दौरान किए गए सभी चरणों को दोहराएं। ऐसा करने का एक अच्छा तरीका है पहली कोड से सभी कोड कॉपी और पेस्ट करें। फिर दूसरी विंडो के अनूठे नामों के साथ पहली विंडो के सभी नामों को प्रतिस्थापित करने के लिए खोज और प्रतिस्थापन करें। जिस कोड में मैं बस करता हूं वह नीचे है।

ध्यान देने योग्य सबसे महत्वपूर्ण बात यह है कि दूसरी विंडो के लिए विंडोज क्लास कोड लाइन "windowclassforwindow2.lpszClassName =" विंडो क्लास 2 "पर एक अद्वितीय नाम होना चाहिए। यदि इसका कोई अद्वितीय नाम नहीं है, तो खिड़कियों पंजीकरण असफल हो जायेगी।

#include <windows.h> 

LRESULT CALLBACK windowprocessforwindow1(HWND handleforwindow1,UINT message,WPARAM wParam,LPARAM lParam); 
LRESULT CALLBACK windowprocessforwindow2(HWND handleforwindow2,UINT message,WPARAM wParam,LPARAM lParam); 

bool window1closed=false; 
bool window2closed=false; 

int WINAPI WinMain(HINSTANCE hInst,HINSTANCE hPrevInst,LPSTR lpCmdLine,int nShowCmd) 
{ 
    bool endprogram=false; 

    //create window 1 

    WNDCLASSEX windowclassforwindow1; 
    ZeroMemory(&windowclassforwindow1,sizeof(WNDCLASSEX)); 
    windowclassforwindow1.cbClsExtra=NULL; 
    windowclassforwindow1.cbSize=sizeof(WNDCLASSEX); 
    windowclassforwindow1.cbWndExtra=NULL; 
    windowclassforwindow1.hbrBackground=(HBRUSH)COLOR_WINDOW; 
    windowclassforwindow1.hCursor=LoadCursor(NULL,IDC_ARROW); 
    windowclassforwindow1.hIcon=NULL; 
    windowclassforwindow1.hIconSm=NULL; 
    windowclassforwindow1.hInstance=hInst; 
    windowclassforwindow1.lpfnWndProc=(WNDPROC)windowprocessforwindow1; 
    windowclassforwindow1.lpszClassName=L"windowclass 1"; 
    windowclassforwindow1.lpszMenuName=NULL; 
    windowclassforwindow1.style=CS_HREDRAW|CS_VREDRAW; 

    if(!RegisterClassEx(&windowclassforwindow1)) 
    { 
     int nResult=GetLastError(); 
     MessageBox(NULL, 
      L"Window class creation failed", 
      L"Window Class Failed", 
      MB_ICONERROR); 
    } 

    HWND handleforwindow1=CreateWindowEx(NULL, 
     windowclassforwindow1.lpszClassName, 
      L"Parent Window", 
      WS_OVERLAPPEDWINDOW, 
      200, 
      150, 
      640, 
      480, 
      NULL, 
      NULL, 
      hInst, 
      NULL    /* No Window Creation data */ 
); 

    if(!handleforwindow1) 
    { 
     int nResult=GetLastError(); 

     MessageBox(NULL, 
      L"Window creation failed", 
      L"Window Creation Failed", 
      MB_ICONERROR); 
    } 

    ShowWindow(handleforwindow1,nShowCmd); 

    // create window 2 

    WNDCLASSEX windowclassforwindow2; 
    ZeroMemory(&windowclassforwindow2,sizeof(WNDCLASSEX)); 
    windowclassforwindow2.cbClsExtra=NULL; 
    windowclassforwindow2.cbSize=sizeof(WNDCLASSEX); 
    windowclassforwindow2.cbWndExtra=NULL; 
    windowclassforwindow2.hbrBackground=(HBRUSH)COLOR_WINDOW; 
    windowclassforwindow2.hCursor=LoadCursor(NULL,IDC_ARROW); 
    windowclassforwindow2.hIcon=NULL; 
    windowclassforwindow2.hIconSm=NULL; 
    windowclassforwindow2.hInstance=hInst; 
    windowclassforwindow2.lpfnWndProc=(WNDPROC)windowprocessforwindow2; 
    windowclassforwindow2.lpszClassName=L"window class2"; 
    windowclassforwindow2.lpszMenuName=NULL; 
    windowclassforwindow2.style=CS_HREDRAW|CS_VREDRAW; 

    if(!RegisterClassEx(&windowclassforwindow2)) 
    { 
     int nResult=GetLastError(); 
     MessageBox(NULL, 
      L"Window class creation failed for window 2", 
      L"Window Class Failed", 
      MB_ICONERROR); 
    } 

    HWND handleforwindow2=CreateWindowEx(NULL, 
     windowclassforwindow2.lpszClassName, 
      L"Child Window", 
      WS_OVERLAPPEDWINDOW, 
      200, 
      150, 
      640, 
      480, 
      NULL, 
      NULL, 
      hInst, 
      NULL); 

    if(!handleforwindow2) 
    { 
     int nResult=GetLastError(); 

     MessageBox(NULL, 
      L"Window creation failed", 
      L"Window Creation Failed", 
      MB_ICONERROR); 
    } 

    ShowWindow(handleforwindow2,nShowCmd); 
    SetParent(handleforwindow2,handleforwindow1); 
    MSG msg; 
    ZeroMemory(&msg,sizeof(MSG)); 
    while (endprogram==false) { 
     if (GetMessage(&msg,NULL,0,0)); 
     { 
      TranslateMessage(&msg); 
      DispatchMessage(&msg); 
     } 
     if (window1closed==true && window2closed==true) { 
      endprogram=true; 
     } 
    } 
    MessageBox(NULL, 
    L"Both Windows are closed. Program will now close.", 
    L"", 
    MB_ICONINFORMATION); 
    return 0; 
} 

LRESULT CALLBACK windowprocessforwindow1(HWND handleforwindow,UINT msg,WPARAM wParam,LPARAM lParam) 
{ 
    switch(msg) 
    { 
     case WM_DESTROY: { 
      MessageBox(NULL, 
      L"Window 1 closed", 
      L"Message", 
      MB_ICONINFORMATION); 

      window1closed=true; 
      return 0; 
     } 
     break; 
    } 

    return DefWindowProc(handleforwindow,msg,wParam,lParam); 
} 

LRESULT CALLBACK windowprocessforwindow2(HWND handleforwindow,UINT msg,WPARAM wParam,LPARAM lParam) 
{ 
    switch(msg) 
    { 
     case WM_DESTROY: { 
      MessageBox(NULL, 
      L"Window 2 closed", 
      L"Message", 
      MB_ICONINFORMATION); 

      window2closed=true; 
      return 0; 
     } 
     break; 
    } 

    return DefWindowProc(handleforwindow,msg,wParam,lParam); 
}

एक अधिक जटिल उदाहरण का इस्तेमाल करने वाली कार्यों विंडो बनाने के लिए।

एक समारोह के बिना प्रत्येक विंडो बनाना अव्यवस्थित-विशेष रूप से अगर यह बयान करता है, तो में है कोड बनाने के हो सकता है। नीचे दिया गया कोड एक अलग एफ का उपयोग करता है प्रत्येक खिड़की बनाने के लिए एकीकरण। अगली विंडो बनाने के लिए पहले तीन विंडो में एक विंडो विंडो बनाएं।

#include <Windows.h> 

LRESULT CALLBACK windowprocessforwindow1(HWND handleforwindow1,UINT message,WPARAM wParam,LPARAM lParam); 
LRESULT CALLBACK windowprocessforwindow2(HWND handleforwindow1,UINT message,WPARAM wParam,LPARAM lParam); 
LRESULT CALLBACK windowprocessforwindow3(HWND handleforwindow1,UINT message,WPARAM wParam,LPARAM lParam); 
LRESULT CALLBACK windowprocessforwindow4(HWND handleforwindow1,UINT message,WPARAM wParam,LPARAM lParam); 

#define createwindowbuttoninwindow1 101 
#define createwindowbuttoninwindow2 201 
#define createwindowbuttoninwindow3 301 

bool window1open,window2open,window3open,window4open=false; 
bool windowclass1registeredbefore,windowclass2registeredbefore, 
    windowclass3registeredbefore,windowclass4registeredbefore=false; 

enum windowtoopenenumt {none,window2,window3,window4}; 

windowtoopenenumt windowtoopenenum=none; 

void createwindow2(WNDCLASSEX& wc,HWND& hwnd,HINSTANCE hInst,int nShowCmd); 
void createwindow3(WNDCLASSEX& wc,HWND& hwnd,HINSTANCE hInst,int nShowCmd); 
void createwindow4(WNDCLASSEX& wc,HWND& hwnd,HINSTANCE hInst,int nShowCmd); 

int WINAPI WinMain(HINSTANCE hInst,HINSTANCE hPrevInst,LPSTR lpCmdLine,int nShowCmd) 
{ 
    bool endprogram=false; 
    WNDCLASSEX windowclassforwindow2; 
    WNDCLASSEX windowclassforwindow3; 
    WNDCLASSEX windowclassforwindow4; 
    HWND handleforwindow2; 
    HWND handleforwindow3; 
    HWND handleforwindow4; 

    //create window 1 
    MSG msg; 
    WNDCLASSEX windowclassforwindow1; 
    ZeroMemory(&windowclassforwindow1,sizeof(WNDCLASSEX)); 
    windowclassforwindow1.cbClsExtra=NULL; 
    windowclassforwindow1.cbSize=sizeof(WNDCLASSEX); 
    windowclassforwindow1.cbWndExtra=NULL; 
    windowclassforwindow1.hbrBackground=(HBRUSH)COLOR_WINDOW; 
    windowclassforwindow1.hCursor=LoadCursor(NULL,IDC_ARROW); 
    windowclassforwindow1.hIcon=NULL; 
    windowclassforwindow1.hIconSm=NULL; 
    windowclassforwindow1.hInstance=hInst; 
    windowclassforwindow1.lpfnWndProc=(WNDPROC)windowprocessforwindow1; 
    windowclassforwindow1.lpszClassName=L"window class 1"; 
    windowclassforwindow1.lpszMenuName=NULL; 
    windowclassforwindow1.style=CS_HREDRAW|CS_VREDRAW; 

    if(!RegisterClassEx(&windowclassforwindow1)) 
    { 
     int nResult=GetLastError(); 
     MessageBox(NULL, 
      L"Window class creation failed", 
      L"Window Class Failed", 
      MB_ICONERROR); 
    } 

    HWND handleforwindow1=CreateWindowEx(NULL, 
      windowclassforwindow1.lpszClassName, 
      L"Window 1", 
      WS_OVERLAPPEDWINDOW, 
      200, 
      150, 
      640, 
      480, 
      NULL, 
      NULL, 
      hInst, 
      NULL    /* No Window Creation data */ 
); 

    if(!handleforwindow1) 
    { 
     int nResult=GetLastError(); 

     MessageBox(NULL, 
      L"Window creation failed", 
      L"Window Creation Failed", 
      MB_ICONERROR); 
    } 

    ShowWindow(handleforwindow1,nShowCmd); 
    bool endloop=false; 
    while (endloop==false) { 
     if (GetMessage(&msg,NULL,0,0)); 
     { 
      TranslateMessage(&msg); 
      DispatchMessage(&msg); 
     } 

     if (windowtoopenenum !=none) { 
      switch (windowtoopenenum) { 
       case window2: 
        if (window2open==false) {              
         createwindow2(windowclassforwindow2,handleforwindow2,hInst,nShowCmd); 
        } 
        break; 
       case window3: 
        if (window3open==false) {   
         createwindow3(windowclassforwindow3,handleforwindow3,hInst,nShowCmd); 
        } 
        break; 
       case window4:    
        if (window4open==false) {    
         createwindow4(windowclassforwindow4,handleforwindow4,hInst,nShowCmd); 
        } 
        break; 
      } 
     windowtoopenenum=none; 
    } 
    if (window1open==false && window2open==false && window3open==false && window4open==false) 
     endloop=true; 

    } 
    MessageBox(NULL, 
      L"All Windows are closed. Program will now close.", 
      L"Message", 
      MB_ICONINFORMATION); 

} 

void createwindow2(WNDCLASSEX& wc,HWND& hwnd,HINSTANCE hInst,int nShowCmd) { 
    if (windowclass2registeredbefore==false) { 
    ZeroMemory(&wc,sizeof(WNDCLASSEX)); 
    wc.cbClsExtra=NULL; 
    wc.cbSize=sizeof(WNDCLASSEX); 
    wc.cbWndExtra=NULL; 
    wc.hbrBackground=(HBRUSH)COLOR_WINDOW; 
    wc.hCursor=LoadCursor(NULL,IDC_ARROW); 
    wc.hIcon=NULL; 
    wc.hIconSm=NULL; 
    wc.hInstance=hInst; 
    wc.lpfnWndProc=(WNDPROC)windowprocessforwindow2; 
    wc.lpszClassName=L"wc2"; 
    wc.lpszMenuName=NULL; 
    wc.style=CS_HREDRAW|CS_VREDRAW; 

    if(!RegisterClassEx(&wc)) 
    { 
     int nResult=GetLastError(); 
     MessageBox(NULL, 
      L"Window class creation failed", 
      L"Window Class Failed", 
      MB_ICONERROR); 
    } 
    else 
     windowclass2registeredbefore=true; 
    } 
    hwnd=CreateWindowEx(NULL, 
      wc.lpszClassName, 
      L"Window 2", 
      WS_OVERLAPPEDWINDOW, 
      200, 
      170, 
      640, 
      480, 
      NULL, 
      NULL, 
      hInst, 
      NULL    /* No Window Creation data */ 
); 

    if(!hwnd) 
    { 
     int nResult=GetLastError(); 

     MessageBox(NULL, 
      L"Window creation failed", 
      L"Window Creation Failed", 
      MB_ICONERROR); 
    } 

    ShowWindow(hwnd,nShowCmd); 
} 

void createwindow3(WNDCLASSEX& wc,HWND& hwnd,HINSTANCE hInst,int nShowCmd) { 
    if (windowclass3registeredbefore==false) { 
    ZeroMemory(&wc,sizeof(WNDCLASSEX)); 
    wc.cbClsExtra=NULL; 
    wc.cbSize=sizeof(WNDCLASSEX); 
    wc.cbWndExtra=NULL; 
    wc.hbrBackground=(HBRUSH)COLOR_WINDOW; 
    wc.hCursor=LoadCursor(NULL,IDC_ARROW); 
    wc.hIcon=NULL; 
    wc.hIconSm=NULL; 
    wc.hInstance=hInst; 
    wc.lpfnWndProc=(WNDPROC)windowprocessforwindow3; 
    wc.lpszClassName=L"window class 3"; 
    wc.lpszMenuName=NULL; 
    wc.style=CS_HREDRAW|CS_VREDRAW; 

    if(!RegisterClassEx(&wc)) 
    { 
     int nResult=GetLastError(); 
     MessageBox(NULL, 
      L"Window class creation failed", 
      L"Window Class Failed", 
      MB_ICONERROR); 
    } 
    else 
     windowclass3registeredbefore=true; 
    } 
    hwnd=CreateWindowEx(NULL, 
      wc.lpszClassName, 
      L"Window 3", 
      WS_OVERLAPPEDWINDOW, 
      200, 
      190, 
      640, 
      480, 
      NULL, 
      NULL, 
      hInst, 
      NULL    /* No Window Creation data */ 
); 

    if(!hwnd) 
    { 
     int nResult=GetLastError(); 

     MessageBox(NULL, 
      L"Window creation failed", 
      L"Window Creation Failed", 
      MB_ICONERROR); 
    } 

    ShowWindow(hwnd,nShowCmd); 
} 

void createwindow4(WNDCLASSEX& wc,HWND& hwnd,HINSTANCE hInst,int nShowCmd) { 
    if (windowclass4registeredbefore==false) { 
     ZeroMemory(&wc,sizeof(WNDCLASSEX)); 
    wc.cbClsExtra=NULL; 
    wc.cbSize=sizeof(WNDCLASSEX); 
    wc.cbWndExtra=NULL; 
    wc.hbrBackground=(HBRUSH)COLOR_WINDOW; 
    wc.hCursor=LoadCursor(NULL,IDC_ARROW); 
    wc.hIcon=NULL; 
    wc.hIconSm=NULL; 
    wc.hInstance=hInst; 
    wc.lpfnWndProc=(WNDPROC)windowprocessforwindow4; 
    wc.lpszClassName=L"window class 4"; 
    wc.lpszMenuName=NULL; 
    wc.style=CS_HREDRAW|CS_VREDRAW; 

    if(!RegisterClassEx(&wc)) 
    { 
     int nResult=GetLastError(); 
     MessageBox(NULL, 
      L"Window class creation failed", 
      L"Window Class Failed", 
      MB_ICONERROR); 
    } 
    else 
     windowclass4registeredbefore=true; 
    } 
    hwnd=CreateWindowEx(NULL, 
      wc.lpszClassName, 
      L"Window 4", 
      WS_OVERLAPPEDWINDOW, 
      200, 
      210, 
      640, 
      480, 
      NULL, 
      NULL, 
      hInst, 
      NULL    /* No Window Creation data */ 
); 

    if(!hwnd) 
    { 
     int nResult=GetLastError(); 

     MessageBox(NULL, 
      L"Window creation failed", 
      L"Window Creation Failed", 
      MB_ICONERROR); 
    } 

    ShowWindow(hwnd,nShowCmd); 
} 

// windows process functions 

LRESULT CALLBACK windowprocessforwindow1(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam) { 
    switch(message) { 
     case WM_CREATE: 
       window1open=true; 
       CreateWindowEx(NULL, 
       L"BUTTON", 
       L"Open Window 2", 
       WS_TABSTOP|WS_VISIBLE| 
       WS_CHILD|BS_DEFPUSHBUTTON, 
       50, 
       220, 
       150, 
       24, 
       hwnd, 
       (HMENU)createwindowbuttoninwindow1, 
       GetModuleHandle(NULL), 
       NULL); 
      break; 
      case WM_DESTROY: 
       window1open=false; 
       break; 
     case WM_COMMAND: 
      switch LOWORD(wParam) { 
       case createwindowbuttoninwindow1: 
        windowtoopenenum=window2; 
        break; 
      } 
    } 
    return DefWindowProc(hwnd, message, wParam, lParam); 

} 

LRESULT CALLBACK windowprocessforwindow2(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam) { 
    switch(message) { 
     case WM_CREATE: 
       window2open=true; 
       CreateWindowEx(NULL, 
       L"BUTTON", 
       L"Open Window 3", 
       WS_TABSTOP|WS_VISIBLE| 
       WS_CHILD|BS_DEFPUSHBUTTON, 
       50, 
       220, 
       150, 
       24, 
       hwnd, 
       (HMENU)createwindowbuttoninwindow2, 
       GetModuleHandle(NULL), 
       NULL); 
      break; 
      case WM_DESTROY: 
       window2open=false; 
       break; 
     case WM_COMMAND: 
      switch LOWORD(wParam) { 
       case createwindowbuttoninwindow2: 
        windowtoopenenum=window3; 
        break; 
      } 
    } 
    return DefWindowProc(hwnd, message, wParam, lParam); 
} 

LRESULT CALLBACK windowprocessforwindow3(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam) { 
    switch(message) { 
     case WM_CREATE: 
       window3open=true; 
       CreateWindowEx(NULL, 
       L"BUTTON", 
       L"Open Window 4", 
       WS_TABSTOP|WS_VISIBLE| 
       WS_CHILD|BS_DEFPUSHBUTTON, 
       50, 
       220, 
       150, 
       24, 
       hwnd, 
       (HMENU)createwindowbuttoninwindow3, 
       GetModuleHandle(NULL), 
       NULL); 
       break; 
       case WM_DESTROY: 
       window3open=false; 
       break; 
     case WM_COMMAND: 
      switch LOWORD(wParam) { 
       case createwindowbuttoninwindow3: 
        windowtoopenenum=window4; 
        break; 
      } 
    } 
    return DefWindowProc(hwnd, message, wParam, lParam); 
} 

LRESULT CALLBACK windowprocessforwindow4(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam) { 
    switch(message) { 
     case WM_DESTROY: 
      window4open=false; 
      break; 
    } 
    return DefWindowProc(hwnd, message, wParam, lParam); 
}

यदि आप खिड़की को बंद और फिर से खोलें तो क्या होगा?

यदि आप बंद बटन पर क्लिक करते हैं और उसी विंडो को फिर से खोलते हैं, तो निम्न पर ध्यान दें। जब बंद बटन बंद होने के बाद विंडो बंद हो जाती है, तो इसे नष्ट कर दिया जाएगा। लेकिन खिड़की को नष्ट करना खिड़कियों की कक्षा को नष्ट नहीं करता है। यह केवल createwindow फ़ंक्शन से विंडो को नष्ट कर देता है। यह उपर्युक्त प्रोग्राम में अगर कथन के लिए जरूरी बनाता है जो केवल विंडोज क्लास बनाता है अगर यह पहली बार विंडो प्रदर्शित होता है।

कुछ साइड नोट

तुम बस एक खिड़कियों वर्ग का उपयोग कर कई खिड़कियां बना सकते हैं। लेकिन इसके साथ समस्या यह है कि आपके पास एक से अधिक खिड़की से निपटने के लिए एक विंडोज़ प्रक्रिया है। यह इस सरल उदाहरण में ठीक काम करेगा। लेकिन खिड़कियों जितना अधिक विषम होगा उतना ही प्रत्येक खिड़की के लिए एक अलग खिड़कियां बनाने की आवश्यकता होगी।

इसके अलावा कई createwindow फ़ंक्शंस को एक फ़ंक्शन में जोड़ा जा सकता था। ध्यान दें कि उनके बीच एकमात्र अंतर wc.lpszClassName कोड लाइन था। लेकिन विंडोज एक-दूसरे से भिन्न होने की संभावना है, इसलिए कार्यों को एक में जोड़ना जरूरी नहीं है- कोड को दोहराने वाली चीजों को न रखने की प्राथमिकता है।

अतिरिक्त पठन

डोमेन functionx साथ वेबसाइट पर लिंक खिड़कियों डिजाइन में अवधारणाओं के बारे में अधिक विवरण नहीं हैं। लिंक here

functionx.com पर होम पेज में अच्छे प्रोग्रामिंग सीखने के संसाधन हैं। विशेष रूप से महत्वपूर्ण यह पृष्ठ है जिसमें विंडोज़ कक्षा को बदलने, सूची बॉक्स बनाने और अन्य विंडोज नियंत्रणों जैसी चीजों के लिए प्रोग्रामिंग संदर्भ सामग्री है। यह सामान्य रूप से Win32 प्रोग्रामिंग सीखने के लिए भी एक अच्छा संसाधन है। functionx.com Win32 प्रोग्रामिंग

functionx.com win32 programming

स्रोत

2015-08-28 01:28:59 rauprog

1

मैं यह पहले से ही उत्तर दिया गया है पता है, लेकिन मैं सिर्फ एक कार्यक्रम पाश के लिए एक के माध्यम से खिड़कियों की एक मनमाना संख्या खुलती लिख रहा था।

मेरा संस्करण यहां है। असल में, यह एकाधिक विंडो बनाने के लिए एक ही कक्षा जनरेटर का उपयोग करता है। आप जितना चाहें उतना बना सकते हैं। बस अपने एचडब्ल्यूएनडी [] और WNDCLASSEX wc [] सरणी को तदनुसार समायोजित करना सुनिश्चित करें।

नोट 1: कोड का यह टुकड़ा वैश्विक अनुप्रयोग इंस्टेंस का उपयोग करता है, जो WinMain फ़ंक्शन से लिया गया है। अपने WinMain में, एप्लिकेशन इंस्टेंस के लिए प्राप्त किया गया प्रवेश असाइन करें, जो इस उदाहरण में वैश्विक स्तर पर उपलब्ध माना जाता है। यह आपका प्राथमिक एप्लिकेशन विंडो उदाहरण है।

नोट 2: बेशक, आपको पहले से ही लिखित WinProc routine होना चाहिए, और किसी अन्य शीर्षलेख फ़ाइल में कहीं भी शामिल होना चाहिए, या बस ऊपर (इस उदाहरण में नहीं दिखाया गया है।) इस कोड में, इसे WinProc के रूप में संदर्भित किया गया है , जब इसे पॉप्युलेट क्लास (WNDPROC प्रक्रिया)

नोट 3: स्पॉनविंडो "केंद्रित" और "अधिकतम" झंडे का समर्थन करता है। वे क्या करते हैं आत्म-व्याख्यात्मक है।

इसके अलावा, विंडो क्लास नाम स्वत: जेनरेट किया गया है, इसलिए आपको इसे नाम देने के बारे में चिंता करने की ज़रूरत नहीं है, बस इसे एक अच्छा आधार नाम असाइन करें।

int WindowCounter = 0; 
WNDCLASSEX wc[1000]; 
HWND hwnd[1000]; 
char class_name[256]; // for auto class name generation 

void PopulateClass(WNDPROC process) { 
    ZeroMemory(&wc[WindowCounter], sizeof(WNDCLASSEX)); 
    wc[WindowCounter].cbSize = sizeof(WNDCLASSEX); 
    wc[WindowCounter].style = CS_HREDRAW|CS_VREDRAW|CS_OWNDC; 
    wc[WindowCounter].lpfnWndProc = process; 
    wc[WindowCounter].cbClsExtra = 0; 
    wc[WindowCounter].cbWndExtra = 0; 
    wc[WindowCounter].hInstance = ApplicationInstance; 
    wc[WindowCounter].hIcon = LoadIcon(nullptr, IDI_APPLICATION); 
    wc[WindowCounter].hCursor = LoadCursor(nullptr, IDC_ARROW); 
    wc[WindowCounter].hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH); 
    wc[WindowCounter].lpszMenuName = nullptr; 
    sprintf(class_name, "WindowClass%d", WindowCounter); 
    wc[WindowCounter].lpszClassName = class_name; 
    wc[WindowCounter].hIconSm = nullptr; 
}

अब, चलो इसे स्पॉनविंडो फ़ंक्शन प्रदान करके सभी को एक साथ रख दें!

HWND SpawnWindow(int x, 
       int y, 
       int width, 
       int height, 
       bool centered = false, 
       bool maximized = false) { 
    PopulateClass(WinProc); 
    RegisterClassEx(&wc[ WindowCounter ]); 
    int config_style = WS_OVERLAPPEDWINDOW; 
    if (maximized) { width = GetSystemMetrics(SM_CXFULLSCREEN); height =  GetSystemMetrics(SM_CYFULLSCREEN); config_style = WS_OVERLAPPEDWINDOW |  WS_MAXIMIZE; } 
    if (centered) { x = (GetSystemMetrics(SM_CXFULLSCREEN)/2) - (width/ 2); y = (GetSystemMetrics(SM_CYFULLSCREEN)/2) - (height/2); } 
    hwnd[WindowCounter] = CreateWindowEx(NULL, 
     wc[WindowCounter].lpszClassName, 
     config.namever(), 
     WS_OVERLAPPEDWINDOW, 
     x, 
     y, 
     width, 
     height, 
     nullptr, 
     nullptr, 
     ApplicationInstance, 
     nullptr); 
    HWND returnID = hwnd[WindowCounter]; 
    ShowWindow(hwnd[WindowCounter++], SW_SHOW); 
    return returnID; 
}

अंत में, के रूप में कई विंडो बनाने के रूप में आप सिर्फ एक कोड की पंक्ति से प्रत्येक के साथ हैं: मुख्य लूप प्रवेश करने से पहले, अपने WinMain से()

void CreateWindows() { 
    HWND PrimaryWindow1 = SpawnWindow(500, 500, 250, 250); 
    HWND PrimaryWindow2 = SpawnWindow(500, 500, 250, 250, true); 
    HWND PrimaryWindow3 = SpawnWindow(500, 500, 250, 250, true, true); 
    HWND PrimaryWindow4 = SpawnWindow(100, 100, 150, 150); 
    HWND PrimaryWindow5 = SpawnWindow(450, 500, 350, 150); 
}

कॉल CreateWindows।

आशा है कि इससे किसी को वहां मदद मिलेगी।

स्रोत

2017-11-01 05:01:23 InfiniteStack

संबंधित मुद्दे
नवीनतम प्रश्न

 संबंधित मुद्दे