root/lang/objective-cplusplus/i3/trunk/tmp/dwmedit/BlurEditController.cc @ 39069

#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <usp10.h>
#include <utility>

#include "ApiHook.h"
#include "WindowsVersionHelp.h"

#ifdef _MSC_VER
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "dbghelp.lib")
#pragma comment(lib, "dwmapi.lib")
#pragma comment(lib, "uxtheme.lib")
#endif

using namespace api_hook;

struct BlurEditController;
extern BlurEditController self;
struct BlurEditController {
    LONG paint_enable; // thread guard
    bool auto_paint_ignored; // raw
    DWORD thread_id; // raw

    WNDPROC DefaultWindowProceduer;
    bool capture;
    bool focus;
    HBRUSH black_brush;
    BLENDFUNCTION blend_function;
    BP_PAINTPARAMS bp_paintparams;

    class PaintEnable {
        const LONG saved_paint_enable;
        PaintEnable& operator=(const PaintEnable& that);
    public:
        PaintEnable() : saved_paint_enable(InterlockedExchange(&self.paint_enable, 1)) {
        }
        ~PaintEnable() {
            InterlockedExchange(&self.paint_enable, saved_paint_enable);
        }
    };

    static bool isPaintEnable() {
        LONG paint_enable = InterlockedExchangeAdd(&self.paint_enable, 0);
        if (paint_enable || self.thread_id != GetCurrentThreadId()) {
            return true;
        }
        return false;
    }

    struct O {
        FARPROC (WINAPI *GetProcAddress)(HINSTANCE, const CHAR*);
        // decltype(&GetProcAddress) GetProcAddress;
        BOOL (WINAPI *ExtTextOutW)(HDC, int, int, UINT, const RECT*, const WCHAR*, UINT, const INT*);
        // decltype(&ExtTextOutW) ExtTextOutW;
        HRESULT (WINAPI *DrawThemeBackground)(void*, HDC, int, int, const RECT*, const RECT*);
        // decltype(&DrawThemeBackground) DrawThemeBackground;
    } o;

    struct H {
        static HRESULT WINAPI DrawThemeBackground(HTHEME a, HDC b, int c, int d,
            const RECT * e, const RECT * f) {
            if (isPaintEnable()) {
                return self.o.DrawThemeBackground(a, b, c, d, e, f);
            }
            self.auto_paint_ignored = true;
            return  S_OK;
        }
        static FARPROC WINAPI GetProcAddress(HMODULE hModule, LPCSTR lpProcName) {
            if (lstrcmpA(lpProcName, "DrawThemeBackground") == 0) {
                return (FARPROC)H::DrawThemeBackground;
            }
            return self.o.GetProcAddress(hModule, lpProcName);
        }
        static BOOL WINAPI ExtTextOutW(HDC hdc, int x, int y, UINT fuOptions, CONST RECT *lprc,
            LPCTSTR lpString, UINT cbCount, CONST INT *lpDx) {

            if (isPaintEnable()) {
                return self.o.ExtTextOutW(hdc, x, y, fuOptions, lprc, lpString, cbCount, lpDx); 
            }

            // ����PI�Ăяo�����E�N���b�N���j���[�`�����߂̂����𔻕�
            // TODO ���Ə�����            static int x_ = 0;
            static int y_ = 0;
            static UINT fuOptions_ = 0;
            static UINT cbCount_ = 0;
            bool match = (x_ == x && y_ == y && fuOptions_ == fuOptions && cbCount_ == cbCount);
            x_ = x;
            y_ = y;
            fuOptions_ = fuOptions;
            cbCount_ = cbCount;

            DWORD objectType = GetObjectType(hdc);
            if (objectType != OBJ_DC || !match) {
                // �E�N���b�N���j���[�̕`���ꍇ
                return self.o.ExtTextOutW(hdc, x, y, fuOptions, lprc, lpString, cbCount, lpDx);
            }

            self.auto_paint_ignored = true;
            return TRUE;
        }
    };

    BlurEditController() {
        o = O();
        capture = false;
        focus = false;
        paint_enable = 0;
        auto_paint_ignored = false;

        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;

        thread_id = GetCurrentThreadId();

        dll.init();

        if (!dll.ImageDirectoryEntryToData) {
            return;
        }

        o.GetProcAddress = (decltype(&H::GetProcAddress))GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetProcAddress");
        if (!o.GetProcAddress) {
            return;
        }

        o.DrawThemeBackground = (decltype(&H::DrawThemeBackground))GetProcAddress(GetModuleHandleA("uxtheme.dll"), "DrawThemeBackground");
        if (!o.DrawThemeBackground) {
            return;
        }

        o.ExtTextOutW = (decltype(&H::ExtTextOutW))GetProcAddress(GetModuleHandleA("gdi32.dll"), "ExtTextOutW");
        if (!o.ExtTextOutW) {
            return;
        }

        //ReplaceIATEntryInAllMods("gdi32.dll", o.ExtTextOutW, H::ExtTextOutW);
        ReplaceIATEntryInOneMod("gdi32.dll", o.ExtTextOutW, H::ExtTextOutW, GetModuleHandle(_T("usp10.dll")));
        ReplaceIATEntryInOneMod("kernel32.dll", o.GetProcAddress, H::GetProcAddress, GetModuleHandle(_T("comctl32.dll")));
    }

    bool hook(HWND hEdit) {
        if (!dll.BeginBufferedPaint) {
            return false;
        }
        self.DefaultWindowProceduer = (WNDPROC)GetWindowLongPtr(hEdit, GWLP_WNDPROC);
        SetWindowLongPtr(hEdit, GWLP_WNDPROC, (LONG_PTR)BlurEditController::WndProc);
        return true;
    }

    /**
     * �����ςȐݒ��`�悳�����܂����߁A������������
     * �ŁA���ꂪ�������ꂽ�ꍇ�ɐ������ݒ��ĕ`�悷��     */
    static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
        (void)static_cast<WNDPROC>(WndProc);

        bool redraw = false;

        if (message == WM_PAINT) {
            BYTE alpha = 0;
            if (self.focus) {
                alpha = 0xff;
            } else if (self.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) {
                // fatal error
                EndPaint(hWnd, &ps);
                return CallWindowProc(self.DefaultWindowProceduer, hWnd, message, wParam, lParam);
            }

            if (alpha == 255) {
                // �s�����̏ꍇ
                {
                    PaintEnable paintEnable;
                    CallWindowProc(self.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����                self.blend_function.SourceConstantAlpha = alpha;

                HDC mem_dc2 = 0;
                HPAINTBUFFER paint_buffer2 = dll.BeginBufferedPaint(mem_dc1, &ps.rcPaint, BPBF_TOPDOWNDIB, &self.bp_paintparams, &mem_dc2);
                if (paint_buffer2 == 0) {
                    // fatal error
                    dll.EndBufferedPaint(paint_buffer1, FALSE);
                    EndPaint(hWnd, &ps);
                    return CallWindowProc(self.DefaultWindowProceduer, hWnd, message, wParam, lParam);
                }

                {
                    PaintEnable paintEnable;
                    CallWindowProc(self.DefaultWindowProceduer, hWnd, WM_PRINTCLIENT, (WPARAM)mem_dc2, PRF_CLIENT);
                }

                dll.BufferedPaintSetAlpha(paint_buffer2, 0, 255);
                FillRect(mem_dc1, &ps.rcPaint, self.black_brush);
                dll.EndBufferedPaint(paint_buffer2, TRUE);
            }

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

        //if (message == WM_ERASEBKGND) {
        //    return 0;
        //}

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

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

        if (message == WM_CAPTURECHANGED) {
            if ((HWND)lParam != hWnd && self.capture) {
                ReleaseCapture();
                self.capture = false;
                redraw = 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 (self.capture) {
                        ReleaseCapture();
                        self.capture = false;
                        redraw = true;
                    }

            } else {
                // �J�[�\�����E�B���h�E������                if (!self.capture) {
                    SetCapture(hWnd);
                    self.capture = true;
                    redraw = true;
                }
            }
        }

        {
            LRESULT l = CallWindowProc(self.DefaultWindowProceduer, hWnd, message, wParam, lParam);

            if (redraw || self.auto_paint_ignored) {
                self.auto_paint_ignored = false;
                InvalidateRect(hWnd, NULL, FALSE);
                // WndProc(hWnd, WM_PAINT, 0, 0);
            }

            return l;
        }
    }
} self;

bool BlurEditControllerHook(HWND hEdit) {
    return self.hook(hEdit);
}