Scrap/InsideTheVcl/Part3

UserPreferences

1. Window Creation Fundamentals
2. 개요
3. 윈도우 생성
1. CreateWindow 함수
2. 컨트롤 클래스의 등록
3. 슈퍼클래싱
4. TWinControl 클래스를 사용해서 윈도우 만들기
5. The CreateParams Function CreateParams 함수
1. CreateWnd 함수
2. CreateWindowHandle 함수
3. TWinControl 클래스로 슈퍼클래싱하기
6. 윈도우 생성의 커스터마이즈
1. Style 과 ExStyle 다루기
2. WindowClass 멤버 다루기
3. WndParent 멤버 다루기

1 Window Creation Fundamentals

• from http://bcbcaq.bytamin-c.com/WindowCreationFundamentals.html by Damon Chandler
  
• 번역 : 김성철( paranwave at korea.com )
  
  
  

2 개요

윈도우즈 API 레퍼런스에서 "윈도우(window)" 란 단어를 봤을 때, VCL 의 폼이 생각날 것이다. 실제로 폼은 어플리케이션에서 사용되는 윈도우의 한 종류이다. 곧 알게 되겠지만, TWinControl 에서 파생된 컨트롤들은 윈도우 형식의 컨트롤이다. 예를 들어서, Handle 속성은 TWinControl 클래스에서 가장 중요한 속성인데 이 것은 아무렇게 설계해서 그런 것이 아니라 오히려 윈도우 형식의 컨트롤임을 확실하게 나타내는 것이다. 이 핸들 속성은 윈도우의 실제 메모리 블럭을 나타내는 추상화 레이어로 사용되고 API 함수들은 이 핸들을 이용해서 윈도우의 실제 메모리 블럭을 다룰 수 있는 것이다. "From Message to Events" 의 문서에서 SendMessage API 함수를 사용했들 때도, 이 함수의 첫번째 인자에 메세지를 받을 윈도우의 핸들을 전달했었다. 사실, 윈도우 형식의 컨트롤을 다루는 거의 모든 API 함수들은 윈도우 핸들을 필요로한다. 하지만 VCL 을 사용하면 거의 대부분 이 윈도우 핸들(Handle) 속성을 사용할 필요가 없다. 그러나 VCL 이 모든 윈도우 조작 API 함수를 지원하는 것이 아니기 때문에 가끔 쓸일도 있다.

TWinControl 클래스는 윈도우즈 API 와 윈도우 형식의 모든 VCL 컨트롤을 연결시켜 주는 접착제가 된다. 그렇기 때문에, TWinControl 을 이해하기 위해서는, 먼저 API 관점에서 윈도우 생성 과정을 이해해야한다. "From Message to Event" 시리즈의 문서에서 메세지와 이벤트에 대해서 몇몇 윈도우즈 API 와 VCL 을 연결해 보았지만 이 문서에서는 TWinControl 클래스와 윈도우 생성 과정의 API 들을 연결시켜 볼 것이다.

3 윈도우 생성

대부분의 어플리케이션들은 사용자와 정보를 서로 주고받기 위해서 윈도우즈 형식으로 만들어진다. 확실히, 윈도우라는 비주얼 오브젝트를 이용해서 사용자와 어플리케이션 간에 정보를 주고 받으면 정말 편리하다. 어떤 경우에는, 윈도우가 사용자의 입력을 받아 들이고, 어떤 때에는 정보를 알려주는데 사용된다. 이런 얘기는 그래픽컬 유저 인터페이스(GUI) 개잘자들에게는 모두다 알고 있는 따분한 옛 이야기일 뿐이지만 콘솔 또는 텍스트 기반의 어플리케이션만을 주로 만드는 개발자들에게는 감칠 맛 나는 얘기거리가 된다. 또한, VCL 은 윈도우 생성 과정의 대부분을 속에 감추고 있기 때문에, 숙련된 C++ 빌더 개발자들도 윈도우를 커스터마이즈 할 때 또는 문제를 해결 할 때 많은 어려움을 겪는다. 이런 이유로, 이 문서에서는 윈도우즈 API 로 윈도우를 생성하는 과정을 설명하고 나서, VCL 이 어떻게 윈도우 생성 과정을 포장해 놓았는지 하나하나씩 벗겨볼 것이다.



3.1 CreateWindow 함수

모든 윈도우 형식의 컨트롤들은 CreateWindow API 함수를 사용해서 만들 수 있다. API 의 구현은 모든 컨트롤들이 윈도우 형식의 컨트롤인데 비쥬얼한게 하나도 없다. 그래서 모든 컨트롤들을 코드를 작성해서 만들어야 한다. 버튼, 에디트 컨트롤 같은 간단한 컨트롤들을 만들기 위해서는 CreateWindow() 함수를 한번만 호출해 주면 되는데 이 컨트롤들은 윈도우즈에 미리 등록되어 있는 컨트롤이기 때문이다. 우선, CreateWindow 함수를 살펴보자.:



HWND CreateWindow( 
    LPCTSTR lpClassName, 
    LPCTSTR lpWindowName, 
    DWORD dwStyle, 
    int x, 
    int y, 
    int nWidth, 
    int nHeight, 
    HWND hWndParent, 
    HMENU hMenu, 
    HANDLE hInstance, 
    LPVOID lpParam 
); 


이 함수는 7개의 인자를 필요로하고, 새롭게 생성된 윈도우의 핸들을 반환한다. 첫 인자인 lpClassName 은 만들어질 윈도우 클래스의 이름(문자열)을 가리키는 포인터이다. 여기서 이 윈도우 클래스의 이름은 CreateWindow 함수가 호출되기 전에 윈도우즈 운영체제에 등록되어 있어야한다. 윈도우즈 운영체제는 CreateWindow() 함수에 전달되는 모든 윈도우 클래스의 이름을 알지 못하며 해당 클래스의 윈도우를 어떻게 만들어야하는지도 모른다. 사실, 윈도우즈 API 는 특정 종류의 컨트롤들을 운영체제에 미리 등록해 놓았기 때문에 CreateWindow() 함수만 호출해서 윈도우 컨트롤을 만들 수 있는 것이다. 이 특정 윈도우 컨트롤들을 표준컨트롤, 공통컨트롤이라고 한다.



3.2 컨트롤 클래스의 등록

윈도우즈 API 는 운영체제에 미리 등록된 컨트롤 클래스를 제공하기 때문에 컨트롤 클래스를 다시 등록하지 않고 특정 컨트롤을 사용할 수 있다. 이 컨트롤들은 API 의 사용자 인터페이스 서비스의 일부분으로 윈도우즈 운영체제에 포함되어 있다. 버튼, 에디트 컨트롤(edit control), 스태틱 컨트롤(static control), 콤보박스(combo box), 목록 박스(list box) 와 같은 표준 컨트롤은 운영체제가 시작될 때 미리 등록된다. 예를 들어서, 버튼을 생성하려면 CreateWindow() 함수의 lpClassName 인자에 "BUTTON" 값을 넘겨주기만하면 된다. 표준컨트롤과 비슷한 공통컨트롤이 있는데 목록뷰(list view), 트리뷰(tree view), 헤더 컨트롤(header control), 탭 컨트롤(tab control), 툴바(toolbar) 컨트롤을 가지고 있다. 이 공통 컨트롤은 InitCommonControlEx() API 함수를 호출하면 운영체제에 등록된다. 그렇다면 사용자 컨트롤을 만들고 싶을 때는 어떻게 해야할까? 우선, 사용자 컨트롤의 클래스를 RegisterClass() API 함수를 사용해서 운영체제에 등록해야한다.



ATOM RegisterClass(const WNDCLASS *lpWndClass); 


RegisterClass() 함수는 한개의 인자만 받는데, 윈도우 클래스의 속성을 정의하는 WNDCLASS 구조체의 포인터이다. WNDCLASS 구조체는 아래처럼 정의되어 있다.



typedef struct _WNDCLASS { 
    UINT style;  
    WNDPROC lpfnWndProc;  
    int cbClsExtra;  
    int cbWndExtra;  
    HANDLE hInstance;  
    HICON hIcon;  
    HCURSOR hCursor;  
    HBRUSH hbrBackground;  
    LPCTSTR lpszMenuName;  
    LPCTSTR lpszClassName;  
} WNDCLASS; 


WNDCLASS 구조체의 멤버 데이타 중 몇개는 익숙할텐데, 예를 들어 lpfnWndProc 은 윈도우 프로시져의 포인터이고, hIcon과 hCursor 은 윈도우가 사용할 기본 아이콘과 마우스 커서의 핸들이다. hbrBackground 는 윈도우의 배경을 칠할때 사용하는 브러쉬의 핸들이고, 가장 중요한 마지막 데이타 멤버인 lpszClassName 은 윈도우의 클래스 이름을 정의한다.( 예: "TForm1" )

WNDCLASS 구조체가 알맞게 초기화 되면, 구조체의 주소를 RegisterClass() 함수의 인자로 전달한다. 이제, "TMyForm" 인 새로운 윈도우를 생성하는 예제를 살펴보자. 목록 2.0은 이 예제의 코드다.



목록 2.0 
 
//---------------------------------------------------------------------- 
#include <windows.h> 
//---------------------------------------------------------------------- 
 
// our new window class name 
const char NewClassName[] = "TMyForm"; 
//---------------------------------------------------------------------- 
 
// main window procedure 
LRESULT CALLBACK WndProc(HWND HWnd, unsigned int Msg, WPARAM WParam, LPARAM LParam) 
{ 
    // this window will actually do no special processing 
    // except terminate the application when destroyed 
    switch (Msg) 
    { 
    case WM_DESTROY: 
        { 
            // will place WM_QUIT in our message queue 
            // (strictly speaking, the QS_QUIT flag) 
            PostQuitMessage(0); 
            return 0; 
        } 
    } 
    return DefWindowProc(HWnd, Msg, WParam, LParam); 
} 
//---------------------------------------------------------------------- 
 
int APIENTRY WinMain(HINSTANCE HInstance, HINSTANCE HPrevInstance, LPTSTR lpCmdLine, int nCmdShow) 
{ 
    WNDCLASS wc; 
    memset(&wc, 0, sizeof(WNDCLASS)); 
 
    // initialize the WNDCLASS structure 
    wc.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS; 
    wc.lpfnWndProc = WndProc; 
    wc.hInstance = HInstance; 
    wc.hCursor = LoadCursor(NULL, IDC_ARROW); 
    wc.hbrBackground = GetStockObject(LTGRAY_BRUSH); 
    wc.lpszClassName = NewClassName; 
     
    // register our new class of window 
    if (RegisterClass(&wc)) 
    { 
        // once registered, we are free to create the window 
        HWND HWnd = CreateWindow(NewClassName, "MyForm1",  
                                            WS_OVERLAPPEDWINDOW | WS_CAPTION | WS_VISIBLE, 
                                            CW_USEDEFAULT, CW_USEDEFAULT, 
                                            CW_USEDEFAULT, CW_USEDEFAULT, 
                                            NULL, NULL, HInstance, NULL); 
 
        if (HWnd) 
        { 
            // show the new window 
            ShowWindow(HWnd, nCmdShow); 
            UpdateWindow(HWnd); 
 
            // main message pump 
            MSG msg; 
 
            while (GetMessage(&msg, NULL, 0, 0)) 
            { 
                TranslateMessage(&msg); 
                DispatchMessage(&msg); 
            } 
        } 
    } 
    return 0; 
} 
//---------------------------------------------------------------------- 


목록 2.0 에 있는 WinMain 함수는 VCL 이 만들어 준 WinMain 함수( "From Message to Events" 문서에서 목록 1.4 의 소스코드 )와 아주 똑같지만 TMyForm 은 새로운 윈도우 클래스이고 미리 등록된 클래스가 아니기 때문에 기본 윈도우 프로시져를 만들어줘야 한다. 이 윈도우 프로시져에 TMyForm 윈도우의 행동과 속성을 정의하는데, 목록 2.0 에 정의된 윈도우 프로시져(WndProc) 는 DefWindowProc() API 함수만 호출한다. 이 말은 새로운 종류인 TMyFrom 윈도우가 표준 윈도우와 똑같이 행동한다는 것이다.

목록 2.0 에 정의된 WinMain 함수를 보면, 구현이 세단계로 되어 있다. 첫 단계는, WNDCLASS 구조체를 선언하고 초기화한다. 두번째 단계는, RegisterWindow() API 함수에 구조체의 주소를 전달해 호출한다. 마지막 세번째 단계는 클래스의 등록이 성공한 후에, CreateWindow() 함수에 새롭게 등록된 클래스의 이름을 lpClassName 인자에 전달해서 호출한다. 모든 윈도우 컨트롤을 만들기 위해서 이 세단계를 반드시 거쳐야한다.

확실하게, 캡슐화 된 것이 하나 없는 이 과정은 아주 귀찮고 버그가 발생하면 발견하기도 어렵다. 그러나 행복하게도, TWinControl 클래스가 이 과정의 전부를 캡슐화 했고 이에 대해서는 다음 섹션에서 알아볼 것이다. 우선은 CreateWindow() 함수에 대해서 더 알아보자.



HWND CreateWindow( 
    LPCTSTR lpClassName, 
    LPCTSTR lpWindowName, 
    DWORD dwStyle, 
    int x, 
    int y, 
    int nWidth, 
    int nHeight, 
    HWND hWndParent, 
    HMENU hMenu, 
    HANDLE hInstance, 
    LPVOID lpParam 
); 


두번째 인자인, lpWindowName 은 윈도우의 캡션을 나나태는 문자열값이다. C++ 빌더에서, 어플리케이션의 첫번재 폼은 lpWindowName 에 "Form1" 이란 문자열이 설정된다. dwStyle 인자는 여러가지 윈도우의 속성을 설정하기 위해서 사용한다. 예를 들어서, WS_OVERLAPPED 스타일은 표준 탑레벨(top-level) 윈도우를 만들 때 사용하느데 TForm 클래스가 기본 스타일로 사용된다. WS_POPUP 스타일은 캡션과 경계(border) 가 없는 윈도우를 만들어 준다. 이미 알고 있을지 모르지만, TForm::BorderStyle 속성은 윈도우의 여러가지 경계(border) 스타일을 만들 때 사용할 수 있다. 이 때 이 속성에 설정되는 값이 dwStyle 인자에 전달되는 것이다. 비슷하게, x, y, nWidth, nHeight 인자는 폼의 Top, Left, Width, Height 속성이 설정될 때 속성 값이 전달되는 것이다. 윈도우가 자식윈도우로 만들어 진다면, hWndParent 인자가 윈도우의 부모를 가리키기 위해 사용된다. 탑레벨(top-level) 윈도우에서 이 값은 데스크탑(바탕화면)의 핸들로 설정된다. 이 때, 데스크탑(바탕화면) 윈도우의 핸들은 hWndParent 에 NULL 값을 설정하거나 GetDesktopWindow() API 함수를 호출해서 얻을 수 있다. TFrom 클래스는 이 hWndParent 의 값으로 TApplication 윈도우의 핸들을 설정한다. hMenu 인자는 윈도우의 메인 메뉴의 핸들로 사용된다. hInstance 인자는 어플리케이션의 인스턴스 핸들로 전역 변수인 HInstance 를 통해서 설정할 수 있다. 마지막 인자인 lpParam 은 "사용자 정의"의 추가 정보를 저장할 때 사용한다.

지금까지 미리 등록된 클래스가 바탕이 아닌 새로운 윈도우 클래를 만들어 보았다. 지금부터는 운영체제에 미리 등록된 클래스를 바탕으로 새로운 윈도우 클래스를 만들어 주는 슈퍼클래싱에 대해서 알아보자. VCL 의 TButton 클래스는 사실 표준 컨트롤인 BUTTON 을 바탕으로 새로운 클래스로 만들어진 것이다. 이 경우에, TButton 과 TWinControl 클래스는 슈퍼클래싱을 수행한다. 마이크로소프트의 Spy++ 툴을 사용해서, TButton 의 인스턴스를 조사해 보면 클래스 이름이 "BUTTON" 이 아니라 "TButton" 으로 되어 있는 것을 확인할 수 있다.



3.3 슈퍼클래싱

위에서 말했듯이, 슈퍼클래싱 기술은 미리 등록된 클래스를 바탕으로 새로운 윈도우 클래스를 만드는 것이다. 그냥 새롭게 윈도우 클래스를 만들 때와 비슷하게 슈퍼클래싱을 하기 위해서도 WNDCLASS 구조체를 선언하고 새로 만들 클래스의 특징으로 WNDCLASS 를 초기화해야한다. 차이점은 부모클래스로부터 WNDCLASS 의 정보를 얻기 위해서 GetClassInfo() API 함수를 먼저 호출한다는 것이다.



bool GetClassInfo( 
    HINSTANCE hInstance, 
    LPCTSTR lpClassName, 
    LPWNDCLASS lpWndClass 
); 


GetClassInfo() 함수에 WNDCLASS 변수를 전달해 호출하면, 부모클래스의 기본 윈도우 프로시져의 주소가 lpfnWndProc 데이타 멤버에 저장된다. 이 값은 슈퍼클래스(새롭게 만들어지는)의 윈도우 프로시져로 사용된다. 이 단계는 "From Messages to Events" 에서 원래의 윈도우 프로시져를 다른 윈도우 프로시져와 바꿨던 인스턴스 서브클래싱의 예제(목록 1.18)와 비슷하다. 서브클래싱에서는 교체된 윈도우 프로시져를 "서브클래스 프로시져"라고 했는데, 슈퍼클래싱에서는 새로운 윈도우 프로시져를 "슈퍼클래스 프로시져" 라고 한다. 기반 클래스의 윈도우 프로시져를 저장하고 나서, 슈퍼클래스 프로시져가 WNDCLASS 의 lpfnWndProc 멤버에 설정된다. 마지막으로 어플리케이션의 인스턴스 핸들(hInstance)을 hInstance 인자에 설정하고 lpClassName 인자에 새로운 클래스의 이름을 설정한다.

표준컨트롤인 BUTTON 을 슈퍼클래싱하는 예제를 살펴보며 알아보자. 전과정이 목록 2.1 에 있고, 이때 슈퍼클래스의 이름을 "TMyButton" 으로 했다.



목록 2.1 
 
//----------------------------------------------------------------------- 
#include <windows.h> 
//----------------------------------------------------------------------- 
 
// our new window class name 
const char NewFormClassName[] = "TMyForm"; 
 
// our new button class name 
const char NewButtonClassName[] = "TMyButton"; 
 
// will hold the address of the base (BUTTON) 
// class's default window procedure 
FARPROC ButtonDefWndProc = NULL; 
 
//---------------------------------------------------------------------- 
// main window procedure 
LRESULT CALLBACK FormWndProc(HWND HWnd, unsigned int Msg, WPARAM WParam, LPARAM LParam) 
{ 
    // this window will actually do no special processing 
    // except terminate the application when destroyed 
    switch (Msg) 
    { 
        case WM_DESTROY: 
        { 
            // will place WM_QUIT in our message queue 
            // (strictly speaking, the QS_QUIT flag) 
            PostQuitMessage(0); 
            return 0; 
        } 
    } 
    return DefWindowProc(HWnd, Msg, WParam, LParam); 
} 
 
//---------------------------------------------------------------------- 
// button window procedure 
LRESULT CALLBACK ButtonWndProc(HWND HWnd, unsigned int Msg, WPARAM WParam, LPARAM LParam) 
{ 
    // 
    // this window will actually do no special processing 
    // 
    // call the original BUTTON window procedure 
    return CallWindowProc(ButtonDefWndProc, HWnd, Msg, WParam, LParam); 
} 
 
//---------------------------------------------------------------------- 
int APIENTRY WinMain(HINSTANCE HInstance, HINSTANCE HPrevInstance, LPTSTR lpCmdLine, int nCmdShow) 
{ 
    WNDCLASS form_wc, button_wc; 
    memset(&form_wc, 0, sizeof(WNDCLASS)); 
    memset(&button_wc, 0, sizeof(WNDCLASS)); 
 
     // initialize the Form's WNDCLASS structure 
    form_wc.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS; 
    form_wc.lpfnWndProc = FormWndProc; 
    form_wc.hInstance = HInstance; 
    form_wc.hCursor = LoadCursor(NULL, IDC_ARROW); 
    form_wc.hbrBackground = GetStockObject(LTGRAY_BRUSH); 
    form_wc.lpszClassName = NewFormClassName; 
 
    // initialize a WNDCLASS structure for the "BUTTON" 
    // base class via the GetClassInfo API function 
    if (!GetClassInfo(NULL, "BUTTON", &button_wc)) return false; 
 
    // store the address of the original window procedure 
    ButtonDefWndProc = reinterpret_cast<FARPROC>(button_wc.lpfnWndProc); 
    // specify the address of the subclass procedure 
    button_wc.lpfnWndProc = ButtonWndProc; 
 
    // initialize the rest of our button's WNDCLASS 
    // structure for superclassing 
    button_wc.hInstance = HInstance; 
    button_wc.lpszClassName = NewButtonClassName; 
 
    // register our new class of window and button 
    if (RegisterClass(&form_wc) && RegisterClass(&button_wc)) 
    { 
        // once registered, we are free to create the window 
        HWND HWnd = CreateWindow(NewFormClassName, "MyForm1",  
                                        WS_OVERLAPPEDWINDOW | WS_CAPTION | WS_VISIBLE, 
                                        CW_USEDEFAULT, CW_USEDEFAULT, 
                                        CW_USEDEFAULT, CW_USEDEFAULT, 
                                        NULL, NULL, HInstance, NULL); 
 
        if (HWnd) 
        { 
            // create the new button 
            CreateWindow(NewButtonClassName, "MyButton1", 
                                        WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 
                                        10, 10, 200, 75, 
                                        HWnd, NULL, HInstance, NULL); 
 
            // show the new window 
            ShowWindow(HWnd, nCmdShow); 
            UpdateWindow(HWnd); 
 
            // main message pump 
            MSG msg; 
            while (GetMessage(&msg, NULL, 0, 0)) 
            { 
                TranslateMessage(&msg); 
                DispatchMessage(&msg); 
            } 
        } 
    } 
    return 0; 
} 
//---------------------------------------------------------------------- 


목록 2.0 에서 본 구현과 비슷하게, 목록 2.1 에 있는 WinMain 함수의 구현은 우선 TMyForm 클래스를 위한 WNDCLASS 변수를 선언하고 초기화했다. 그러나 목록 2.1 에서는 새로운 버튼 클래스를 만들기 위해서 button_wc 란 WNDCLASS 변수를 하나더 선언했다. button_wc 의 데이타 멤버를 일일이 설정하는 대신에, GetClassInfo() API 함수를 호출했다. 이때, hInstance 인자에는 NULL 을 전달하고, 부모클래스의 클래스 이름을 나타내는 lpClassName 인자에는 "BUTTON" 을 전달했다. 마지막의 lpWndClass 인자에는 button_wc 의 주소값을 전달했다. hInstance 인자에 NULL 을 전달한 것은 BUTTON 클래스가 윈도우즈 운영체제에 이미 등록되어 있기 때문이다. GetClassInfo() 함수가 수행되고 나면, button_wc 는 BUTTON 클래스를 등록할 때 사용한 정보로 초기화된다. 위의 코드에서는 부모 클래스의 기본 윈도우 프로시져를 ButtonDefWndProc 변수에 저장했다. 그 다음 button_wc 의 hInstance 데이타 멤버를 우리가 만들고 있는 어플리케이션의 인스턴스 핸들로 바꿨다. 그리고 lpfnWndProc 값은 슈퍼클래스 프로시져 주소값으로 설정되었고 lpClassName 데이타 멤버는 새로운 클래스 이름인 "TMyButton" 으로 설정되었다. 두개의 새로운 클래스를 등록한 다음에, 새로운 TMyForm 윈도우를 만들고 CreateWindow() 함수를 사용해서 새로운 TMyButton 윈도우 컨트롤을 만들었다. TMyButton 컨트롤을 만들 때 CreateWindow() 함수에 WS_CHILD 와 BS_PUSHDOWN 스타일을 설정했다. 이 것은 BUTTON 클래스의 스타일인데, TMyButton 클래스의 부모 클래스가 BUTTON 클래스이기 때문에 BUTTON 클래스의 스타일을 그대로 쓸 수 있는 것이다. 설정한 스타일의 뜻은 TMyButton 컨트롤이 다른 윈도우(이 예제에서는 TMyForm)의 자식이라는 것이다. 자식 윈도우를 대개 "윈도우 컨트롤" 또는 간단하게 "컨트롤" 이라고 한다. 이 예제에서 TMyForm 이 TMyButton 클래싕 부모이기 때문에, TMyButton 를 만들 때 CreateWindow() API 함수의 hWndParent 의 인자에 TMyForm 윈도우의 핸들인 HWnd 값을 설정했다.

VCL 은 슈퍼클래싱을 완벽하게 지원한다. 즉, TWinControl 에서 파생된 컨트롤 중 존재하는 컨트롤 클래스를 확장한 컨트롤들은 모두 슈퍼클래싱을 사용하고 있는 것이다. 예를 들어서, TListBox 클래스는 표준 컨트롤 클래스인 LISTBOX 를 슈퍼클래싱 하고 있는 것이고 TListView 클래스는 공통 컨트롤인 WC_LISTVIEW 를 슈퍼클래싱 하는 것이다.

지금쯤 CreateWindow() API 함수에 매우 익숙해져 있을 것이다. 하지만 이 함수를 잊고 살아도 된다. 마찬가리로 RegisterWindow() 함수를 WNDCLASS 구조체를 초기화하는데 호출할 경우가 거의 없다. 이 함수들 없이도 슈퍼클래싱을 멋지게 할 수 있다. 왜냐하면, TWinControl 클래스가 이러한 작업(윈도우 생성, 슈퍼클래싱)의 모든 과정을 포함하고 있기 때문이다. TWinControl 클래스가 바로 VCL 프레임웤이 제공하는 추상화의 수준이다. 이러한 RAD(Rapid Application Development) 를 만들기 위한 캡슐화 때문에 C++ 빌더가 계속해서 강세를 보이고 있는 것이다. VCL 은 강력한 프레임웤과 사용하기 쉬운 점 외에도, 아주 뛰어난 설계, 윈도우즈 API 와의 유연성 등을 골고루 갖추고 있다. 게다가 곧 알게 되겠지만, VCL 은 절대로 로우레벨의 API 를 다루는 것을 제한하지 않는다.

4 TWinControl 클래스를 사용해서 윈도우 만들기

지금까지, CreateWindow() 와 RegisterClass() API 함수에 대해서 알아보았다. 알아본 것 중에 가장 중요한 것은, 윈도우 컨트롤을 만들기 위해서는 WNDCLASS 구조체를 만들고 초기화한 다음에 윈도우즈 운영체제에 등록해야 한다는 점이었다. 또한, 기존의 컨트롤 클래스를 슈퍼클래싱하는 단계를 살펴보았다. 그럼 이제 TWinControl 클래스가 이러한 작업을 가상 멤버 함수에 심어 놨는지 살펴보자. 이 번 단원에서는 TWinControl 클래스의 멤버 함수 중에서 윈도우 생성과 슈퍼클래싱에 필요한 멤버 함수들에 대해서 알아볼 것이다. 앞에서 API 를 이용해 구현해 봤기 때문에, TWinControl 로 이뤄지는 구현은 별로 어렵지 않다.



5 The CreateParams Function CreateParams 함수

자꾸 말해서 미안하지만, 사용자 정의의 윈도우 컨트롤을 만들기 위해서 첫번째로 해야할 것은 윈도우 클래스를 등록하는 것이었다. 특히, WNDCLASS 구조체를 알맞게 설정해야 하는데 이 일을 TWinControl::CreateParams() 멤버 함수를 사용해서 할 수 있다. 이 함수는 1 개의 인자만 받는데 TCreateParams 구조체 값이다.



struct TCreateParams 
{ 
    char *Caption; 
    long Style; 
    long ExStyle; 
    int X; 
    int Y; 
    int Width; 
    int Height; 
    HWND WndParent; 
    void *Param; 
    WNDCLASSA WindowClass; 
    char WinClassName[64]; 
}; 


이 구조체를 살펴보면, 윈도우를 생성할 때 필요한 모든 정보가 있다는 것을 알 수가 있다. 즉, TCreateParams 구조체는 이름대로 윈도우 "생성 인자(Creation Parameters)" 모두를 가지고 있는 것이다. 특히, 이 구조체는 다음 세단계에서 필요한 모든 정보를 가지고 있다. (1) WNDCLASS 설정 (2) RegisterWnd() (3) CreateWindow. 또한 TCreatePArams 구조체의 멤버들은 CreateWindow API 함수의 인자들과 서로 대응한다. TWinControl::CreateParams() 멤버 함수는 이 TCreateParams 구초체를 알맞게 설정한다. 목록 2.2 를 보면 C++ 로 표현된 TWinControl::CreateParams() 멤버 함수가 있다.



목록 2.2 
 
void __fastcall TWinControl::CreateParams(TCreateParams &Params) 
{ 
    memset(&Params, 0, sizeof(TCreateParams)); 
 
    //  
    // <snip> initialize:  
    // Params.Caption (with FText); 
    // Params.Style with WS_* flags (e.g., WS_CHILD) 
    // Params.X with FLeft; 
    // Params.Y with FTop; 
    // Params.Width with FWidth; 
    // Params.Height with FHeight; 
    // Params.WndParent = Parent->Handle; 
    // 
 
    Params.WindowClass.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS; 
    Params.WindowClass.lpfnWndProc = DefWindowProc; 
    Params.WindowClass.hInstance = HInstance; 
    Params.WindowClass.hCursor = LoadCursor(NULL, IDC_ARROW); 
    Params.WindowClass.hbrBackground = NULL; 
    strcpy(Params.WinClassName, AnsiString(ClassName()).c_str()); 
} 


목록 2.2 에 정의된 TWinControl::CreateParams() 함수를 보면 TCreateParms 구조체의 대부분의 멤버를 초기화한다. 자세한 구현 사항은 TWinControl 에서 파생된 클래스들을 볼 때 살펴보기로 하고, 우선 두가지 중요한 점을 알아보자. 첫째, TCreateParams::WindowClass(WNDCLASS 형)구조체의 멤버인 lpfnWndProc 의 값이 DefWindowProc() API 함수의 주소로 설정되었는데 이 구현은 아무런 문제가 없다. 왜냐하면 DefWindowProc() 함수는 모든 윈도우의 윈도우 프로시져로 사용할 수 있기 때문이다. TWinControl 클래스는 이 주소값을 임시 값으로 사용하며, 현재 윈도우 클래스가 이미 등록되어 있는지 아닌지를 구분하기 위해서 사용한다. 둘째, WindowClass 의 lpszClassName 멤버가 전혀 초기화되지 않았다. 오히려 클래스의 이름이 TCreateParams::WinClassName 멤버에 저장되었다. 이 이유는 다음에 설명하고 우선, 이렇게 하는 것이 더 효율적이다라고 알아두자.



5.1 CreateWnd 함수

TCreateParams 구조체의 WindowClass 멤버를 설정한 후에 RegisterClass() API 함수로 등록해야 한다. 이 일을 CreateWnd() 멤버 함수가 수행한다. 이 함수내에서 윈도우 생성 메카니즘이 모두 수행된다. 즉. 윈도우 생성에 필요한 모든 TWinControl 클래스의 멤버 함수가 CreateWnd() 함수 내에서 호출된다. 목록 2.3 에 C++ 로 나타낸 TWinControl::CreateWnd() 멤버 함수가 있다.



목록 2.3 
 
void __fastcall TWinControl::CreateWnd() 
{ 
    TCreateParams Params; 
    CreateParams(Params); 
 
    if (Params.WndParent == NULL && (Params.Style & WS_CHILD)) 
    { 
        throw EInvalidOperation(SParentRequired, ARRAYOFCONST((Name))); 
    } 
 
    FDefWndProc = Params.WindowClass.lpfnWndProc; 
 
    WNDCLASS dummyClass;  
    bool IsClassRegistered = GetClassInfo( 
                                                Params.WindowClass.hInstance, 
                                                Params.WinClassName, 
                                                &dummyClass 
                                            ); 
 
    if (!IsClassRegistered || TempClass.lpfnWndProc != reinterpret_cast<WNDPROC>(InitWndProc)) 
    { 
        if (IsClassRegistered) 
        { 
            UnregisterClass(Params.WinClassName, Params.WindowClass.hInstance); 
        } 
 
        Params.WindowClass.lpfnWndProc = reinterpret_cast<WNDPROC>(InitWndProc); 
        Params.WindowClass.lpszClassName = Params.WinClassName; 
    } 
 
    CreateWindowHandle(Params); 
 
    // <snip> font and bounds stuff... 
}  


CreateWnd() 멤버 함수는 알맞게 설정된 TCreateParmas 구조체 값이 필요하기 때문에, 제일 먼저 TWinControl::CreateParams() 멤버 함수를 호출한다. 그 다음에 컨트롤이 다른 윈도우의 자식일 때 WndParent 멤버의 유효성을 살펴서 문제가 있다면 "Control <ControlName> has no Parent" 라는 예외를 일으킨다. 기본 윈도우 프로시져의 주소가 FDefWndProc 멤버( TWinControl 의 DefWndProc 속성을 통해서 접근 가능하다)에 저장되고 GetClassInfo() API 함수가 호출된다. 이 때 임시 WNDCLASS 변수를 사용하는데 이는 현재 클래스가 이미 등록된 클래스인지를 구분하기 위해서다. 만약에 클래스가 이미 등록된 것이 아니거나 등록된 클래스의 기본 윈도우 프로시져의 주소값이 InitWndProc() 함수의 반환값과 틀리면, 새로운 클래스가 등록된다. if 의 조건문이 참이 되면, 먼저 등록된 클래스를 먼저 UnregsterClass() API 함수를 사용해서 등록 해제한다. 그 다음, TWinControl::CreateWindowHandle() 멤버 함수에 Params 값을 전달해서 호출한다.

각각의 구현에 대해서 깊게 알려고 하지 말고 대충 무슨 일이 일어나지만 알아두길 바란다. 즉, CreateWnd() 멤버 함수의 주된 기증은 새로운 윈도우 클래스를 RegisterClass() API 함수를 이용해서 등록하는 것이다. Params 변수의 초기화는 CreateParams() 함수가 수행하고 실제 윈도우 생성은 CreateWindowHandle() 함수가 처리한다.



5.2 CreateWindowHandle 함수

앞에서 말했듯이, CreateWindowHandle() 멤버 함수가 CreateWindow() API 함수를 사용해서 실제 윈도우를 만든다. 사실, CreateWindowHandle() 함수는 CreateWindowEx() API 함수를 사용한다. 함수의 이름대로, 이 함수는 CreateWindow() 함수의 확장판으로 더 많은 윈도우 스타일(확장 윈도우 스타일)을 설정할 수 있다. 이는 TCreateParams 구조체의 ExStyle 데이타 멤버를 알맞게 설정하면 된다.



HWND CreateWindowEx( 
    DWORD dwExStyle, 
    LPCTSTR lpClassName, 
    LPCTSTR lpWindowName, 
    DWORD dwStyle, 
    int x,  
    int y,  
    int nWidth, 
    int nHeight, 
    HWND hWndParent, 
    HMENU hMenu,  
    HINSTANCE hInstance, 
    LPVOID lpParam  
); 


목록 2.4에 C++ 로 표현한 CreateWindowHandle() 함수가 있는데, CreateWindowEx() API 함수만 호출하는 것을 볼 수 있다.



목록 2.4 
 
void __fastcall TWinControl::CreateWindowHandle(const TCreateParams &Params) 
{ 
    FHandle = CreateWindowEx( 
                        Params.ExStyle, 
                        Params.WinClassName, 
                        Params.Caption, 
                        Params.Style, 
                        Params.X, Params.Y, 
                        Params.Width, Params.Height, 
                        Params.WndParent, NULL, 
                        Params.WindowClass.hInstance, 
                        Params.Param 
                    ); 
} 


목록 2.3 에 정의된 CreateWindowHandle() 함수를 살펴보면 실제 윈도우를 만든다는 것을 알 수 있다. 이 일은 간단하게 CreateWindowEx() API 함수를 호출해서 이뤄지고 이때, 초기화된 Params 의 멤버를 함수의 인자로 전달한다. CreateWindow() API 함수처럼 CreateWindowEx() 함수도 새롭게 만들어진 윈도우 핸들을 반환한다. 이 값은 FHandle 멤버에 저장되는데 TWinControl::Handle 속성을 통해서 접근할 수 있다.

지금까지 살펴본 세가지 멤버 함수인, CreateParams(), CreateWnd(), CreateWindowHandle() 로 TWinControl 클래스는 윈도우 생성 메카니즘을 제공한다. CreateParams() 함수는 TCreateParams 구조체를 알맞게 설정하고, CreateWnd() 함수는 새 윈도우 클래스를 등록하며 CreateWindowHandle() 함수는 실제 윈도우을 만든다. 이 세 단계가 새로운 윈도우 클래스를 만들기 위해서 필요하다. 사실, 이 세가지 멤버 함수는 하나의 함수로 합칠 수 있다. 하지만 앞에서도 얘기했듯이, TWinControl 에서 파생된 클래스 대부분이 기존의 윈도우 클래스를 바탕으로 만들어진 것이다. 우리는 이 것이 슈퍼클래싱이란 기술을 통해서 이뤄진다는 것을 알고 있다. 그럼 지금부터 TWinControl 클래스가 어떻게 슈퍼클래싱을 캡슐화했는지 알아보자.



5.3 TWinControl 클래스로 슈퍼클래싱하기

기존의 컨트롤 클래스를 슈퍼클래싱하기 위해서 피룡한 단계를 생각해보면 첫째, GetClassInfo() 함수를 사용해서 기존 윈도우 클래스의 정보를 WNDCLASS 구조체에 담아야한다. 둘째, 클래스의 기본 윈도우 프로시져 주소값을 저장하고 새롭게 만든 윈도우 프로시져 주소값으로 교체해야한다. 셋째, WNDCLASS 데이타 멤버인 hInstance 와 lpClassName 을 알맞게 바꿔야한다. 곧 알게 되겠지만, 이 세가지 단계는 TWinControl 의 멤버 함수 하나로 이뤄진다.

CreateParams() 멤버 함수는 TCreateParams::WindowClass 의 멤버인 hInstance 를 설정하는 것으로 슈퍼클래싱에도 사용된다. 목록 2.1 의 구현처럼, CreateParams() 멤버 함수는 어플리케이션의 인스턴스인 HInstance 를 hInstance 데이타 멤버에 설정한다. CreateWnd() 멤버 함수 또한 슈퍼클래싱에 사용되는데 기본 윈도우 프로시져를 FDefWndProc 멤버에 저장하며, 슈퍼클래스 프로시져를 lpfnWndProc 멤버에 설정하고, lpszClassName 멤버에 새로운 윈도우 클래스 이름을 설정한다. 그럼 남은 일이 무엇일까? 지금까지의 구현을 보면 기존 클래스의 정보를 TCreateParams::WindowClass 멤버에 설정하기 위해서 GetClassInfo() 함수를 호출하는 곳이 없다. 이 일은 TWinControl::CreateSubClass 멤버 함수가 수행한다.

함수 이름에 맞지 않게, CreateSubClass() 멤버 함수는 CreateParams() 또는 CreateWnd() 함수에서 하지 않은 슈퍼클래싱의 나머지 작업을 처리한다. 즉, CreateSubClass() 멤버 함수의 역할은 TCreateParams::WindowClass 데이타 멤버를 기존 윈도우 클래스의 정보로 설정하는 것이다. 목록 2.5 에 C++ 로 표현한 TWinControl::CreateSubClass() 멤버 함수의 코드가 있다.



목록 2.5 
 
void __fastcall TWinControl::CreateSubClass(TCreateParams &Params, char *ControlClassName) 
{ 
    if (ControlClassName) 
    { 
        HINSTANCE SaveInstance = Params.WindowClass.hInstance; 
 
        if (!GetClassInfo(HInstance, ...) && !GetClassInfo(NULL, ...) && !GetClassInfo(MainInstance, ...)) 
        { 
            GetClassInfo(Params.WindowClass.hInstance, ControlClassName, &Params.WindowClass); 
        } 
 
        Params.WindowClass.hInstance = SaveInstance; 
    } 
} 


CreateSubClass() 함수에 전달되는 ControlClassName 인자는 기반 클래스이 이름이다. 예를 들어서, 윈도우즈의 BUTTON 표준 컨트롤을 슈퍼클래싱을 하려면, ControlClassName 인자에 "BUTTON" 을 전달해야 한다. Params 인자는 CreateParams() 함수로 초기화한 TCreateParms 구조체 값이다. CreateParams() 함수는 CreateSubClass() 함수 이전에 호출되어야 한다. 만약, CreateParams() 함수가 CreateSUbClass() 함수보다 늦게 호출된다면, CreateParams() 함수가 CreateSubClass() 에 의해 초기화된 정보를 지워버리고 다시 쓸 것이다. 대개, CreateSubClass() 함수는 오버라이드(override)된 CreateParams() 함수 안에서 호출되는데, 부모 클래스의 CreateParams() 함수를 호출한다음에 CreateSubClass() 함수를 호출한다.

목록 2.5를 보면, CreateSubClass() 함수는 대부분 GetClassInfo() API 함수를 이용해서 TCreateParams::WindowClass 멤버를 설정하는 내용으로 되어 있다. CreateSubClass() 함수는 총 4 번에 걸쳐서 GetClassInfo() 함수를 호출하는데, 각각의 호출마다 hInstance 인자가 다르다. GetClassInfo() 함수에 전달된는 hInstance 값은 클래스가 등록되어 있는 어플리케이션의 인스턴스 핸들이다. CreateSubClass() 함수는 우선 전역 HInstance 변수를 사용해서 현재 어플리케이션에 기반 클래스가 등록되어 있는지 살펴본다. 첫번째 호출이 실패하면, hInstance 에 NULL 값을 주어 호출하는데, 이 것은 윈도우즈 운영체제에 기반 클래스가 등록되어 있는지를 살펴보는 것이다. 두번째 호출도 실패하면, hInstance 인자에 MainInstance 를 전달해 호출한다. MainInstance 는 DLL 이 사용될 경우 HInsatnce 와 다른 값을 가지게 된다. 세번에 걸친 호출이 모두 실패하면, 마지막 호출로, WNDCLASS::hInstance 데이타 멤버를 GetClassInfo() 함수에 전달해 호출한다. 이 경우에는 GetClassInfo() 함수를 위해서 WindowClass 데이타 멤버인 hInstance 에 어플리케이션의 핸들을 명시적으로 설정해서 CreateSubClass() 함수에 전달해야 한다.

슈퍼클래싱 작업을 여러 멤버함수로 쪼개 놓은 것이 비직관적일 수도 있다. 사실, CreateSubClass() 함수가 슈퍼클래싱 작업을 한꺼번에 처리하는 것이 더 논리적일 수도 있다. 곧 알게 되겠지만, 슈퍼클래싱 작업을 이렇게 나누는 것이 꼭 필요한데, TWinControl 클래스에서 파생된 컨트롤 중 기반 클래스를 슈퍼클래싱 하지 않는 것도 있기 때문이다. 예를 들면, TCustomGrid 클래스는 TWinControl 에서 파생된 것이지만, 기반 컨트롤 클래스가 없다. 그렇기 때문에, TCustomGrid::CreateParams() 멤버 함수의 구현을 보면 CreateSubClass() 함수를 호출하지 않는다. 하지만, TWinControl 그 자체는 일반(generic) 윈도우를 슈퍼클래싱한 것이다. 사실, TWinControl 은 작은 빈공간에, 경계(border)가 없는 자식 윈도우다. 그렇기 때문에 TWinControl::CreateParams() 구현에서 TCreateParams::Style 멤버에 WS_CHILD 스타일을 기본으로 사용한다.

이 멤버 함수들의 자세한 설명에 질려버릴 것 같다면, 잠시 쉬면서 정리해보자. 이 글의 주제는 CreateParams(), CreateWnd() 그리고 CreateWindowHandle() 멤버 함수가 새로운 클래스를 등록하고, 이 새로운 클래스의 윈도우를 만들어 준다는 것이다. 마찬가지로 CreateSubClass() 함수를 "슈퍼클래싱 유틸리티" 멤버 함수라고 생각하면 된다. 슈퍼클래싱을 확실하게 이해하기 위해서 이제 예제를 살펴보자. 이 예제는 목록 2.1 에서 만들어본 TMyButton 컨트롤을 TWinControl 클래스를 사용해서 만들어 본 것이다. 목록 2.6a 와 2.6b 에 전체 코드가 있다.



목록 2.6a 
 
//---------------------------------------------------------------------- 
#ifndef SuperClassMyButtonH 
#define SuperClassMyButtonH 
//---------------------------------------------------------------------- 
#include <Classes.hpp> 
#include <Controls.hpp> 
#include <StdCtrls.hpp> 
#include <Forms.hpp> 
//---------------------------------------------------------------------- 
 
class TMyButton : public TWinControl 
{ 
protected: 
    virtual void __fastcall CreateParams(TCreateParams &Params); 
public: 
    __fastcall TMyButton(TComponent *Owner) : TWinControl(Owner) {}; 
}; 
//---------------------------------------------------------------------- 
 
class TForm1 : public TForm 
{ 
__published: // IDE-managed Components 
private: // User declarations 
    TMyButton *MyButton; 
Public: // User declarations 
    __fastcall TForm1(TComponent* Owner); 
}; 
//---------------------------------------------------------------------- 
extern PACKAGE TForm1 *Form1; 
//---------------------------------------------------------------------- 
#endif 




목록 2.6b 
 
//---------------------------------------------------------------------- 
#include <vcl\vcl.h> 
#pragma hdrstop 
#include "SuperClassMyButton.h" 
//---------------------------------------------------------------------- 
#pragma package(smart_init) 
#pragma resource "*.dfm" 
TForm1 *Form1; 
//---------------------------------------------------------------------- 
__fastcall TForm1::TForm1(TComponent* Owner) 
: TForm(Owner) 
{ 
    MyButton = new TMyButton(this); 
    MyButton->Parent = this; 
    MyButton->SetBounds(10, 10, 200, 75); 
 
    // use SetWindowText to set the caption of the 
    // button since we have not published the 
    // TControl::Caption property 
    SetWindowText(MyButton->Handle, "MyButton1"); 
} 
//---------------------------------------------------------------------- 
void __fastcall TMyButton::CreateParams(TCreateParams &Params) 
{ 
    // have the TWinControl::CreateParams member function 
    // perform its default initialization of Params 
    TWinControl::CreateParams(Params); 
 
    // superclass the Windows BUTTON Standard Control 
    CreateSubClass(Params, "BUTTON"); 
} 
//----------------------------------------------------------------------  


이 예제의 핵심은 TMyButton::CreateParams() 함수에 있다. 우선, 부모 클래스인 TWinControl 의 CreateParams() 함수를 호출해서 Params 인자를 알맞게 초기화한 다음 TWinControl::CreateSubClass() 멤버 함수에 초기화된 Params 값과 기반 컨트롤 클래스의 이름인 "BUTTON" 을 전달해서 호출했다.

이 예제는 TWinControl 클래스의 윈도우 생성 매카니즘을 자세히 살펴보는 일은 매우 어려웠지만, 멤버 함수를 사용하는 것은 매우 직관적인 것을 보여준다. 미리 정의된 컨트롤 클래스는 제한 되어 있기 때문에, CreateSubClass() 함수가 항상 필요한 것은 아니다.

6 윈도우 생성의 커스터마이즈

클래스 설계 중 가장 중요한 것은 확장이 쉬워야 하는 것인데 이 것은 TWinControl 클래스의 아주 강한 면중 하나다. 혼합되어 사용할 수 있는 윈도우 스타일이 어마어마하지만, TWinControl 클래스는 이 모든 스타일을 아주 유연하게 다룰 수 있다. 미리 정의된 컨트롤은 몇개 안 되지만 각 컨트롤이 사용할 수 있는 스타일은 아주 많다. 예를 들어서 아래에 있는 스타일은 표준 컨트롤인 STATIC 이 사용하는 스타일이다.

SS_BITMAP, SS_BLACKFRAME, SS_BLACKRECT, SS_CENTER, SS_CENTERIMAGE, SS_ENHMETAFILE, SS_ETCHEDFRAME, SS_ETCHEDHORZ, SS_ETCHEDVERT, SS_GRAYFRAME, SS_GRAYRECT, SS_ICON, SS_LEFT, SS_LEFTNOWORDWRAP, SS_NOPREFIX, SS_NOTIFY, SS_OWNERDRAW, SS_REALSIZEIMAGE, SS_RIGHT, SS_RIGHTJUST, SS_ICON, SS_SIMPLE, SS_SUNKEN, SS_WHITEFRAME, SS_WHITERECT.

TWinControl 에서 파생된 클래스들은 CreateParams() 멤버 함수를 재정해서 윈도우 생성에 사용되는 여러 인자들을 설정한다. 예를 들어서, TCustomStaticText::CreateParams() 함수는 아주 많은 STATIC 컨트롤의 스타일을 다룬다. 목록 2.7 을 보자.



목록 2.7 
 
void __fastcall TCustomStaticText::CreateParams(TCreateParams &Params) 
{ 
    TWinControl::CreateParams(Params); 
    CreateSubClass(Params, "STATIC"); 
 
    Params.Style |= SS_NOTIFY; 
    switch (FAlignment) 
    { 
        case taLeftJustify: 
        { 
            Params.Style |= SS_LEFT; 
            break; 
        } 
        case taRightJustify: 
        { 
            Params.Style |= SS_RIGHT; 
            break; 
        } 
        case taCenter: 
        { 
            Params.Style |= SS_CENTER; 
            break; 
        } 
    } 
 
    // <snip> some right to left alignment support... 
 
    // BorderStyle... 
    switch (BorderStyle) 
    { 
        case sbsSingle: 
        { 
            Params.Style |= WS_BORDER; 
            break; 
        } 
        case sbsSunken: 
        { 
            Params.Style |= WS_BORDER; 
            break; 
        } 
    } 
    Params.WindowClass.style &= ~(CS_HREDRAW | CS_VREDRAW); 
} 


목록 2.7 에서 TCreateParams::Style 과 TCreateParams::WindowClass:style 데이타 멤버를 다루는 예를 볼 수 있다. 모든 커스터마이즈는 CreateParams() 멤버 함수 내에서 할 수 있다. 계속해서 윈도우 생성을 커스터마이즈하는 예제를 살펴보자.



6.1 Style 과 ExStyle 다루기

앞에서 말했듯이, CreateWindowEx() 함수에 전달되는 인자를 다뤄야할 때가 있다. 보통 dwStyle 과 dwExStyle 인자를 많이 다룬다. 하지만, CreateWindowEx() 함수를 직접 호출해야할 일이 없기 때문에, 어떻게 이 인자들을 다뤄야 하는가? TCreateParams 구조체의 데이타 멤버중 Style 과 ExStyle 가 CreateWindowEx() 함수의 dwStyle 과 dwExStyle 로 전달되기 때문에 TCreateParams 구조체의 Style 과 ExStyle 을 다루면 된다. 이 일은 대개 CreateParams 함수 내에서 이뤄진다.

떠있는(플롯팅) 도구바를 만들기 위해서 많이 사용하는 툴윈도우를 만들어보자. 툴윈도우는 TForm::BorderStyle 속성을 bsToolWindow 로 고치면 쉽게 만들 수 있지만, 이 예제에서는 이 것을 TForm::CreateParams() 멤버 함수에서 만들어 본다. 특히, 툴윈도우는 CreateWindowEx() 함수의 dwExStyle 인자에 WS_EX_TOOLWINDOW 를 설정해서 만들기 때문에, TCreateParams::ExStyle 를 알맞게 설정해줘야 한다. 목록 2.8a 와 2.8b 는 구현 코드다.



목록 2.8a  
 
//---------------------------------------------------------------------- 
#ifndef ToolWindowH 
#define ToolWindowH 
//---------------------------------------------------------------------- 
#include <Classes.hpp> 
#include <Controls.hpp> 
#include <StdCtrls.hpp> 
#include <Forms.hpp> 
//---------------------------------------------------------------------- 
class TForm1 : public TForm 
{ 
__published: // IDE-managed Components 
private: // User declarations 
    virtual void __fastcall CreateParams(TCreateParams &Params); 
public: // User declarations 
    __fastcall TForm1(TComponent* Owner); 
}; 
//---------------------------------------------------------------------- 
extern PACKAGE TForm1 *Form1; 
//---------------------------------------------------------------------- 
#endif  




목록 2.8b  
 
//---------------------------------------------------------------------- 
#include <vcl.h> 
#pragma hdrstop 
#include "ToolWindow.h" 
//---------------------------------------------------------------------- 
#pragma package(smart_init) 
#pragma resource "*.dfm" 
TForm1 *Form1; 
//---------------------------------------------------------------------- 
__fastcall TForm1::TForm1(TComponent* Owner) 
: TForm(Owner) 
{ 
} 
//---------------------------------------------------------------------- 
void __fastcall TForm1::CreateParams(TCreateParams &Params) 
{ 
    TForm::CreateParams(Params); 
    Params.ExStyle = Params.ExStyle | WS_EX_TOOLWINDOW; 
} 
//---------------------------------------------------------------------- 


목록 2.8b 에 있는 TForm1::CreateParams() 함수에서, 우선 부모클래스의 CreateParams() 멤버 함수를 호출했다. 그리고 나서 Params 변수의 ExStyle 데이타 멤버에 WS_EX_TOOLWINDOW 스타일로 설정했다. 사실, 이 것은 BorderStyle 속성이 bsToolWindow 로 설정될 때 수행하는 일과 같은 것이다. 이 예제는 BorderStyle 속성을 다루는 것으로 더 쉽게 만들 수 있기 때문에 더 좋은 예제를 만들어보자.

그림 2.0 과 같이 파일의 속성을 알려주는 간단한 폼을 생각해보자.



탐색기에서 폼으로 파일을 끌어다놓기(드래그앤드롭 drag and drop)가 되도록 만들 것이다. "From Message to Event" 에서 DragAcceptFiles() API 함수를 드롭 목표 윈도우를 정할 때 사용할 수 있었다. 사실, DragAcceptFiles() 함수를 사용하지 않고 목표 윈도우를 설정하는 다른 방법이 있는데, WS_EX_ACCEPTFILES 확장 윈도우 스타일을 설정하면 해당 윈도우가 드롭 목표 윈도우로 만들어진다. 위의 예제처럼, TCreateParms::ExStyle 만 간단히 수정하면 된다. 목록 2.9a 와 2.9b 는 구현 코드다.



목록 2.9a 
 
//---------------------------------------------------------------------- 
#ifndef DragDropH 
#define DragDropH 
//---------------------------------------------------------------------- 
#include <Classes.hpp> 
#include <Controls.hpp> 
#include <StdCtrls.hpp> 
#include <Forms.hpp> 
#include <ExtCtrls.hpp> 
//---------------------------------------------------------------------- 
class TForm1 : public TForm 
{ 
__published: // IDE-managed Components 
    TLabel *NameLabel; 
    TLabel *SizeLabel; 
    TLabel *DateLabel; 
    TBevel *Bevel1; 
protected: 
    virtual void __fastcall CreateParams(TCreateParams &Params); 
private: // User declarations 
    void __fastcall WMDropFiles(TMessage &Msg); 
public: // User declarations 
    __fastcall TForm1(TComponent* Owner); 
 
BEGIN_MESSAGE_MAP 
    MESSAGE_HANDLER(WM_DROPFILES, TMessage, WMDropFiles) 
END_MESSAGE_MAP(TForm) 
}; 
//---------------------------------------------------------------------- 
extern PACKAGE TForm1 *Form1; 
//---------------------------------------------------------------------- 
#endif  




목록 2.9b 
 
//---------------------------------------------------------------------- 
#include <vcl.h> 
#pragma hdrstop 
#include <memory> 
#include "DragDrop.h" 
//---------------------------------------------------------------------- 
#pragma package(smart_init) 
#pragma resource "*.dfm" 
TForm1 *Form1; 
//---------------------------------------------------------------------- 
__fastcall TForm1::TForm1(TComponent* Owner) 
: TForm(Owner) 
{ 
} 
//---------------------------------------------------------------------- 
void __fastcall TForm1::CreateParams(TCreateParams &Params) 
{ 
    TForm::CreateParams(Params); 
    Params.ExStyle = Params.ExStyle | WS_EX_ACCEPTFILES; 
} 
//---------------------------------------------------------------------- 
void __fastcall TForm1::WMDropFiles(TMessage &Msg) 
{ 
    // grab a handle to the drop object 
    HDROP HDrop = reinterpret_cast<HDROP>(Msg.WParam); 
    // find the number of files dropped 
    int num_files = DragQueryFile(HDrop, 0xFFFFFFFF, NULL, NULL); 
    if (num_files > 1) 
    { 
        ShowMessage("You have dropped too many files."); 
        return; 
    } 
    // extract the name and path of the dropped file 
    char filename[MAX_PATH]; 
    DragQueryFile(HDrop, 0, filename, MAX_PATH); 
    NameLabel->Caption = NameLabel->Caption + " " + filename; 
    std::auto_ptr<TFileStream> fs; 
    try 
    { 
        fs.reset(new TFileStream(filename, fmOpenRead)); 
        // get the file information  
        SizeLabel->Caption = SizeLabel->Caption + " " + GetFileSize(reinterpret_cast<HANDLE>(fs->Handle), NULL); 
        DateLabel->Caption = DateLabel->Caption + " " + FileDateToDateTime(FileGetDate(fs->Handle)); 
    } 
    catch (...) 
    { 
        // close the drop handle 
        DragFinish(HDrop); 
    } 
    // close the drop handle  
    DragFinish(HDrop); 
    Msg.Result = 0; 
} 
//---------------------------------------------------------------------- 


목록 2.8b 에 있는 TForm1::CreateParams() 함수 내에서, 우선 부모 클래스의 CreateParams() 함수를 호출한다음에 ExStyle 멤버에 WS_EX_ACCEPTFILES 를 추가했다. WMDropFiles 메세지 핸들러에서, 드롭된 파일의 크기를 얻기 위해서 GetFileSize() API 함수를 사용했고 파일이 마지막으로 수정된 날짜를 알기위해서 VCL 함수인 FileGetDate() 와 FileDateToDateTime() 함수를 사용했다.

Style 과 ExStyle 멤버는 자식 컨트롤을 만들 때 아주 유용하게 살사용할 수 있다. 예를 들어, TListBox 에서 수직 스크롤바를 없애려면 Style 데이타 멤버에서 WS_VSCROLL 을 제거하면 된다.



목록 2.10 
 
//---------------------------------------------------------------------- 
#ifndef NoScrollListBoxH 
#define NoScrollListBoxH 
//---------------------------------------------------------------------- 
#include <StdCtrls.hpp> 
//---------------------------------------------------------------------- 
class TMyListBox : public TListBox 
{ 
protected: 
    virtual void __fastcall CreateParams(TCreateParams &Params) 
    { 
        TListBox::CreateParams(Params); 
        Params.Style = Params.Style & ~WS_VSCROLL; 
    } 
public: 
    __fastcall TMyListBox(TComponent *Owner) : TListBox(Owner) {}; 
}; 
//---------------------------------------------------------------------- 
#endif  




6.2 WindowClass 멤버 다루기

새로운 컨트롤 클래스의 윈도우를 만드는 첫번재 단계는 WNDCLASS 변수를 설정하는 것이었다. RegisterClass() API 함수에 전달되는 WNDCLASS 변수는 새로운 컨트롤 클래스의 속성을 설정하는데 사용할 수 있다. style 멤버는 클래스의 스타일을 정의하는데 사용된다. 예를 들어, 목록 2.0 에서 form_wc 의 style 멤버를 CS_VREDRAW, CS_HREDRAW, CS_DBLCLKS 클래스 스타일을 섞어서 설정했었다.

TCreateParams::WindowClass 데이타 멤버는 RegisterClass() 함수에 전달되는 WNDCLASS 구조체 변수다. 이 멤버는 CreateParams() 멤버 함수에서 설정되는데, Style 과 ExStyle 멤버처럼 WindowClass 멤버를 커스터마이즈할 수 있다.

기본 마우스 커서로 십자선 커서를 갖는 폼을 만들어보자. 이런 폼은 Cursor 속성을 수정해서 쉽게 만들수 있지만, 이 예제에서는 WindowClass 의 hCursor 데이타 멤버를 수저해서 만들어 본다.



//---------------------------------------------------------------------- 
#ifndef HelpCursorH 
#define HelpCursorH 
//---------------------------------------------------------------------- 
#include <Classes.hpp> 
#include <Controls.hpp> 
#include <Forms.hpp> 
#include <StdCtrls.hpp> 
//---------------------------------------------------------------------- 
class TForm1 : public TForm 
{ 
__published: // IDE-managed Components 
protected: 
    virtual void __fastcall CreateParams(TCreateParams &Params) 
    { 
        TForm::CreateParams(Params); 
        Params.WindowClass.hCursor = LoadCursor(NULL, IDC_CROSS); 
    } 
public: // User declarations 
    __fastcall TForm1(TComponent* Owner); 
}; 
//---------------------------------------------------------------------- 
extern PACKAGE TForm1 *Form1; 
//---------------------------------------------------------------------- 
#endif 


전과 같이, 우선 부모 클래스의 CreateParams() 멤버 함수로 Params 를 설정한다음에, LoadCursor() API 함수를 사용해서 hCursor 의 멤버에 십자형 마우스 커서를 설정했다.

WindowClass 멤버를 다루는 다른 예제를 살펴보자. 이 예제는 그림 2.1 처럼 윈도우의 "닫기" 버튼을 비활성 버튼으로 만든다.



WindowClass 데이타 멤버엣 CS_NOCLASS 클래스 스타일을 추가하면 된다.



목록 2.12 
 
//---------------------------------------------------------------------- 
#ifndef NoCloseH 
#define NoCloseH 
//---------------------------------------------------------------------- 
#include <Classes.hpp> 
#include <Controls.hpp> 
#include <Forms.hpp> 
#include <StdCtrls.hpp> 
//---------------------------------------------------------------------- 
class TForm1 : public TForm 
{ 
__published: // IDE-managed Components 
protected: 
    virtual void __fastcall CreateParams(TCreateParams &Params) 
    { 
        TForm::CreateParams(Params); 
        Params.WindowClass.style = Params.WindowClass.style | CS_NOCLOSE; 
    } 
public: // User declarations 
    __fastcall TForm1(TComponent* Owner); 
}; 
//---------------------------------------------------------------------- 
extern PACKAGE TForm1 *Form1; 
//---------------------------------------------------------------------- 
#endif 


앞에서 살펴본 hCursor 멤버를 설정하는 예제처럼, WindowClass 의 style 데이타 멤버에 CS_NOCLOSE 클래스 스타일을 추가했다. 이 스타일은 타이틀바의 "닫기" 버튼을 비활성 버튼으로 만들고 시스템 메뉴에서 "닫기" 항목을 제거한다. 하지만, 태스바에 있는 어플리케이션 버튼위에서 마우스 오른쪽 버튼을 누르면 "닫기" 메뉴 항목이 있는 것을 볼 수 있다. 이 문제를 해결하는 방법을 알아보자.



6.3 WndParent 멤버 다루기

가장 많이 묻는 질문 중에 하나는, '어플리케이션 내의 폼들을 어떻게 테스크바 위에 버튼으로 나타내느냐' 이다. 기본적으로, VCL 어플리케이션에서 쓰이는 폼은 테스크바 버튼으로 나타나질 않는다. 우리가 보는 것은 TApplication 윈도우이다. 테스크바 버튼 위에서 마우스 오른쪽 버튼을 눌러보면, 표준 윈도우즈 어플리케이션과 VCL 어플리케이션과의 차이점을 볼 수 있다. 메모장의 팝업 메뉴는 그림 2.2 처럼 시스템 메뉴다.



VCL 어플리케이션은 다른 메뉴가 나온다. TApplication::CreateHandle() 멤버 함수가 그림 2.3 처럼 최대화(Maximize), 이동(Move), 크기 조정(Size) 옵션을 제거하기 때문이다.



그럼 왜 TApplication::CreateHandle() 멤버 함수는 최대화, 이동, 크기조정의 메뉴를 만들지 않는 것일까? 그것은 TApplication 의 윈도우가 최대화, 이동, 크기변환이 되면 안 되기 때문이다.

CreateWindowEx() 함수의 hWndParent 인자에 대해서 얘기할 때, 기본으로 이 값에 어플리케이션(TApplication) 윈도우의 핸들을 설정했었다. 그렇기 때문에 테스크바에서 폼의 버튼을 볼 수 없는 것이다. 앞의 예제처럼 CreateParams() 함수를 사용해서, TCreateParams::WndParent 멤버를 바탕화면(desktop) 윈도우의 핸들로 설정할 수 있다. 목록 2.13 은 구현 코드다.



목록 2.13 
 
//---------------------------------------------------------------------- 
#ifndef AppWindow2H 
#define AppWindow2H 
//---------------------------------------------------------------------- 
#include <Classes.hpp> 
#include <Controls.hpp> 
#include <StdCtrls.hpp> 
#include <Forms.hpp> 
//---------------------------------------------------------------------- 
class TForm2 : public TForm 
{ 
__published: // IDE-managed Components 
private: // User declarations 
    virtual void __fastcall CreateParams(TCreateParams &Params) 
    { 
        TForm::CreateParams(Params); 
        Params.WndParent = GetDesktopWindow(); // or NULL 
    } 
public: // User declarations 
    __fastcall TForm2(TComponent* Owner); 
}; 
//---------------------------------------------------------------------- 
extern PACKAGE TForm2 *Form2; 
//---------------------------------------------------------------------- 
#endif 


GetDesktopWindow() API 함수를 이용해서 바탕화면(desktop)의 윈도우 핸들을 가져온 다음에, 이 핸들 값을 Params 의 WndParent 데이타 멤버에 설정했다. 위의 구현으로, Form2 는 테스크바에 버튼으로 나타난다. 그리고 마우스 오른쪽 버튼을 눌러보면 시스템 메뉴가 나온다. 하지만, 어플리케이션(TApplication) 자체가 최소화될 때 Form2 는 최소화되지 않는다.

사실, 위의 방법은 Application 의 MainFrom( TApplication::MainForm) 을 뺀 모든 폼이 잘 동작한다. 하지만 왜 MainForm 에서 최소화 메뉴가 작동하지 않는지 알아보기 위해서 목록 2.13 의 코드를 TFrom1 클래스로 다시 만들어보자.



목록 2.14 
 
//---------------------------------------------------------------------- 
#ifndef AppWindow2H 
#define AppWindow2H 
//---------------------------------------------------------------------- 
#include <Classes.hpp> 
#include <Controls.hpp> 
#include <StdCtrls.hpp> 
#include <Forms.hpp> 
//---------------------------------------------------------------------- 
class TForm1 : public TForm 
{ 
__published: // IDE-managed Components 
private: // User declarations 
    virtual void __fastcall CreateParams(TCreateParams &Params) 
    { 
        TForm::CreateParams(Params); 
        Params.WndParent = GetDesktopWindow(); // or NULL 
    } 
public: // User declarations 
    __fastcall TForm2(TComponent* Owner); 
}; 
//---------------------------------------------------------------------- 
extern PACKAGE TForm2 *Form2; 
//---------------------------------------------------------------------- 
#endif 


이 예제를 실행시키면, 두가지 문제점을 발견할 것이다. 어플리케이션의 윈도우 버튼이 테스크바에 그대로 있고, Form1 의 새로운 버튼도 테스크바 위에 나타난다. 어플리케이션의 테스트바 버튼위에서 마우스 오른쪽 버튼을 눌러서 최소화 메뉴를 선택하면 Form1 은 최소화되지 않고 그래도 있는 문제를 볼 수 있다.

왜 그런지 알기 위해서는 WndParent 멤버에 어플리케이션 윈도우의 핸들이 사용된 것을 알아야한다. 그렇기 때문에 어플리케이션이 최소화되면 모든 폼이 최소화되는 것이다. 위의 예제를 보면, Form1 과 Form2 는 WndParent 의 값으로 더이상 어플리케이션의 윈도우 핸들을 사용하지 않기 때문에 어플리케이션이 최소화 될 때, 그대로 있는 것이다.

윈도우의 최소화 시스템 메뉴가 선택되면, 윈도우는 SC_MINIMIZE 명령을 wParam 인자에 넣어 WM_SYSCOMMAND 메세지를 보낸다. TCustomForm 클래스는 이 메세지를 WMSysCommand 메세지 핸들러에서 다루는데, 이 핸들러 안에서 메세지의 현재 인스턴스가 어플리케이션의 MainForm 인지 아닌지를 체크한다음에, 그렇다면 그 메세지를 어플리케이션 윈도우에 전달한다. 메세지를 받은 어플리케이션 윈도우는 TApplication::Minimize() 멤버 함수를 사용해서 메세지를 처리한다. 이렇게 하면 모든 폼들이 최소화되지만, WndParent 를 조작한 폼은 최소화되질 않는다.

이 문제를 해결하기 위해서, 메세지 매크로를 사용해야한다.( 즉, Dispatch() 함수를 사용하는 것 ) 그렇게하면, TCustomForm 클래스에 전달되던 WM_SYSCOMMAND 메세지를 우리가 만든 WMSysCommand 메세지 핸들러에서 가로챌 수 있다. 목록 2.15a 와 2.15b 에 구현 코드가 있다.



목록 2.15a 
 
//---------------------------------------------------------------------- 
#ifndef AppWindowH 
#define AppWindowH 
//---------------------------------------------------------------------- 
#include <Classes.hpp> 
#include <Controls.hpp> 
#include <StdCtrls.hpp> 
#include <Forms.hpp> 
//---------------------------------------------------------------------- 
class TForm1 : public TForm 
{ 
__published: // IDE-managed Components 
    TButton *Button1; 
    void __fastcall FormShow(TObject *Sender); 
    void __fastcall Button1Click(TObject *Sender); 
private: // User declarations 
    void __fastcall WMSysCommand(TMessage &Msg); 
protected: 
    virtual void __fastcall CreateParams(TCreateParams &Params); 
public: // User declarations 
    __fastcall TForm1(TComponent* Owner); 
BEGIN_MESSAGE_MAP 
    MESSAGE_HANDLER(WM_SYSCOMMAND, TMessage, WMSysCommand) 
END_MESSAGE_MAP(TForm) 
}; 
//---------------------------------------------------------------------- 
extern PACKAGE TForm1 *Form1; 
//---------------------------------------------------------------------- 
#endif 




목록 2.15b 
 
//---------------------------------------------------------------------- 
#include <vcl.h> 
#pragma hdrstop 
#include "AppWindow.h" 
#include "AppWindow2.h" 
//---------------------------------------------------------------------- 
#pragma package(smart_init) 
#pragma resource "*.dfm" 
TForm1 *Form1; 
//---------------------------------------------------------------------- 
__fastcall TForm1::TForm1(TComponent* Owner) 
: TForm(Owner) 
{ 
} 
//---------------------------------------------------------------------- 
void __fastcall TForm1::CreateParams(TCreateParams &Params) 
{ 
    TForm::CreateParams(Params); 
    Params.WndParent = GetDesktopWindow(); 
} 
//---------------------------------------------------------------------- 
void __fastcall TForm1::WMSysCommand(TMessage &Msg) 
{ 
    // trap the WM_SYSCOMMAND message only if the  
    // SC_MINIMIZE flag is specified 
    unsigned int op_code = Msg.WParam & 0xFFF0; 
    if (op_code == SC_MINIMIZE) 
    { 
        WindowState = wsMinimized; 
        Msg.Result = 0; 
        return; 
    } 
    TForm::Dispatch(&Msg); 
} 
//---------------------------------------------------------------------- 
void __fastcall TForm1::FormShow(TObject *Sender) 
{ 
    // hide the Application window (and its taskbar button) 
    ShowWindow(Application->Handle, SW_HIDE);  
} 
//---------------------------------------------------------------------- 
void __fastcall TForm1::Button1Click(TObject *Sender) 
{ 
    // display Form2 (notice its own taskbar button) 
    Form2->Show();  
} 
//---------------------------------------------------------------------- 


목록 2.15a 에서 메세지 매크로를 사용했는데, 이 매크로는 Dispatch() 멤버 함수를 사용하는 것이다. 목록 2.15b 의 WM_SYSCOMMAND 메세지 핸들러인 WMSysCommand() 내에서, WParam 이 SC_MINIMIZE 인지 체크한다음에 맞다면, TCustomForm::WindowState 속성을 설정해서 Form1 을 최소화시키고 메세지를 트랩했다.

TCustomForm::OnShow 이벤트 핸들러를 사용했는데, ShowWindow() API 함수를 사용해서 어플리케이션 윈도우와 테스트바의 버튼을 보이지 않게 했다. 이렇게 해서 모든 문제를 해결했다.

• see also Scrap/InsideTheVcl
  

• CategoryTools