root/lang/objective-cplusplus/i3/trunk/tmp/dwmtest.cpp @ 38374

#include <windows.h>
#include <windowsx.h>
#include <tchar.h>
#include <uxtheme.h>
#include <dwmapi.h>
#include <assert.h>
#include <richedit.h>

struct Dll {
    decltype(&DwmExtendFrameIntoClientArea) DwmExtendFrameIntoClientArea;
    decltype(&DwmIsCompositionEnabled) DwmIsCompositionEnabled;
    decltype(&DwmEnableBlurBehindWindow) DwmEnableBlurBehindWindow;
    decltype(&DwmGetColorizationColor) DwmGetColorizationColor;
    decltype(&DwmGetWindowAttribute) DwmGetWindowAttribute;
    decltype(&BeginBufferedPaint) BeginBufferedPaint;
    decltype(&BufferedPaintInit) BufferedPaintInit;
    decltype(&BufferedPaintUnInit) BufferedPaintUnInit;
    decltype(&EndBufferedPaint) EndBufferedPaint;
    decltype(&BufferedPaintSetAlpha) BufferedPaintSetAlpha;
} dll = {};


struct BlurStatus {
        BlurStatus() : 
                capture(false),
                focus(false),
                dc_width_max(0),
                dc_width(0),
                dc_height_max(0),
                dc_height(0),
                dc_changed(false),
                dc1(NULL),
                dc2(NULL)
        {
                black_brush = (HBRUSH)GetStockObject(BLACK_BRUSH);

        blend_function.BlendOp = AC_SRC_OVER;
        blend_function.BlendFlags = 0;
        blend_function.AlphaFormat = 0; //AC_SRC_ALPHA
        blend_function.SourceConstantAlpha = 255;

        bp_paintparams.cbSize = sizeof(bp_paintparams);
        bp_paintparams.dwFlags = 0;
        bp_paintparams.prcExclude = NULL;
        bp_paintparams.pBlendFunction = &blend_function;
        }
        WNDPROC DefaultWindowProceduer;
        bool capture;
        bool focus;
        HBRUSH black_brush;
        int dc_width_max;
        int dc_height_max;
        int dc_width;
        int dc_height;
        bool dc_changed;
        HDC dc1;
        HDC dc2;
        BLENDFUNCTION blend_function;
        BP_PAINTPARAMS bp_paintparams;
} blur;

LRESULT CALLBACK BlurEditWndProc(
    HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {

    WNDPROC wp = BlurEditWndProc;
    (void)wp;
    bool redraw = false;

        if (message == WM_SETFOCUS) {
                blur.focus = true;
                                redraw = true;
    }

    if (message == WM_KILLFOCUS) {
                blur.focus = false;
                redraw = true;
    }

    if (message == WM_LBUTTONDOWN) {
                redraw = true;
    }

    if (message == WM_LBUTTONDBLCLK) {
                redraw = true;
    }

    if (message == WM_CAPTURECHANGED) {
                if ((HWND)lParam != hWnd && blur.capture) {
            ReleaseCapture();
                        blur.capture = false;
                redraw = true;
        }
    }

        if (message == WM_SIZE) {
                blur.dc_width = LOWORD(lParam);
                blur.dc_height = HIWORD(lParam);
                blur.dc_changed = true;
        }

        if (message == WM_WINDOWPOSCHANGED || message == WM_WINDOWPOSCHANGING) {
                const WINDOWPOS* pos = (WINDOWPOS*)lParam;
                if (!(pos->flags & SWP_NOSIZE)) {
                        blur.dc_width = pos->cx;
                        blur.dc_height = pos->cy;
                        blur.dc_changed = true;
                }
        }

    if (message == WM_MOUSEMOVE) {
        // �}�E�X���E�B���h�E�����݂��邩�`�F�b�N
        RECT rect = {};
        POINT p = {};
        p.x = GET_X_LPARAM(lParam);
        p.y = GET_Y_LPARAM(lParam);
        if (!(wParam & MK_LBUTTON) && 
            (p.x < 0 ||
            p.y < 0 ||
            !GetWindowRect(hWnd, &rect) ||
            p.x >= (rect.right - rect.left) ||
            p.y >= (rect.bottom - rect.top)
            )) {
            // �f�[�^�擾���s���A�J�[�\�����E�B���h�E�O�ɂ���                      if (blur.capture) {
                ReleaseCapture();
                                blur.capture = false;
                redraw = true;
            }
        } else {
            // �J�[�\�����E�B���h�E������                       if (!blur.capture) {
                SetCapture(hWnd);
                                blur.capture = true;
                redraw = true;
            }
        }

        if (wParam & MK_LBUTTON) {
            redraw = true;
        }
    }
        

    if (message == WM_PAINT) {
                BYTE alpha = 0;
                if (blur.focus) {
            alpha = 0xff;
                } else if (blur.capture) {
            alpha = 0xbb;
        } else {
            alpha = 0x88;
        }

        PAINTSTRUCT ps = {};
        HDC hdc = BeginPaint(hWnd, &ps);
        HDC mem_dc1 = NULL;
        HPAINTBUFFER paint_buffer1 = dll.BeginBufferedPaint(hdc, &ps.rcPaint, BPBF_TOPDOWNDIB, NULL, &mem_dc1);
        if (paint_buffer1 == 0) {
            EndPaint(hWnd, &ps);
                        return CallWindowProc(blur.DefaultWindowProceduer, hWnd, message, wParam, lParam);
        }

        if (alpha == 255) {
            // �s�����̏ꍇ
                        CallWindowProc(blur.DefaultWindowProceduer, hWnd, WM_PRINTCLIENT, (WPARAM)mem_dc1, PRF_CLIENT);
            dll.BufferedPaintSetAlpha(paint_buffer1, 0, 255);
        } else {
            // �����̏ꍇ�A�������f�o�C�X�R���e�L�X�g��������ăA���t�@�u�����h����                  blur.blend_function.SourceConstantAlpha = alpha;

            HDC mem_dc2 = 0;
                        HPAINTBUFFER paint_buffer2 = dll.BeginBufferedPaint(mem_dc1, &ps.rcPaint, BPBF_TOPDOWNDIB, &blur.bp_paintparams, &mem_dc2);
            if (paint_buffer2 == 0) {
                dll.EndBufferedPaint(paint_buffer1, FALSE);
                EndPaint(hWnd, &ps);
                                return CallWindowProc(blur.DefaultWindowProceduer, hWnd, message, wParam, lParam);
            }
                        CallWindowProc(blur.DefaultWindowProceduer, hWnd, WM_PRINTCLIENT, (WPARAM)mem_dc2, PRF_CLIENT);
            dll.BufferedPaintSetAlpha(paint_buffer2, 0, 255);
            FillRect(mem_dc1, &ps.rcPaint, blur.black_brush);
            dll.EndBufferedPaint(paint_buffer2, TRUE);
        }

        dll.EndBufferedPaint(paint_buffer1, TRUE);
        EndPaint(hWnd, &ps);
        return 0;
    }

        if (message == WM_IME_NOTIFY) {
                redraw = true;
        }

        {
                LRESULT l = CallWindowProc(blur.DefaultWindowProceduer, hWnd, message, wParam, lParam);
                if (redraw) {
                        InvalidateRect(hWnd, NULL, FALSE);
                        //BlurEditWndProc(hWnd, WM_PAINT, 0, 0);
                }
                return l;
        }
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
    WNDPROC wp = WndProc;
    (void)wp;

    if (message == WM_COMMAND) {
        int wID = LOWORD(wParam);
        int wNotifyCode = HIWORD(wParam);
        HWND hwndControl =  (HWND)lParam;
        if (hwndControl == (HWND)GetProp(hWnd, _T("my editbox"))) {
            if (wNotifyCode == EN_UPDATE) {
                InvalidateRect(hwndControl, 0, FALSE);
            }
        }
    }

    if (message == WM_DESTROY) {
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hWnd, message, wParam, lParam);
}

#define SET_DLL_ADDRESS(module, name)                                   \
    {                                                                   \
        dll.name = (decltype(&name))GetProcAddress(module, #name);      \
    }

int APIENTRY _tWinMain(HINSTANCE hInstance,
                       HINSTANCE hPrevInstance,
                       LPTSTR    lpCmdLine,
                       int       nCmdShow) {
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    assert(LoadLibrary(_T("msftedit.dll")));
    assert(LoadLibrary(_T("riched20.dll")));
    assert(LoadLibrary(_T("riched32.dll")));

    HMODULE dwmapi_dll = LoadLibrary(_T("dwmapi.dll"));
    assert(dwmapi_dll);

    SET_DLL_ADDRESS(dwmapi_dll, DwmExtendFrameIntoClientArea);
    SET_DLL_ADDRESS(dwmapi_dll, DwmIsCompositionEnabled);
    SET_DLL_ADDRESS(dwmapi_dll, DwmEnableBlurBehindWindow);
    SET_DLL_ADDRESS(dwmapi_dll, DwmGetColorizationColor);
    SET_DLL_ADDRESS(dwmapi_dll, DwmGetWindowAttribute);

    HMODULE uxtheme_dll = LoadLibrary(_T("uxtheme.dll"));
    assert(uxtheme_dll);
    SET_DLL_ADDRESS(uxtheme_dll, BeginBufferedPaint);
    SET_DLL_ADDRESS(uxtheme_dll, BufferedPaintInit);
    SET_DLL_ADDRESS(uxtheme_dll, BufferedPaintUnInit);
    SET_DLL_ADDRESS(uxtheme_dll, EndBufferedPaint);
    SET_DLL_ADDRESS(uxtheme_dll, BufferedPaintSetAlpha);

    assert(dll.BufferedPaintInit() == S_OK);

    MSG msg = {};
    TCHAR szWindowClass[] = _T("hoge");

    WNDCLASS wc = {};
    wc.style            = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc      = WndProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = hInstance;
    wc.hIcon            = NULL;
    wc.hCursor          = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground    = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wc.lpszMenuName     = NULL;
    wc.lpszClassName    = szWindowClass;

    assert(RegisterClass(&wc));

    TCHAR szTitle[] = _T("hige");
    DWORD style = WS_OVERLAPPEDWINDOW;

    RECT r;
    r.top = 0;
    r.left = 0;
    r.right = 300;
    r.bottom = 300;
    assert(AdjustWindowRectEx(&r, style, FALSE, 0));

    HWND hWnd = CreateWindow(
        szWindowClass, szTitle, style,
        50, 50, r.right - r.left, r.bottom - r.top,
        NULL, NULL, hInstance, NULL);
    assert(hWnd);

    DWM_BLURBEHIND bb  = {};
    bb.dwFlags = DWM_BB_ENABLE;
    bb.fEnable = TRUE;
    assert(dll.DwmEnableBlurBehindWindow(hWnd, &bb) == S_OK);

    MARGINS margins = {};
        margins.cxLeftWidth = 50;
        margins.cxRightWidth = 50;
        margins.cyBottomHeight = 100;
        margins.cyTopHeight = 100;

    assert(dll.DwmExtendFrameIntoClientArea(hWnd, &margins) == S_OK);

    HWND hEdit = CreateWindow( 
        _T("EDIT"),
        _T("hage"),
        WS_CHILD | WS_VISIBLE /*| WS_BORDER */,
        50,
        100,
        200,
        100,
        hWnd,
        NULL,
        hInstance,
        NULL);

    assert(hEdit);
    assert(SetProp(hWnd, _T("my editbox"), (HANDLE)hEdit) != 0);

    //HANDLE wp = (HANDLE)GetWindowLongPtr(hEdit, GWLP_WNDPROC);
    //assert(SetProp(hEdit, _T("my default wndproc"), wp) != 0);

        blur.DefaultWindowProceduer = (WNDPROC)GetWindowLongPtr(hEdit, GWLP_WNDPROC);
    SetWindowLong(hEdit, GWLP_WNDPROC, (LONG_PTR)BlurEditWndProc);
    
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int) msg.wParam;
}