지나간 삶

// 특정 메뉴를 OWNERDRAW로 변경하고 ItemData에 색상을 넣어 준다.
void AddMenuColor( HMENU hMenu, UINT id, COLORREF color )
{
    ModifyMenu( hMenu, id, MF_BYCOMMAND | MF_OWNERDRAW, id, "" );
    // ItemData에 색상을 기록해 둔다.
    MENUITEMINFO mi = { 0 };
    mi.cbSize = sizeof(mi);
    mi.dwItemData = (DWORD)color;
    mi.fMask = MIIM_DATA;
    SetMenuItemInfo( hMenu, id, FALSE, &mi );    // FALSE :2번째 인자가 ID라는 의미.TRUE:POSITION
}
LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {   
    case WM_CREATE:
        {
            // 그리기 메뉴 1단계 - 메뉴항목의 속성을 OWNERDRAW로 변경한다.
            HMENU h1 = GetMenu( hwnd );
            HMENU h2 = GetSubMenu( h1, 0 );

            AddMenuColor( h2, ID_RED, RGB( 255, 0, 0 ) );
            AddMenuColor( h2, ID_BLUE, RGB( 0, 0, 255 ) );
            AddMenuColor( h2, ID_GREEN, RGB( 0, 255, 0 ) );
           
            // ModifyMenu(
            //    h2,                // 팝업메뉴 핸들
            //    ID_RED,            // ID 또는 Position
            //    MF_BYCOMMAND | MF_OWNERDRAW,
            //    // 2번째 파라미터의 해석 방법 | 속성...
            //    // MF_BYCOMMAND(ID), MF_BYPOSITION(순서)
            //    ID_RED,            // 변경할 ID
            //    "빨간색"            // 변경할 Text
            //    );
        }
        return 0;
    case WM_MEASUREITEM:
        {
            // 그리기 메뉴 2단계
            // OS 가 구조체를 만들어서 포인터를 보내준다. 그 구조체에 크기를 채워준다.
            LPMEASUREITEMSTRUCT p = (LPMEASUREITEMSTRUCT)lParam;

            if( p->itemID == ID_RED || p->itemID == ID_BLUE || p->itemID == ID_GREEN )
            // 메뉴 Item ID 조사
            {
                p->itemWidth = GetSystemMetrics( SM_CYMENU ) * 4;
                p->itemHeight = GetSystemMetrics( SM_CYMENU );
            }
        }
        return 0;
    case WM_DRAWITEM:
        {
            // 그리기 메뉴 3단계 - Item 에 원하는 그림을 그린다.
            LPDRAWITEMSTRUCT p = (LPDRAWITEMSTRUCT)lParam;

            HDC hdc = p->hDC;
            RECT rc = p->rcItem;    // 그려야 하는 Item의 크기
            int state = p->itemState;    // Item의 상태
            int id = p->itemID;

            if( id == ID_RED || p->itemID == ID_BLUE || p->itemID == ID_GREEN )
            {
                RECT rcTemp = rc;

                // 선택여부를 조사한다.
                COLORREF c;
                /////////////////////////////////////////////////////
                if( state & ODS_SELECTED )    // 선택여부를 나타내는 필드
                {
                    c = GetSysColor( COLOR_HIGHLIGHT );
                    InflateRect( &rcTemp, -2, -2 );    // 사각형을 줄인다.
                }
                else
                {
                    c = GetSysColor( COLOR_MENU );
                    InflateRect( &rcTemp, -5, -5 );    // 사각형을 줄인다.
                }
                /////////////////////////////////////////////////////
                HBRUSH hBrush1 = CreateSolidBrush( c );
                FillRect( hdc, &rc, hBrush1 );

                // ItemData에서 색상을 얻는다.
                COLORREF color = (COLORREF)(p->itemData);
                HBRUSH hBrush = CreateSolidBrush( color );
                FillRect( hdc, &rcTemp, hBrush );

                DeleteObject( hBrush1 );
                DeleteObject( hBrush );
            }
        }
        return 0;

    case WM_RBUTTONUP:
        return DefWindowProc( hwnd, msg, wParam, lParam );    // MSDN에서 강조함!!확인!

    // ContextMenu 나타내기 - Tray에서 나타내려면 WM_RBUTTONUP을 사용해라.!
    case WM_CONTEXTMENU:
        {
            // 1. 메뉴 Load
            HMENU hMenu = LoadMenu( GetModuleHandle(0), MAKEINTRESOURCE(IDR_MENU1) );

            // 2. 나타낼 팝업 메뉴 핸들 얻기
            HMENU hSubMenu = GetSubMenu( hMenu, 0 );

            // 3. 현재 커서의 위치에 나타낸다.
            POINT pt;
            GetCursorPos( &pt );

            TrackPopupMenu(
                hSubMenu, TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
                pt.x, pt.y,        // 좌표
                0,                // Reserved(사용안함)
                hwnd,            // 메뉴 메세지를 받을 윈도우
                0 );            // 사용안함.

            // LoadIcon, LoadCursor는 Destroy 할 필요없다.
            // LoadMenu 는 Destroy 해야 한다. --- MSDN 참고.
            DestroyMenu( hMenu );
        }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

// DialogBoxParam 을 사용하기 위해선 구조체가 필요하다.
// 각 컨트롤에서 값을 꺼내기 위해 사용한다.
typedef struct _DATA
{
    int cx;
    int cy;
}DLGDATA;

// DialogBox를 나타내려면 DialogProc가 있어야 한다.
BOOL CALLBACK DlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
    static DLGDATA* pData;

    switch( msg )
    {
    case WM_INITDIALOG:
        {
            // 부모를 사용가능하게 한다.
            pData = (DLGDATA*)lParam;

            // 구조체 값으로 컨트롤을 초기화 한다.
            SetDlgItemInt( hDlg, IDC_EDIT1, pData->cx, 0 );
            SetDlgItemInt( hDlg, IDC_EDIT2, pData->cy, 0 );

            // 부모를 사용가능하게 한다.
            //EnableWindow( GetParent( hDlg ), TRUE );
        }
        return TRUE;

    case WM_COMMAND:
        switch( LOWORD(wParam) )
        {
        case IDOK:
            {
                // 값을 꺼내서 부모가 전달해 준 구조체에 넣는다.
                BOOL bRet = 0;

                pData->cx = GetDlgItemInt( hDlg, IDC_EDIT1, &bRet, 0 );
                pData->cy = GetDlgItemInt( hDlg, IDC_EDIT2, &bRet, 0 );
                /*
                char buf[256];
                // 결국 각 Control의 ID를 핸들로 변경하면 다양한 윈도우 관련 함수를 사용가능하다.
                //HWND hEdit = GetDlgItem( hDlg, IDC_EDIT1 );
                //GetWindowLong( hEdit, buf, 256 );

                GetDlgItemText( hDlg, IDC_EDIT1, buf, 256 );
                MessageBox( 0, buf, "", MB_OK );
                */
                //////////////////////////////////////////////////////////////////////////
               
                EndDialog( hDlg, IDOK );    // 모달 Dialog를 닫는다.
            }
            break;
        case IDCANCEL:    EndDialog( hDlg, IDCANCEL ); break;
        }
        return TRUE;    // 메세지를 처리한 경우
    }
    return FALSE;    // 메세지를 처리 하지 않은 경우
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static int sx, sy;

    switch( msg )
    {
        RECT aa;

    case WM_LBUTTONDOWN:
        {
            DialogBox( 0, 0, 0, 0 );
            // 값을 꺼내오기 위해서 구조체 생성
            DLGDATA data;
            data.cx = sx;
            data.cy = sy;
            // 모달 Dialog 나타내기
            UINT ret = DialogBoxParam(
                GetModuleHandle( 0 ),            // hInstance
                MAKEINTRESOURCE( IDD_DIALOG1 ),    // 리소스 ID
                hwnd,                            // 부모 윈도우 핸들
                (DLGPROC)DlgProc,                // 메세지 함수
                (LPARAM)&data                    // WM_INITDIALOG의 lParam으로 간다.
                );

            if ( ret == IDOK )                    // EndDialog의 리턴값
            {
                // 구조체에서 값을 꺼내서 static 변수에 넣어 놓고 사용한다.
                sx = data.cx;
                sy = data.cy;

                InvalidateRect( hwnd, 0, TRUE );
            }
        }
        return 0;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            TextOut( hdc, sx, sy, "hello", 5 );
            EndPaint( hwnd, &ps );
        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

 // 메뉴를 적재하는 3가지 방법중 1번째
 // 1. 윈도우 클래스에 메뉴 리소스 ID를 등록한다.
 wc.lpszMenuName = IDR_MENU1;

 // 메뉴를 붙이는 2번쨰 방법.
 // 2. CreateWindowEx 9번째 인자를 사용한다.
 hMenu = LoadMenu( hInstance, MAKEINTRESOURCE(IDR_MENU1) );
 SetMenu( hwnd, hMenu );

// 3. 핸들을 얻어내서 추가하기
 HMENU h1 = GetMenu( hwnd );    // 메뉴 바의 핸들을 얻는다.
 HMENU h2 = GetSubMenu( h1, 0 );    // h1의 1번째 팝업 메뉴의 핸들을 얻는다.

 MENUINFO mi = { 0 };
 mi.cbSize = sizeof( mi );
 mi.hbrBack = CreateSolidBrush( RGB( 0, 255, 0 ) );
 mi.fMask = MIM_BACKGROUND;
  // 팝업 메뉴를 관리하는 구조체를 변경한다.
 SetMenuInfo( h2, &mi );

 //AppendMenu( h2, MF_STRING, 50001, "추가메뉴" );
 //// 메뉴 바에도 직접 추가 할 수 있다.
 //AppendMenu( h1, MF_STRING, 50002, "AAA" );
 /// 메뉴 바에 추가한 경우 즉시 그리게 한다.
 //DrawMenuBar( hwnd );

           if ( bFull == FALSE )
            {
                bFull = TRUE;

                hMenu = GetMenu( hwnd );    // 메뉴 핸들을 보관하고
                SetMenu( hwnd, 0 ); // 메뉴를 떼어낸다.

                ModifyStyle( hwnd, WS_CAPTION, 0 );
                ShowWindow( hwnd, SW_MAXIMIZE );
            }
            else
            {
                bFull = FALSE;
                SetMenu( hwnd, hMenu );
                hMenu = 0;
                ModifyStyle( hwnd, 0, WS_CAPTION );
                ShowWindow( hwnd, SW_SHOWNORMAL );
            }

    while ( GetMessage( &msg, 0, 0, 0) )
    {   
        // 모달리스는 자체 루프를 가지고 있지 않다.
        // 그래서... IsDialogMessage()를 직접 호출해야 한다.

        if ( !IsWindow( g_hDlg ) || !IsDialogMessage( g_hDlg, &msg ))
        {
            TranslateMessage( &msg );
            DispatchMessage( &msg );
        }
    }
// DialogBox를 나타내려면 DialogProc가 있어야 한다.
BOOL CALLBACK DlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
    static DLGDATA* pData;

    switch( msg )
    {
    case WM_INITDIALOG:
        {
            // 부모를 사용가능하게 한다.
            pData = (DLGDATA*)lParam;

            // 구조체 값으로 컨트롤을 초기화 한다.
            SetDlgItemInt( hDlg, IDC_EDIT1, pData->cx, 0 );
            SetDlgItemInt( hDlg, IDC_EDIT2, pData->cy, 0 );

            // 부모를 사용가능하게 한다.
            //EnableWindow( GetParent( hDlg ), TRUE );
        }
        return TRUE;

    case WM_COMMAND:
        switch( LOWORD(wParam) )
        {
        case IDOK:
            {
                // 값을 꺼내서 부모가 전달해 준 구조체에 넣는다.
                BOOL bRet = 0;

                pData->cx = GetDlgItemInt( hDlg, IDC_EDIT1, &bRet, 0 );
                pData->cy = GetDlgItemInt( hDlg, IDC_EDIT2, &bRet, 0 );

                // Data를 꺼내서 구조체에 넣어두고, 부모에게 메세지를 보내서 즉시 update 한다.
                SendMessage( GetParent(hDlg), WM_USER+100, 0, 0 );

            }
            break;
        case IDCANCEL:
            DestroyWindow( hDlg );
            g_hDlg = 0;    // 그래야 다음번 모달리스 Dialog가 나타난다.

            break;
        }
        return TRUE;    // 메세지를 처리한 경우
    }
    return FALSE;    // 메세지를 처리 하지 않은 경우
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static int sx, sy;

    // 값을 꺼내오기 위해서 구조체 생성
    static DLGDATA data;

    switch( msg )
    {
    case WM_USER+100:
        sx = data.cx;
        sy = data.cy;

        InvalidateRect( hwnd, 0, TRUE );
        return 0;

    case WM_LBUTTONDOWN:
        {
            if ( g_hDlg == 0 )
            {
                data.cx = sx;
                data.cy = sy;
                // 모달리스 Dialog 나타내기
                g_hDlg = CreateDialogParam(
                    GetModuleHandle( 0 ),            // hInstance
                    MAKEINTRESOURCE( IDD_DIALOG1 ),    // 리소스 ID
                    hwnd,                            // 부모 윈도우 핸들
                    (DLGPROC)DlgProc,                // 메세지 함수
                    (LPARAM)&data                    // WM_INITDIALOG의 lParam으로 간다.
                    );
                ShowWindow( g_hDlg, SW_SHOW );
            }
            else
            {
                // Focus를 이동해서 사용자에게 알려준다.
                SetFocus( g_hDlg );
            }
        }
        return 0;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );
            TextOut( hdc, sx, sy, "hello", 5 );
            EndPaint( hwnd, &ps );
        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

//-------------------------------------------------------------------------------
// 시스템 메뉴의 ID 16의 배수로 0xF000 보다 작게...
#define IDM_SYS_TOPMOST 0x0010
#define WM_TRAYMESSAGE    WM_USER+100
LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {   
    case WM_CREATE:
        {
            // 시스템 메뉴의 핸들을 얻어낸다.
            HMENU hMenu = GetSystemMenu( hwnd, FALSE );
            // 메뉴를 추가한다.
            AppendMenu( hMenu, MF_SEPARATOR, 0, 0 );
            AppendMenu( hMenu, MF_STRING, IDM_SYS_TOPMOST, "항상위" );
        }       
        return 0;
    case WM_SYSCOMMAND:
        // 주의 ID 조사시 하위 4비트를 0으로 놓고 조사한다.
        switch( LOWORD( wParam & 0xFFF0 ) )
        {
        case IDM_SYS_TOPMOST:
            MessageBox( hwnd, "항상위", "", MB_OK );
            return 0;
        case SC_MINIMIZE:    // 닫기 메뉴의 ID
            {
                // 트레이에 Icon 넣기.
                NOTIFYICONDATA nid = { 0 };
                nid.cbSize = sizeof(nid);
                nid.hIcon = LoadIcon( 0, IDI_WINLOGO );
                nid.hWnd = hwnd;

                nid.uCallbackMessage = WM_USER+100;
                nid.uID = 1;

                strcpy( nid.szTip, "Test" );

                nid.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;

                Shell_NotifyIcon( NIM_ADD, &nid );

                // 애니메이션 효과를 낸다..
                RECT rcFrom;
                GetWindowRect( hwnd, &rcFrom );

                // 실제로는 작업표시줄을 구해야 한다.
                RECT rcTo = { 1280, 1024, 1281, 1025 }; //화면 오른쪽 아래

                DrawAnimatedRects( hwnd, IDANI_CAPTION, &rcFrom, &rcTo );
               
                // 이제 윈도우를 숨긴다.
                ShowWindow( hwnd, SW_HIDE );
            }
            return 0;
        }
        // 나머지 모든 메뉴를 처리하기 위해 아래로 보내야 한다.
        return DefWindowProc( hwnd, msg, wParam, lParam );

    case WM_TRAYMESSAGE:
        if( wParam == 1 ) // Icon ID
        {
            if( lParam == WM_LBUTTONDBLCLK)
            {
                ShowWindow( hwnd, SW_SHOW );
            }
            else if( lParam == WM_RBUTTONUP )
            {
                // Context Menu 를 나타나게 해준다.
            }
        }
        return 0;

    case WM_LBUTTONDOWN:
        //GetSystemMenu( hwnd, TRUE );    // 초기상태로 되돌린다.
        return 0;

    case WM_DESTROY:
        // Tray Icon을 제거하고 종료해야 한다.
        {
            NOTIFYICONDATA nid = { 0 };
            nid.cbSize = sizeof(nid);
            nid.hWnd = hwnd;
            nid.uID = 1;
            Shell_NotifyIcon( NIM_DELETE, &nid );
        }
        PostQuitMessage(0);
        return 0;
    }

//////////////////////////////////////////////////////////////////////////////////////
    HCURSOR hCursor = LoadCursor( hInstance, MAKEINTRESOURCE( IDC_CURSOR1 ) );
    // 애니메이션 커서 Load
    HCURSOR hCursor = LoadCursorFromFile( "C:\\windows\\cursors\\dinosaur.ani" );
//////////////////////////////////////////////////////////////////////////////////////
// 커서 위치별 변화시키기
LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HCURSOR h1 = LoadCursorFromFile( "C:\\windows\\cursors\\sizens.ani" );
    static HCURSOR h2 = LoadCursorFromFile( "C:\\windows\\cursors\\sizewe.ani" );
    static HCURSOR h3 = LoadCursorFromFile( "C:\\windows\\cursors\\banana.ani" );

    static RECT gameRect = { 10, 10, 100, 100 };

    switch( msg )
    {   
    case WM_SETCURSOR:
        {
            UINT code = LOWORD( lParam );

            POINT pt;
            GetCursorPos(&pt);
            ScreenToClient( hwnd, &pt );

            if ( code == HTCLIENT && PtInRect( &gameRect, pt ) )
            {
                SetCursor( h3 );
                return TRUE;
            }

            if ( code == HTTOP || code == HTBOTTOM )
            {
                SetCursor( h1 );
                return TRUE;    // 커서변경한 경우 TRUE 리턴
            }
            if ( code == HTLEFT || code == HTRIGHT )
            {
                SetCursor( h2 );
                return TRUE;
            }

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

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {   
        // 탐색기가 보내주는 메세지
    case WM_DROPFILES:
        {
            // Drop된 파일의 이름을 가진 메모리 핸들을 얻어 낸다.
            HDROP hDrop = (HDROP)wParam;

            // 먼저 갯수를 파악한다.
            int count = DragQueryFile( hDrop, -1, 0, 0 );

            for ( int i = 0; i < count; ++i )
            {
                // 파일의 이름을 꺼낸다.
                char name[256] = { 0 };
                DragQueryFile( hDrop, i, name, 256 );

                MessageBox( 0, name, "", MB_OK );
            }
            //DragDrop을 종료한다.
            DragFinish( hDrop );
        }
        return 0;
    case WM_CREATE:
        DragAcceptFiles( hwnd, TRUE );
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HCURSOR    hCursor;
    static HICON    hFill, hEmpty;
    static RECT        rc = { 10, 10, 42, 42 };
    static HINSTANCE hInstance;

    switch( msg )
    {   
    case WM_CREATE:
        hInstance = ((LPCREATESTRUCT)lParam)->hInstance;

        hCursor = LoadCursor( hInstance, MAKEINTRESOURCE(IDC_CURSOR1) );
        hFill    = LoadIcon( hInstance, MAKEINTRESOURCE(IDI_ICON1) );
        hEmpty    = LoadIcon( hInstance, MAKEINTRESOURCE(IDI_ICON2) );

        return 0;

    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );
            DrawIcon( hdc, rc.left, rc.top, hFill );
            EndPaint( hwnd, &ps );
        }
        return 0;
    case WM_LBUTTONDOWN:
        {
            POINT pt = { LOWORD( lParam ), HIWORD( lParam ) };

            if( PtInRect( &rc, pt ) )
            {
                SetCursor( hCursor );
                SetCapture( hwnd );

                HDC hdc = GetDC( hwnd );
                DrawIcon( hdc, rc.left, rc.top, hEmpty );
                ReleaseDC( hwnd, hdc );
            }
        }
        return 0;
    case WM_LBUTTONUP:
        if( GetCapture() == hwnd )
        {
            ReleaseCapture();
            //InvalidateRect( hwnd, &rc, TRUE );
        }
        return 0;

        // 알트탭을 누르면 캡쳐상태가 풀리지만 다시 그리지 못한다. 이를 위해서
        // 캡쳐상태가 변경됬을떄 다시 그려주도록 한다.
    case WM_CAPTURECHANGED:
        {
            InvalidateRect( hwnd, &rc, TRUE );
        }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HBRUSH hBrush = CreateSolidBrush( RGB(255, 0, 0) );
    static HICON hIcon = LoadIcon( GetModuleHandle(0), "aaa" );
    static HINSTANCE hInstance;

    switch( msg )
    {   
    case WM_CREATE:
        {
            // LPARAM에는 CreateWindow에서 사용한 내용이 들어 있다.
            LPCREATESTRUCT p = (LPCREATESTRUCT)lParam;
            hInstance = p->hInstance;
        }
        return 0;

    case WM_LBUTTONDOWN:
        // 실행시간에 ICON을 변경하는 2가지 방법
        // 1. 클래스 자체의 ICON을 변경 - 이 클래스로 만든 모든 윈도우의 ICON 변경.
        SetClassLong( hwnd, GCL_HICON, (LONG)hIcon );
        SetClassLong( hwnd, GCL_HBRBACKGROUND, (LONG)hBrush );
        InvalidateRect( hwnd, 0, TRUE );

        // 2번째 방법 - WM_SETICON 메세지 사용 - 현재 윈도우만 변경.
        SendMessage( hwnd, WM_SETICON, 0, (LPARAM)hIcon );
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {   
    case WM_LBUTTONDOWN:
        SetCapture(hwnd);
        return 0;
    case WM_LBUTTONUP:
        if( GetCapture() == hwnd )
            ReleaseCapture();
        return 0;
    case WM_MOUSEMOVE:
        {
            //POINTS pt = MAKEPOINTS( lParam );
            POINT pt;
            GetCursorPos( &pt );

            HDC scr = CreateDC( "DISPLAY", 0, 0, 0 );
            HDC hdc = GetDC(hwnd);

            StretchBlt( hdc, 0, 0, 500, 500,
                        scr, pt.x, pt.y, 100, 100,
                        SRCCOPY );
           
//            BitBlt( hdc, 0, 0, 500, 500,    // Dest dc
//                scr, 0, 0,                       // Source dc
//                SRCCOPY );                 // Raster Code

            ReleaseDC( hwnd, hdc );
            DeleteDC( scr );
        }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

   // 카드 DLL를 Load 한다.
    HMODULE hDll = LoadLibrary( "Cards.dll" );

    if( hDll == 0 )
    {
        MessageBox( 0, "Dll을 Load 할 수 없습니다.", "", MB_OK );
        return 0;
    }

    // DLL에서 카드 그림을 꺼낸다.
    HBITMAP hBitmap = (HBITMAP)LoadBitmap( hDll, MAKEINTRESOURCE(3) );
    HBRUSH brush = CreatePatternBrush( hBitmap );
    DeleteObject( hBitmap );

    wc.hbrBackground = brush;  //(HBRUSH)GetStockObject( WHITE_BRUSH );

  // 리소스 DLL을 Load해서 필요한 문자열을 얻어온다.
    HMODULE hDll = LoadLibrary("DllResource.dll");
    char buf[256];
    LoadString(hDll, 102, buf, 256);

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HBITMAP hBitmap;
    static int x, y;

    switch( msg )
    {   
    case WM_CREATE:
        {
            // 가상화면을 사용 할 비트맵을 만든다.
            HDC hdc = GetDC( hwnd );
            hBitmap = CreateCompatibleBitmap( hdc, 1280, 1024 );
            ReleaseDC( hwnd, hdc );

            HDC mem = CreateCompatibleDC( 0 );
            HBITMAP old = (HBITMAP)SelectObject( mem, hBitmap );

            // 흰색으로 채워놓는다.
            PatBlt( mem, 0, 0, 1280, 1024, WHITENESS );

            SelectObject( mem, old );
            DeleteObject( mem );
   
            SetTimer( hwnd, 1, 50, 0 );
        }
        return 0;
    case WM_TIMER:
        if ( wParam == 1 )
        {
            if ( GetAsyncKeyState( VK_UP)  < 0 )
            {
                y += 4; InvalidateRect(hwnd, 0, FALSE);
                InvalidateRect(hwnd, 0, FALSE );
            }
            if ( GetAsyncKeyState( VK_DOWN)  < 0 )
            {
                y -= 4; InvalidateRect(hwnd, 0, FALSE);
                InvalidateRect(hwnd, 0, FALSE );
            }
            if ( GetAsyncKeyState( VK_LEFT)  < 0 )
            {
                x += 4; InvalidateRect(hwnd, 0, FALSE);
                InvalidateRect(hwnd, 0, FALSE );
            }       
            if ( GetAsyncKeyState( VK_RIGHT)  < 0 )
            {
                x -= 4; InvalidateRect(hwnd, 0, FALSE);
                InvalidateRect(hwnd, 0, FALSE );
            }
        }
        return 0;
        /*
    case WM_KEYDOWN:
        switch( wParam )
        {
        case VK_UP:            y += 4;        break;
        case VK_DOWN:        y -= 4;        break;
        case VK_LEFT:        x += 4;        break;
        case VK_RIGHT:        x -= 4;        break;
        default:        return 0;
        }
        InvalidateRect( hwnd, 0, FALSE );
        return 0;
        */
    case WM_LBUTTONDOWN:
        {
            POINTS pt = MAKEPOINTS( lParam );

            HDC hdc = GetDC( hwnd );
            Rectangle( hdc, pt.x, pt.y, pt.x + 50, pt.y + 50 );
            ReleaseDC( hwnd, hdc );
            // 다시 그리기 위해 좌표를 저장한다.

            HDC mem = CreateCompatibleDC( 0 );
            HBITMAP old = (HBITMAP)SelectObject( mem, hBitmap );

            Rectangle( mem, pt.x, pt.y, pt.x + 50, pt.y + 50 );

            SelectObject( mem, old );
            DeleteObject( mem );
        }
        return 0;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            // 비트맵을 출력한다.
            HDC mem = CreateCompatibleDC( 0 );
            HBITMAP old = (HBITMAP)SelectObject( mem, hBitmap );

            RECT rc = ps.rcPaint;

            BitBlt( hdc, rc.left, rc.top,
                rc.right - rc.left, rc.bottom - rc.top, mem, rc.left+x, rc.top+y, SRCCOPY );

            SelectObject( mem, old );
            DeleteObject( mem );
            //////////////////////////////////////////////////////////////////////////
            EndPaint( hwnd, &ps );
        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

DialogBox()
{
    EnableWindow( GetParent( hwnd ), FALSE );
    // 실제 DialogBox( MessageBox )를 나타낸다.
    HWND h = CreateWindowEx( 0, "#32770", ... );
    // 그리고 메세지를 처리하기 위해서 자신만의 메세지 루프를 수행한다.
    MSG msg;
    while( GetMessage(&msg) )
    {
        if( msg.message == EndDialog 함수가 넣는 메세지 ) break;
        DispatchMessage( &msg );
    }
    DestroyWindow( h );
    EnableWindow( 부모, TRUE );
    return EndDialog() 의 2번째 인자로 전달된 값.
}

MessageBox()
{
    DialogBox();    // 다시 다이얼로그 박스를 호출...
}

// DIspatchMessage의 대략적인 원리
void DispatchMessage( MSG* pMsg )
{
    // WM_TIMER는 특별하게 처리한다. lParam에는 함수가 있다.
    if( pMsg == WM_TIMER && lParam != 0 )
    {
        TIMEPROC f = (TIMEPROC)lParam;
        f( .... );
    }

    // Dialog 관련 작업 수행..

    // 이제.. pMsg의 HWND를 보고 메세지 처리함수의 주소를 얻어낸다.
    WNDPROC f = (WNDPROC)GetWindowLong( pMsg->hwnd, GWL_WNDPROC );

    // 메세지 처리 함수로 보낸다.
    f( pMsg->hwnd, pMsg->message, pMsg->wParam, pMsg->lParam );
}

#define IDC_BUTTON    1
#define IDC_EDIT    2
#define IDC_LISTBOX    3

int CALLBACK foo(
ENUMLOGFONTEX *lpelfe,    // logical-font data
NEWTEXTMETRICEX *lpntme,  // physical-font data
DWORD FontType,           // type of font
LPARAM lParam             // application-defined data
)
{
    HWND hList = (HWND)lParam;
    SendMessage( hList, LB_ADDSTRING, 0, (LPARAM)lpelfe->elfLogFont.lfFaceName );
    return 1;
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hBtn, hEdit, hList;
    static HBRUSH brush = CreateSolidBrush( RGB(0,255,255) );
    //(HBRUSH)GetStockObject( NULL_BRUSH ); // 투명한 배경을 원할때..

    switch( msg )
    {   
    case WM_COMMAND:
        switch( LOWORD(wParam) )
        {
         case IDC_BUTTON:
            if( HIWORD(wParam) == BN_CLICKED  )
            {
                MessageBox( 0, "click", "", MB_OK );
            }
            break;
        }
        return 0;
        // EditBox가 그려지기 전에 보내는 메세지
   case WM_CTLCOLOREDIT:
        {
            HDC hdc = (HDC)wParam;
            HWND h = (HWND)lParam;

            if( h == hEdit )
            {
                SetTextColor( hdc, RGB(255, 0, 0) );
                SetBkColor( hdc, RGB(0,255,0) );
                return (LRESULT)brush;        // 리턴된 브러쉬로 배경을 채워준다.
            }
        }
        // 처리하지 않은 경우.. 반드시 디폴트로...
        // 디폴트가 기본색상을 채워준다..
        return DefWindowProc( hwnd, msg, wParam, lParam );

    case WM_CREATE:
        hBtn = CreateWindow (
 "button", "Ok", WS_CHILD | WS_VISIBLE | WS_BORDER | BS_AUTOCHECKBOX, 10, 10, 100, 100, hwnd, (HMENU)IDC_BUTTON, GetModuleHandle(0), 0 );
       
        hEdit = CreateWindow (
 "edit", "", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_MULTILINE | WS_VSCROLL | WS_HSCROLL,  210, 10, 100, 100, hwnd, (HMENU)IDC_EDIT, GetModuleHandle(0), 0 );

        // EditBox의 Margin 을 지정한다.
        SendMessage( hEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN,
            MAKELONG( 20, 30 ) );

        hList = CreateWindow( "listbox", "", WS_CHILD | WS_VISIBLE | WS_BORDER,
            410, 10, 100, 100, hwnd, (HMENU)IDC_LISTBOX, GetModuleHandle(0), 0 );

        // 역시 listbox에 항목 추가 메세지를 전달한다.
        SendMessage( hList, LB_ADDSTRING, 0, (LPARAM)"AAA" );
        SendMessage( hList, LB_ADDSTRING, 0, (LPARAM)"BBB" );
        {
            LOGFONT f;
            f.lfCharSet = DEFAULT_CHARSET;
            f.lfFaceName[0] = '\0';

            HDC hdc = GetDC(hwnd);
            EnumFontFamiliesEx( hdc, &f, (FONTENUMPROC)foo, (LPARAM)hList, 0 );

            ReleaseDC( hwnd, hdc );
        }

        // 리턴값, 클래스 이름, 캡션 내용, x좌표, ID 값을 변경하면 됩니다.
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

BOOL PreTranslateMessage( HWND hwnd, MSG *pMsg )
{
    if( pMsg->message == WM_KEYDOWN && pMsg->wParam == 'X' )
    {
        SendMessage( hwnd, WM_CLOSE, 0, 0 );
        return TRUE;    // 메세지를 분배 하지 않는다.
    }
    return FALSE;            // 계속 메세지를 분배한다.
}

int WINAPI _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     LPSTR      lpCmdLine, int nShowCmd )
{
    TCHAR szApp[] = _T("First");

    ATOM atom;
    WNDCLASS wc;
    HWND hwnd;
    MSG msg;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hbrBackground= (HBRUSH)GetStockObject( WHITE_BRUSH );
    wc.hCursor        = LoadCursor( 0, IDC_ARROW );
    wc.hIcon        = LoadIcon( 0, IDI_APPLICATION);
    wc.hInstance    = hInstance;
    wc.lpfnWndProc  = WndProc;
    wc.lpszClassName= szApp;
    wc.lpszMenuName = 0;
    wc.style        = 0;
    atom = RegisterClass( &wc);

    if ( atom == 0 )
    {
        MessageBox( 0, _T("Fail To RegisterClass"), _T("Error"), MB_OK);
        return 0;
    }
    hwnd = CreateWindowEx( 0, szApp, szApp, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, 0, CW_USEDEFAULT,0, 0, 0,
        hInstance, 0);
    ShowWindow( hwnd, nShowCmd);
    UpdateWindow( hwnd );

    while ( GetMessage( &msg, 0, 0, 0) )
    {                           
        //if ( msg.message == WM_KEYDOWN && msg.wParam == 'X' )
        //{
        //    SendMessage( hwnd, WM_CLOSE, 0, 0 );
        //}
        //else
        if( !PreTranslateMessage( hwnd, &msg ) )
        {
            TranslateMessage(&msg);
            DispatchMessage( &msg);
        }
    }
    return 0;
}
//-------------------------------------------------------------------------------
LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hEdit;
    switch( msg )
    {
        // 사용자가 'X' 키보드를 누를때 프로그램을 종료 하는 코드를 만들어 보세요.
        // 종료하는 방법은 "SendMessage( hwnd, WM_CLOSE, 0, 0 )" 으로 하면됩니다.

        //case WM_KEYDOWN:
        //    if( wParam == 'X' ) SendMessage( hwnd, WM_CLOSE, 0, 0 );
        //    return 0;

    case WM_CREATE:
        hEdit = CreateWindow( "edit", "", WS_CHILD | WS_VISIBLE | WS_BORDER,
            10, 10, 300, 300, hwnd, (HMENU)1, GetModuleHandle(0), 0 );
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

#define EM_SETMASK_STRING     WM_USER+999

WNDPROC EditProc;    // 원래의 메세지 처리 함수 주소를 보관할 변수

LRESULT CALLBACK foo( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    static BOOL mask[256] = { TRUE };

    switch( msg )
    {
    case EM_SETMASK_STRING:
        {
            BOOL b = (BOOL)wParam;
            char* p = (char*)lParam;

            for( int i = 0; i < 255; ++i )
            {
                mask[i] = !b;
            }
            for( int i = 0; i < strlen(p); ++i )
            {
                mask[ p[i] ] = b;
            }
        }
        return 0;
    case WM_CHAR:
        if( mask[wParam] )    // 숫자 입력
            break;
        return 0;
    }
    // WM_CHAR를 제외한 모든 메세지와 숫자인 경우는 원래의 함수로 보낸다.
    return CallWindowProc( EditProc, hwnd, msg, wParam, lParam );
    //return EditProc( hwnd, msg, wParam, lParam ); // msdn에서 UNICODE상에서 문제로 금지함..-_-.
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hEdit;

    switch( msg )
    {   
    case WM_CREATE:
        hEdit = CreateWindow( "edit", "", WS_CHILD | WS_VISIBLE | WS_BORDER,
                            10, 10, 200, 200,
                            hwnd, (HMENU)1,
                            GetModuleHandle(0), 0 );

        EditProc = (WNDPROC)SetWindowLong( hEdit, GWL_WNDPROC, (LONG)foo );
        SendMessage( hEdit, EM_SETMASK_STRING, (WPARAM)FALSE, (LPARAM)"ABCDEF");
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

// 자식( 버튼) 이 부모에게 보낼 때 사용할 통지 코드(메세지를 보내는 이유)를 설계
#define BTN_LCLICK    1
#define BTN_RCLICK    2
#define BTN_DISABLED    3
#define BTN_BTN_ENABLED    4

// 부모가 자식(버튼)을 만들어 놓고 보낼 때 사용할 메세지를 설계한다.
// 일반적으로 컨트롤당 수개~수십개가 설계된다.
#define BM_SETTHICK        WM_USER+10
#define BM_SETSTYLE        WM_USER+11

void Draw3dRect(HDC hdc, int x, int y, int xx, int yy, BOOL down, int width );
LRESULT CALLBACK BtnProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static BOOL bDown = FALSE;
    static int width, height;
    static int thick = 2;

    switch( msg )
    {   
        // 부모가 보낸 메세지 처리
    case BM_SETTHICK:
        thick = (int)wParam;    // 두께를 변경한다.
        InvalidateRect( hwnd, 0, FALSE );    // 다시 그린다.
        return 0;

    case WM_SIZE:
        width = LOWORD(lParam);
        height = HIWORD(lParam);
        InvalidateRect( hwnd, 0, TRUE );
        return 0;

    case WM_LBUTTONDOWN:
        bDown = TRUE;
        InvalidateRect( hwnd, 0, FALSE );
        SetCapture( hwnd );
        return 0;
    case WM_LBUTTONUP:
        if( GetCapture() == hwnd )
        {
            ReleaseCapture();

            bDown = FALSE;
            InvalidateRect( hwnd, 0, FALSE );

            // 자신이 눌려 졌다는 사실을 부모에게 알려준다.
            HWND hParent = GetParent( hwnd );    // 부모의 핸들 구하기
            UINT id         = GetDlgCtrlID( hwnd );    // 자신의 ID 구하기

            SendMessage( hParent, WM_COMMAND, MAKELONG( id, BTN_LCLICK ), //하위16:id 상위16:통지
                (LPARAM)hwnd );    // 자신의 핸들
        }
        return 0;

    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            // 이제 자식은 그림을 그리기 전에 DC를 부모에게 전달해서
            // 부모가 색상을 바꿀 수 있는 기회를 제공한다.
            HWND hParent = GetParent( hwnd );
            SendMessage( hParent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hwnd );
            // ------------------------------------------------------------
            // 이제 부모가 변경한 DC를 가지고 그림을 그린다.

            Draw3dRect( hdc, 0, 0, width, height, bDown, thick );
            char title[256];
            GetWindowText( hwnd, title, 256 );    // 부모가 지정한 캡션문자열을 얻는다.
            RECT rc = { 0, 0, width, height };

            if ( bDown == TRUE )        // 버튼이 눌린 경우
                OffsetRect( &rc, thick, thick );
            SetBkMode( hdc, TRANSPARENT );
            DrawText( hdc, title, -1, &rc, DT_SINGLELINE | DT_CENTER | DT_VCENTER );
            EndPaint( hwnd, &ps );
        }
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hBtn;

    switch( msg )
    {   
        // 자식이 자신의 색상을 변경하라고 부모에게 보내주는 메세지
    case WM_CTLCOLORBTN:
        {
            HDC hdc = (HDC)wParam;
            HWND h = (HWND)lParam;

            if( h == hBtn )    // 버튼이 여러 개일 경우.. 원하는 버튼인지 조사
            {
                SetTextColor( hdc, RGB( 255, 0, 0 ) );
                return 0;
            }
        }
        return 0;    //DefWindowProc( hwnd, msg, wParam, lParam );

    case WM_LBUTTONDOWN:
        {
            static int n = 1;
            ++n;
            // 자식(버튼)의 두께를 변경한다.
            SendMessage( hBtn, BM_SETTHICK, n, 0 );
        }
        return 0;

        // 자식(버튼)이 보내는 메세지 처리
    case WM_COMMAND:
        switch( LOWORD( wParam ) )
        {
        case 1:
            if( HIWORD(wParam) == BTN_LCLICK )    //통지 코드 조사
            {
                MessageBox( 0, "Click", "", MB_OK );
            }
            break;
        }
        return 0;
        // 자식( 버튼)이 보내는 메세지 처리
    case WM_CREATE:
        hBtn = CreateWindowEx( 0, "MyButton", "확인", WS_CHILD | WS_VISIBLE | WS_BORDER,
            10, 10, 100, 100, hwnd, (HMENU)1,
            GetModuleHandle(0), 0);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

void Draw3dRect(HDC hdc, int x, int y, int xx, int yy, BOOL down, int width )
{
    COLORREF clrMain  = RGB(192,192,192),
        clrLight = RGB(255,255,255),
        clrDark  = RGB(128,128,128);

    HPEN hPen1, hPen2, hOldPen;
    HBRUSH hBrush, hOldBrush;    

    if(down)   
    {
        hPen2 = CreatePen(PS_SOLID,1,clrLight);
        hPen1 = CreatePen(PS_SOLID,1,clrDark);
    }
    else
    {
        hPen1 = CreatePen(PS_SOLID,1,clrLight);
        hPen2 = CreatePen(PS_SOLID,1,clrDark);
    } 
    hBrush =  CreateSolidBrush( clrMain );
    hOldPen = (HPEN)SelectObject(hdc, hPen1);
    hOldBrush = (HBRUSH)SelectObject(hdc, hBrush); 

    Rectangle(hdc, x , y, xx+1, yy+1); 

    for(int i=0; i < width; i++)
    {
        SelectObject(hdc, hPen1);

        MoveToEx(hdc, xx - 1, y, 0 );
        LineTo(hdc, x, y);
        LineTo(hdc, x, yy - 1 ); 

        SelectObject(hdc, hPen2);

        MoveToEx(hdc, x, yy,0);
        LineTo(hdc, xx, yy);
        LineTo(hdc, xx, y); 

        x++; y++; xx--; yy--;
    }
    SelectObject(hdc, hOldPen);
    SelectObject(hdc, hOldBrush);

    DeleteObject(hPen1);
    DeleteObject(hPen2);
    DeleteObject(hBrush);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static char sz[256] = "10 Seconds";
    switch( msg )
    {   
    case WM_CREATE:
        return 0;

    case WM_LBUTTONDOWN:
        SetTimer( hwnd, 1, 1000, 0 );
        MessageBox( hwnd, sz, "Test", MB_OKCANCEL );    //blocking....
        KillTimer( hwnd, 1 );

        return 0;

    case WM_TIMER:
        {
            HWND hBox = FindWindow( "#32770", "Test" );

            static int c = 10;
            --c;
            wsprintf( sz, "%d Seconds", c );

            // 메세지 박스의 Static Control의 내용을 변경한다.
            SetDlgItemText( hBox, 0x0000FFFF, sz );

            if( c == 0 )
            {
                // MessageBox를 닫는다. - 어떻게..??
                // 결국 MessageBox()는 모달 다이얼로그 이다.
                EndDialog( hBox, IDCANCEL );
            }
        }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
}

// button.cpp
#undef UNICODE
#undef _UNICODE

#define DLL_SOURCE

#include <windows.h>
#include <tchar.h>
#include "button.h"

//////////////////
void Draw3dRect(HDC hdc, int x, int y, int xx, int yy,
                BOOL down, int width )
{
    COLORREF clrMain  = RGB(192,192,192),
        clrLight = RGB(255,255,255),
        clrDark  = RGB(128,128,128);

    HPEN hPen1, hPen2, hOldPen;
    HBRUSH hBrush, hOldBrush;    

    if(down)   
    {
        hPen2 = CreatePen(PS_SOLID,1,clrLight);
        hPen1 = CreatePen(PS_SOLID,1,clrDark);
    }
    else
    {
        hPen1 = CreatePen(PS_SOLID,1,clrLight);
        hPen2 = CreatePen(PS_SOLID,1,clrDark);
    } 
    hBrush =  CreateSolidBrush( clrMain );
    hOldPen = (HPEN)SelectObject(hdc, hPen1);
    hOldBrush = (HBRUSH)SelectObject(hdc, hBrush); 

    Rectangle(hdc, x , y, xx+1, yy+1); 

    for(int i=0; i < width; i++)
    {
        SelectObject(hdc, hPen1);

        MoveToEx(hdc, xx - 1, y, 0 );
        LineTo(hdc, x, y);
        LineTo(hdc, x, yy - 1 ); 

        SelectObject(hdc, hPen2);

        MoveToEx(hdc, x, yy,0);
        LineTo(hdc, xx, yy);
        LineTo(hdc, xx, y); 

        x++; y++; xx--; yy--;
    }
    SelectObject(hdc, hOldPen);
    SelectObject(hdc, hOldBrush);

    DeleteObject(hPen1);
    DeleteObject(hPen2);
    DeleteObject(hBrush);
}

//////////////////////////

LRESULT CALLBACK BtnProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static BOOL bDown = FALSE;
    static int width, height;
    static int thick = 2;

    switch( msg )
    {   
        // 부모가 보낸 메세지 처리
    case BM_SETTHICK:
        thick = (int)wParam;    // 두께를 변경한다.
        InvalidateRect( hwnd, 0, FALSE );    // 다시 그린다.
        return 0;

    case WM_SIZE:
        width = LOWORD(lParam);
        height = HIWORD(lParam);
        InvalidateRect( hwnd, 0, TRUE );
        return 0;

    case WM_LBUTTONDOWN:
        bDown = TRUE;
        InvalidateRect( hwnd, 0, FALSE );
        SetCapture( hwnd );
        return 0;
    case WM_LBUTTONUP:
        if( GetCapture() == hwnd )
        {
            ReleaseCapture();

            bDown = FALSE;
            InvalidateRect( hwnd, 0, FALSE );

            // 자신이 눌려 졌다는 사실을 부모에게 알려준다.
            HWND hParent = GetParent( hwnd );    // 부모의 핸들 구하기
            UINT id         = GetDlgCtrlID( hwnd );    // 자신의 ID 구하기

            SendMessage( hParent, WM_COMMAND, MAKELONG( id, BTN_LCLICK ), //하위16:id 상위16:통지
                (LPARAM)hwnd );    // 자신의 핸들
        }
        return 0;

    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            // 이제 자식은 그림을 그리기 전에 DC를 부모에게 전달해서
            // 부모가 색상을 바꿀 수 있는 기회를 제공한다.
            HWND hParent = GetParent( hwnd );
            SendMessage( hParent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hwnd );
            // ------------------------------------------------------------
            // 이제 부모가 변경한 DC를 가지고 그림을 그린다.

            Draw3dRect( hdc, 0, 0, width, height, bDown, thick );
            char title[256];
            GetWindowText( hwnd, title, 256 );    // 부모가 지정한 캡션문자열을 얻는다.
            RECT rc = { 0, 0, width, height };

            if ( bDown == TRUE )        // 버튼이 눌린 경우
                OffsetRect( &rc, thick, thick );
            SetBkMode( hdc, TRANSPARENT );
            DrawText( hdc, title, -1, &rc, DT_SINGLELINE | DT_CENTER | DT_VCENTER );
            EndPaint( hwnd, &ps );
        }
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

void InitButtonControl()
{
    ATOM atom;
    WNDCLASS wc;

    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hbrBackground= 0;
    wc.hCursor        = LoadCursor( 0, IDC_ARROW );
    wc.hIcon        = 0;//LoadIcon( 0, IDI_APPLICATION);
    wc.hInstance    = GetModuleHandle(0);
    wc.lpfnWndProc  = BtnProc;
    wc.lpszClassName= _T("mybutton");
    wc.lpszMenuName = 0;
    wc.style        = CS_GLOBALCLASS;    // dll 에서 윈도우 클래스를 등록할때 사용!!!
    atom = RegisterClass( &wc);
}

// 모든 DLL은 메모리에 Load될때 아래 함수가 호출된다.
BOOL WINAPI DllMain( HMODULE hDll, DWORD r, LPVOID how )
{
    if( r == DLL_PROCESS_ATTACH )
    {
        InitButtonControl();
    }
    return TRUE;
}

#ifdef DLL_SOURCE
#define DLLAPI    __declspec(dllexport)
#else
#define DLLAPI    __declspec(dllimport)
#endif

// 자식( 버튼) 이 부모에게 보낼 때 사용할 통지 코드(메세지를 보내는 이유)를 설계
#define BTN_LCLICK    1
#define BTN_RCLICK    2
#define BTN_DISABLED    3
#define BTN_BTN_ENABLED    4

// 부모가 자식(버튼)을 만들어 놓고 보낼 때 사용할 메세지를 설계한다.
// 일반적으로 컨트롤당 수개~수십개가 설계된다.
#define BM_SETTHICK        WM_USER+10
#define BM_SETSTYLE        WM_USER+11

#ifdef    __cplusplus
extern "C" {
#endif
    DLLAPI void InitButtonControl();
#ifdef __cplusplus
}
#endif

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hBtn;
    switch( msg )
    {   
    case WM_COMMAND:
        switch( LOWORD( wParam ) )
        {
        case 1:
            if( HIWORD( wParam) == BTN_LCLICK )
                MessageBox( 0, "Click", "", MB_OK );
            break;
        }
        return 0;

    case WM_CREATE:
        InitButtonControl();
        hBtn = CreateWindowEx(
            0, "mybutton", "OK",
            WS_CHILD | WS_VISIBLE | WS_BORDER,
            10, 10, 100, 100, hwnd, (HMENU)1,
            GetModuleHandle(0), 0 );
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static POINTS ptFrom, ptTo;

    switch( msg )
    {   
    case WM_CREATE:

        return 0;
    case WM_LBUTTONDOWN:
        ptFrom = MAKEPOINTS(lParam);
        ptTo   = MAKEPOINTS(lParam);
        {
            HDC hdc = GetDC(hwnd);
            Rectangle( hdc, 100, 100, 200, 200 );
            ReleaseDC(hwnd, hdc);
        }
        SetCapture( hwnd );
        return 0;
    case WM_LBUTTONUP:
        {
            if( GetCapture() == hwnd )
            {
                ReleaseCapture();
                HDC hdc = GetDC(hwnd);
                MoveToEx( hdc, ptFrom.x, ptFrom.y, 0 );
                LineTo( hdc, ptTo.x, ptTo.y );

                ReleaseDC( hwnd, hdc );
            }
        }
        return 0;

    case WM_MOUSEMOVE:
        if( wParam & MK_LBUTTON )
        {
            POINTS pt = MAKEPOINTS(lParam);

            HDC hdc = GetDC( hwnd );
            SetROP2( hdc, R2_NOTXORPEN );    // 그리기 모드를 반전 모드로 만든다.

            MoveToEx( hdc, ptFrom.x, ptFrom.y, 0 );
            LineTo( hdc, ptTo.x, ptTo.y );

            MoveToEx( hdc, ptFrom.x, ptFrom.y, 0 );
            LineTo( hdc, pt.x, pt.y );

            ptTo = pt;

            ReleaseDC( hwnd, hdc );
        }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static char str[] = "Clipping Region Test";
    static HRGN hRgnUp, hRgnDown;
    static int cx, cy;

    switch( msg )
    {   
    case WM_SIZE:
        cx = LOWORD(lParam);
        cy = HIWORD(lParam);
        DeleteObject( hRgnUp );
        DeleteObject( hRgnDown);
        hRgnUp = CreateRectRgn( 0, 0, cx, cy/2 );
        hRgnDown = CreateRectRgn( 0, cy/2, cx, cy );
        return 0;

    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            HFONT hFont = CreateFont(
                72, 0, 0, 0, FW_BOLD, 0, 0, 0, 0,
                0, 0, 0, 0, "Tahoma" );
            HFONT hFontOld = (HFONT)SelectObject( hdc, hFont );
            RECT rc = { 0, 0, cx, cy };

            SetTextColor( hdc, RGB(255, 0, 0) );
            SelectClipRgn( hdc, hRgnUp );
            DrawText( hdc, str, -1, &rc, DT_SINGLELINE | DT_CENTER | DT_VCENTER );

            DeleteObject( SelectObject(hdc, hFontOld) );
            EndPaint( hwnd, &ps );
        }
        return 0;


    case WM_LBUTTONDOWN:
        {
            HDC hdc = GetDC( hwnd );

            HRGN h1 = CreateEllipticRgn( 0, 0, 300, 300 );
            HRGN h2 = CreateRoundRectRgn( 200, 200, 400, 400, 30, 30 );
            HRGN h3 = CreateRectRgn( 0, 0, 0, 0 );
            CombineRgn( h3, h1, h2, RGN_XOR );

            // 영역의 활용 3. DC의 클리핑 영역 제한 - ( 텍스트의 색 부분 바꾸기 )
            char s[] = "asdasdasddddddiijijijioijoioijoijijojojojojoijoj";
            TextOut( hdc, 10, 20, s, strlen(s) );
            SelectClipRgn( hdc, h1 );
            SetTextColor( hdc, RGB(255, 0, 0) );
            TextOut( hdc, 10, 20, s, strlen(s) );

            // 영역의 활용 2. - Hitting Test( Region 영역 클릭 테스트 )
            //POINT pt = { LOWORD(lParam) , HIWORD(lParam) };
            POINTS pt = MAKEPOINTS( lParam );
            if( PtInRegion( h1, pt.x, pt.y ) )
                MessageBox( hwnd, "In Region", "", MB_OK );

            // 영역의 활용 1. - 비정형 윈도우(윈도우창 가리기)
            SetWindowRgn( hwnd, h2, TRUE );

            DeleteObject( SelectObject( hdc, GetStockObject( BLACK_BRUSH ) ) );
            DeleteObject( h1 );
            DeleteObject( h2 );
            DeleteObject( h3 );
            ReleaseDC( hwnd, hdc );

        }
        return 0;

    case WM_DESTROY:
        DeleteObject( hRgnUp );
        DeleteObject( hRgnDown );

        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static vector<POINTS> v;

    switch( msg )
    {
    case WM_MOUSEMOVE:
        {
            POINTS pt = MAKEPOINTS( lParam );
            HDC hdc = GetDC( hwnd );
            Rectangle( hdc, pt.x, pt.y, pt.x + 50, pt.y + 50 );

            v.push_back( pt );
            ReleaseDC( hwnd, hdc );
        }
        return 0;
    case WM_PAINT:
        {
            //HDC hdc = GetDC( hwnd );
            //HideCaret( hwnd );
            // WM_PAINT를 처리 할떄는 반드시 무효화 영역을 유효화 영역으로
            // 변경해야 한다. 즉, QS_PAINT 플래그를 0으로 해야 한다.
            //ValidateRect( hwnd, 0 );
            //ShowCaret( hwnd );
            //ReleaseDC( hwnd, hdc );

            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );
            for( int i = 0; i < v.size(); ++i )
                Rectangle( hdc, v[i].x, v[i].y, v[i].x + 50, v[i].y + 50 );
            EndPaint( hwnd, &ps );
        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

// 화면에 스코어를 그리는 부분을 함수로 만들고 싶다.
// 1. HWND 를 받아서 내부적으로 DC를 구하자. ( BeginPaint, GetDC 문제가 생긴다. )
// 2. HDC를 받아서 바로 사용하자. - OK..
void DrawScore( HDC hdc, int x, int y, int score )
{
    // 여기서 x, y 좌표에 비트맵을 사용 score를 그려준다.
}
//-------------------------------------------------------------------------------
LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static char s[] = "hello";

    switch( msg )
    {
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            for( int i = 0; i < 500; i+=10)
                Rectangle( hdc, i, i, 1000-i, 1000-i );

            TextOut( hdc, 10, 10, s, strlen(s) );
            EndPaint( hwnd, &ps );
        }
        return 0;
    case WM_LBUTTONDOWN:
        {
            // 출력물이 변경되었다. !!!!
            strcpy( s, "xxxxx" );
            // 출력물을 다시 그려야 한다. - 어떻게 ??
            // 1. 강제로 무효화영역을 만들자. - 꼭 필요한 곳을 계산해서 무효화하라.
            // InvalidateRect( hwnd, 0, TRUE );
            //RECT rc = { 10, 10, 100, 40 };
            //InvalidateRect( hwnd, &rc, TRUE );

            // 2. WM_PAINT 가 복잡한 코드가 많다면 성능 저하가 발생할 수도 있다.
            // 간단한 그림은 직접 그리자. - 코드가 중복될 수 있는 단점은 있다.
            HDC hdc = GetDC( hwnd );
            TextOut( hdc, 10, 10, s, strlen(s) );
            ReleaseDC( hwnd, hdc );
        }
        return 0;
    case WM_RBUTTONDOWN:
        {
            strcpy( s, "xxxxx" );
            // 다시 그리기 위해 무효화 영역 발생 메시지Q에 넣어주기만 한다.
            InvalidateRect( hwnd, 0, TRUE );

            // if( msg Q has WM_PAINT ) WndProc( hwnd, WM_PAINT ); 즉시 반영!!
            UpdateWindow( hwnd );
            // 다른 작업을 한다. - 5분 걸린다고 가정.
            for( int i = 0; i < 100000000; ++i );
        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

  case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            Draw3dRect( hdc, 10, 10, 100, 100, TRUE, 5 );

            // 1. GDI Object 생성..
            HPEN hPen = CreatePen( PS_DASH, 5, RGB( 255, 0, 0 ) );
           
            // 2. DC에 선택
            HPEN old_pen = (HPEN)SelectObject( hdc, hPen );

            Rectangle( hdc, 10, 10, 100, 100 );

            // 3. DC에서 선택해지 - 이전의 디폴트 펜을 넣는다.
            // BLACK_PEN 은 Default Object Pen 이다.!!!
            SelectObject( hdc, GetStockObject( BLACK_PEN ) );
            //SelectObject( hdc, old_pen );

            // 4. GDI Object 파괴
            DeleteObject( hPen );

            EndPaint( hwnd, &ps );
        }
        return 0;

void Draw3dRect(HDC hdc, int x, int y, int xx, int yy, BOOL down, int width )
{
    COLORREF clrMain  = RGB(192,192,192),
                clrLight = RGB(255,255,255),
                clrDark  = RGB(128,128,128);

    HPEN hPen1, hPen2, hOldPen;
    HBRUSH hBrush, hOldBrush;    

    if(down)   
    {
        hPen2 = CreatePen(PS_SOLID,1,clrLight);
        hPen1 = CreatePen(PS_SOLID,1,clrDark);
    }
    else
    {
        hPen1 = CreatePen(PS_SOLID,1,clrLight);
        hPen2 = CreatePen(PS_SOLID,1,clrDark);
    } 
    hBrush =  CreateSolidBrush( clrMain );
    hOldPen = (HPEN)SelectObject(hdc, hPen1);
    hOldBrush = (HBRUSH)SelectObject(hdc, hBrush); 

    Rectangle(hdc, x , y, xx+1, yy+1); 

    for(int i=0; i < width; i++)
    {
        SelectObject(hdc, hPen1);

        MoveToEx(hdc, xx - 1, y, 0 );
        LineTo(hdc, x, y);
        LineTo(hdc, x, yy - 1 ); 

        SelectObject(hdc, hPen2);

        MoveToEx(hdc, x, yy,0);
        LineTo(hdc, xx, yy);
        LineTo(hdc, xx, y); 

        x++; y++; xx--; yy--;
    }
    SelectObject(hdc, hOldPen);
    SelectObject(hdc, hOldBrush);

    DeleteObject(hPen1);
    DeleteObject(hPen2);
    DeleteObject(hBrush);
}

#define ORG_X        12
#define ORG_Y        55
#define BLOCKSIZE    16

void DrawBlock( HDC hdc, int x, int y )
{
    Draw3dRect( hdc, ORG_X + x * BLOCKSIZE , ORG_Y + y * BLOCKSIZE,
                     ORG_X + (x+1) * BLOCKSIZE -1 , ORG_Y + (y+1) * BLOCKSIZE -1,
                     FALSE, 2);
}

enum STATE { EMPTY = 0, ONE = 1, TWO = 2, EIGHT = 8, BOMB = 99 };

struct BLOCK
{
    STATE state;
    int isOpen;
};

#define CLOSE 0
#define OPEN 1
#define FLAG 2

BLOCK board[9][9];

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {   
    case WM_LBUTTONDOWN:
        {
            int i = 0, j = 0;
            // lParam 에서 x, y를 구한다.
            // 몇번째 블록인지 구한다. i, j

            if( board[i][j].state == BOMB ) { /* 꽝 */ };
            if( board[i][j].isOpen == FLAG | OPEN ) return 0;
            if( board[i][j].state  == EMPTY )
            {
                // 주변을 열어 준다.
            }
            else
            {
                board[i][j].isOpen = OPEN;
                // 해당 블록의 크기를 정확히 구해서.. 무효화 한뒤에
                // WM_PAINT가 다시 그리게 한다.
            }
        }
    case WM_PAINT:
        {
            int i, j;

            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            Draw3dRect( hdc, 0,   0,  168, 211, FALSE, 3 );
            Draw3dRect( hdc, 9,   9,  159, 46,  TRUE,  2 );
            Draw3dRect( hdc, 15,  14, 57,  40,  TRUE,  1 );
            Draw3dRect( hdc, 109, 14, 150, 40,  TRUE,  1 );
            Draw3dRect( hdc, 9,   52, 159, 202, TRUE,  3 );

            for ( i = 0; i < 9; ++i )
            {
                for ( j = 0; j < 9; ++j )
                {
                    if( board[i][j].isOpen == CLOSE )
                        DrawBlock(hdc,  i, j );
                    else if( FLAG )
                    {
                        // 블록을 그리고 깃발을 그린다.
                    }
                    else
                    {
                        //board[i][j] 가 가지고 있는 숫자를 출력
                        //비트맵 사용
                    }
                }
            }
            EndPaint( hwnd, &ps );
        }
        return 0;

   
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            Draw3dRect( hdc, 10, 10, 100, 100, TRUE, 5 );

            // 1. GDI Object 생성..
            HPEN hPen = CreatePen( PS_DASH, 5, RGB( 255, 0, 0 ) );
           
            // 2. DC에 선택
            HPEN old_pen = (HPEN)SelectObject( hdc, hPen );

            Rectangle( hdc, 10, 10, 100, 100 );

            // 3. DC에서 선택해지 - 이전의 디폴트 펜을 넣는다.
            // BLACK_PEN 은 Default Object Pen 이다.!!!
            SelectObject( hdc, GetStockObject( BLACK_PEN ) );
            //SelectObject( hdc, old_pen );

            // 4. GDI Object 파괴
            DeleteObject( hPen );

            EndPaint( hwnd, &ps );
        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}