root/lang/objective-cplusplus/i3/trunk/src/gui-windows/InputWindowPlatform.cpp @ 36372

Revision 36372, 27.4 kB (checked in by saturday06, 5 years ago)

oaaaaa

Line 
1#include <PrecompiledHeaders.h>
2#include "Mediator.h"
3#include "InputWindowPlatform.h"
4#include "InputWindow.h"
5#include "ShellManager.h"
6
7#define I3_EVENT_HANDLER(receiver_class, event_class)                   \
8    template <>                                                         \
9    void receiver_class::execute_hook_(event_class& event) {            \
10        debug << "r=" << #receiver_class << ", e=" << #event_class;     \
11    }                                                                   \
12    template <>                                                         \
13    void receiver_class::execute(event_class& event)
14
15namespace i3 {
16
17static WNDPROC EditDefaultWndProc = NULL;
18static LRESULT CALLBACK EditWndProc2(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
19    static int alpha = 255;
20
21        if (message == WM_ERASEBKGND) {
22                PAINTSTRUCT ps;
23                HDC hdc = BeginPaint(hWnd, &ps);
24                FillRect(ps.hdc, &ps.rcPaint, (HBRUSH)GetStockObject(BLACK_BRUSH));
25                EndPaint(hWnd, &ps);
26        }
27
28        if (message == WM_KILLFOCUS) {
29        alpha = 200;
30                InvalidateRect(hWnd, 0, FALSE);
31        }
32
33        if (message == WM_SETFOCUS) {
34        alpha = 255;
35                InvalidateRect(hWnd, 0, FALSE);
36        }
37
38    if (message == WM_MOUSEMOVE) {
39        if (alpha < 230) {
40            alpha = 230;
41        }
42    }
43
44    if (message == WM_PAINT) {
45        PAINTSTRUCT ps;
46        HDC hdc = BeginPaint(hWnd, &ps);
47                FillRect(ps.hdc, &ps.rcPaint, (HBRUSH)GetStockObject(BLACK_BRUSH));
48
49                BLENDFUNCTION bf = {};
50                bf.BlendOp = AC_SRC_OVER;
51                bf.BlendFlags = 0;
52        bf.SourceConstantAlpha = alpha;
53                bf.AlphaFormat = 0;//AC_SRC_ALPHA;
54        BP_PAINTPARAMS m_PaintParams = {
55                        sizeof(BP_PAINTPARAMS),
56                        0, //BPPF_ERASE,
57                        NULL,
58                        &bf
59                };
60        HDC mem_dc = 0;
61        HPAINTBUFFER paint_buffer =
62                        dll.dll_BeginBufferedPaint(hdc, &ps.rcPaint, BPBF_TOPDOWNDIB, &m_PaintParams, &mem_dc);
63                if (paint_buffer == 0) {
64                    EndPaint(hWnd, &ps);
65                        return CallWindowProc(EditDefaultWndProc, hWnd, message, wParam, lParam);
66                }
67
68                // EditDefaultWndProc(hWnd, message, (WPARAM)mem_dc, lParam);
69                CallWindowProc(EditDefaultWndProc, hWnd, WM_PRINTCLIENT, (WPARAM)mem_dc, PRF_CLIENT);
70                // CallWindowProc(EditDefaultWndProc, hWnd, WM_PRINTCLIENT, (WPARAM)hdc, PRF_CLIENT);
71        dll.dll_BufferedPaintSetAlpha(paint_buffer, 0, 255);  //�s����
72        dll.dll_EndBufferedPaint(paint_buffer, TRUE);
73                EndPaint(hWnd, &ps);
74
75        return 0;
76    }
77
78    return CallWindowProc(EditDefaultWndProc, hWnd, message, wParam, lParam);
79}
80
81
82
83using namespace mil;
84
85struct ExecuteEvent {
86    TCHAR* command;
87};
88
89#ifdef I3_TEST
90template <>
91void ShellManager::beforeExecute(ExecuteEvent& e) {
92        if (tester.getName() == "simple input") {
93                QT_CHECK(i3::string(e.command) == _T("foo"));
94                tester.pass();
95        }
96}
97#endif
98
99template <>
100void ShellManager::execute(ExecuteEvent& e) {
101
102#ifdef _UNICODE
103    UTF16LE_TO_UTF8_ALLOCA(e.command, data8);
104#else
105    const char* data8 = e.command;
106#endif
107
108    pty.write(data8);
109    pty.write("\n");
110
111    tfree(e.command);
112}
113
114template <>
115void Delegate::execute(ExecuteEvent& e) {
116    if (_tcscmp(e.command, _T("hello")) == 0) {
117        alert(_("Hello, world!"));
118        tfree(e.command);
119        return;
120    } else if (_tcscmp(e.command, _T("exit")) == 0) {
121                ShowWindow(mediator.getInputWindow().window.load(), SW_HIDE);
122        ExitEvent ex;
123        mediator.getInputWindow().post(ex, *this);
124        tfree(e.command);
125        return;
126    }
127
128    mediator.getShellManager().post(e, *this);
129    //HINSTANCE ins = ShellExecute(
130    //    NULL,       // �e�E�B���h�E�̃n���h��
131    //    _T("open"), // ����    //    e.command,  // �����ۂ̃t�@�C��
132    //    NULL,       // �����p�����[�^
133    //    NULL,       // ���f�B���N�g��
134    //    SW_SHOW     // �\����
135    //    );
136
137    //if ((INT)ins <= 32) {
138    //    alert(_T("execute failure"));
139    //}
140}
141
142struct LazyEditFocusEvent {};
143
144template <>
145void InputWindow::execute(LazyEditFocusEvent&) {
146    SetFocus(edit);
147}
148
149struct EditChangedEvent {
150    int serial;
151};
152
153//template <>
154//void Delegate::execute(EditChangedEvent& e) {
155
156I3_EVENT_HANDLER(Delegate, EditChangedEvent) {
157    //MessageBox(NULL, data, data, MB_OK);
158
159    //TCHAR data[STACKABLE_MAX_PATH] = {};
160    ///int result = GetWindowText(e.edit, data, _countof(data));
161    std::vector<TCHAR> data;
162    getChild().mediator.getInputWindow().read(data);
163
164    if (!data[0]) {
165                return;
166        }
167
168        HICON new_icon = NULL;
169
170    SHFILEINFO sfi = {};
171    DWORD_PTR dwptr = SHGetFileInfo(&data[0], 0, &sfi,
172                                    sizeof(sfi), SHGFI_ICON /* | SHGFI_SMALLICON */ /* | SHGFI_ADDOVERLAYS */ );
173    if (dwptr) { // ok
174        new_icon = sfi.hIcon;
175    }
176
177    BOOST_STATIC_ASSERT(sizeof(HICON) == sizeof(DWORD_PTR));
178
179    HICON old = getChild().mediator.getInputWindow().icon.exchange(new_icon);
180    if (old) {
181        DestroyIcon(old);
182    }
183    HWND hWnd = getChild().mediator.getInputWindow().getWindow();
184    RECT r = {0, 0, 30, 30};
185    //RedrawWindow(hWnd, &r, NULL, RDW_INTERNALPAINT); // should rewrite using postmessage
186    InvalidateRect(hWnd, &r, TRUE);
187    UpdateWindow(hWnd);
188}
189
190template <>
191InputWindowPlatform<InputWindow>::InputWindowPlatform() :
192        icon(NULL),
193        edit(NULL),
194        riched20_dll(NULL) {
195
196    const int ICON_SIZE = 32;
197    //const int ICON_SIZE = 32;
198
199    memset((void*)&layout, 0, sizeof(layout));
200    memset((void*)&ce, 0, sizeof(ce));
201        memset((void*)&notify_icon, 0, sizeof(notify_icon));
202    is_dwm_extend_frame_into_client_area = 0;
203
204    layout.icon.padding.left = 2;
205    layout.icon.padding.right = 3;
206    layout.icon.width = ICON_SIZE + layout.icon.padding.right + layout.icon.padding.left;
207    layout.icon.height = ICON_SIZE + layout.icon.padding.top + layout.icon.padding.bottom;
208    layout.window.padding.right = 5;
209    layout.window.width = 200;
210
211#ifdef _WIN32_WCE
212    layout.window.padding.top = 1;
213    layout.window.padding.bottom = 1;
214    layout.window.padding.left = 1;
215#endif
216
217    local_icon = LoadIcon(i3::hInstance, _T("IDI_ICON1"));
218        icon.store(LoadIcon(i3::hInstance, _T("IDI_ICON1")));
219}
220
221template <>
222UINT InputWindowPlatform<InputWindow>::OnNCHitTest(HWND hWnd, int x, int y) {
223    POINT p = POINT();
224    p.x = x;
225    p.y = y;
226    if (!ScreenToClient(hWnd, &p)) {
227        return HTCAPTION;
228    }
229
230    if (p.x > layout.window.width - layout.window.padding.right - layout.edit.padding.right) {
231        return HTRIGHT;
232    }
233
234    return HTCAPTION;
235}
236
237#ifdef _WIN32_WCE
238template <>
239void InputWindowPlatform<InputWindow>::OnLButtonDown(HWND hWnd, BOOL fDoubleClick, int x, int y, UINT keyFlags) {
240    SetCapture(hwnd);
241    RECT rect;
242    GetWindowRect(hwnd, &rect);
243    ce.is_capturing = 1;
244    POINT point;
245    point.x = x;
246    point.y = y;
247    ClientToScreen(hwnd, &point);
248    ce.capture_x = point.x - rect.left;
249    ce.capture_y = point.y - rect.top;
250    SetMsgHandled(false);
251}
252
253template <>
254void InputWindowPlatform<InputWindow>::OnMouseMove(HWND hWnd, int x, int y, UINT keyFlags) {
255    if (ce.is_capturing) {
256        POINT point;
257        point.x = x;
258        point.y = y;
259        ClientToScreen(hwnd, &point);
260        SetWindowPos(hwnd, 0,
261                     point.x - ce.capture_x,  point.y - ce.capture_y,
262                     0, 0,
263                     SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOSIZE);
264        SetMsgHandled(true);
265    }
266    SetMsgHandled(false);
267}
268
269template <>
270void InputWindowPlatform<InputWindow>::OnLButtonUp(HWND hWnd, int x, int y, UINT keyFlags) {
271    ReleaseCapture();
272    ce.is_capturing = 0;
273    SetFocus(edit);
274    SetMsgHandled(false);
275}
276
277#else
278
279template <>
280void InputWindowPlatform<InputWindow>::OnLButtonDown(HWND hWnd, BOOL fDoubleClick, int x, int y, UINT keyFlags) {
281    SetMsgHandled(false);
282}
283
284template <>
285void InputWindowPlatform<InputWindow>::OnMouseMove(HWND hWnd, int x, int y, UINT keyFlags) {
286    SetMsgHandled(false);
287}
288
289template <>
290void InputWindowPlatform<InputWindow>::OnLButtonUp(HWND hWnd, int x, int y, UINT keyFlags) {
291    SetFocus(edit);
292    SetMsgHandled(false);
293}
294
295#endif
296
297template <>
298HBRUSH InputWindowPlatform<InputWindow>::OnCtlColorEdit(HWND hWnd, HDC hdc, HWND hWndChild, int type) {
299    SetMsgHandled(false);
300    return 0;
301}
302
303template <>
304void InputWindowPlatform<InputWindow>::OnActivate(HWND hWnd, UINT state, HWND hWndActDeact, BOOL fMinimized) {
305    if (state == WA_INACTIVE) {
306    } else {
307        post(LazyEditFocusEvent(), *this);
308    }
309    SetMsgHandled(false);
310}
311
312template <>
313void InputWindowPlatform<InputWindow>::OnActivateApp(HWND hWnd, BOOL fActivate, DWORD dwThreadId) {
314    SetMsgHandled(false);
315}
316
317template <>
318void InputWindowPlatform<InputWindow>::OnSize(HWND hWnd, UINT state, int client_width, int client_height) {
319    layout.total_width += client_width - layout.window.width;
320    layout.total_height += client_height - layout.window.height;
321    layout.window.width = client_width;
322    layout.window.height = client_height;
323
324    int x = layout.window.padding.left + layout.icon.width + layout.edit.padding.right;
325    int y = layout.window.height - layout.window.padding.bottom - layout.edit.height + layout.edit.padding.top;
326    int w = layout.window.width
327        - layout.window.padding.right - layout.window.padding.left
328        - layout.icon.width
329        - layout.edit.padding.right - layout.edit.padding.left;
330
331    int h = layout.edit.height - layout.edit.padding.top - layout.edit.padding.bottom;
332
333    SetWindowPos(edit, NULL, x, y, w, h, SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOOWNERZORDER | SWP_NOZORDER);
334    SetMsgHandled(false);
335}
336
337template <>
338InputWindowPlatform<InputWindow>::~InputWindowPlatform() {
339    using namespace std;
340
341    Shell_NotifyIcon(NIM_DELETE, &notify_icon);
342
343    if (!riched20_dll) {
344        return;
345    }
346
347    if (!edit || !IsWindow(edit)) {
348        return;
349    }
350
351    DestroyWindow(edit);
352    FreeLibrary(riched20_dll);
353}
354
355template <>
356void InputWindowPlatform<InputWindow>::OnClose(HWND hWnd) {
357    if (edit && IsWindow(edit)) {
358        //TCHAR data[100] = {};
359        //GetWindowText(edit, data, _countof(data));
360        //MessageBox(NULL, data, data, MB_OK);
361        DestroyWindow(edit);
362        edit = NULL;
363    }
364    destroy();
365}
366
367template <>
368void InputWindowPlatform<InputWindow>::OnDestroy(HWND hWnd) {
369    if (IsWindow(edit)) {
370        DebugBreak();
371        DestroyWindow(edit);
372        edit = NULL;
373    }
374    PostQuitMessage(0);
375}
376
377template <>
378void InputWindowPlatform<InputWindow>::OnCommand(HWND hWnd, int id, HWND hWndCtl, UINT codeNotify) {
379    if (hWndCtl == edit) {
380        switch (codeNotify) {
381        case EN_CHANGE: {
382            //GetWindowText(e.edit, prog, _countof(prog));
383            size_t size_to_copy = 0;
384            std::vector<TCHAR>& local_input_cache = getChild().local_input_cache;
385            local_input_cache[0] = 0;
386            for (;;) {
387                /*
388                http://msdn.microsoft.com/en-us/library/ms633520(VS.85).aspx
389
390                int GetWindowText(
391                HWND hWnd,
392                LPTSTR lpString,
393                int nMaxCount
394                );
395
396                  Parameters
397                  hWnd
398                    [in] Handle to the window or control containing the text.
399                  lpString
400                    [out] Pointer to the buffer that will receive the text.
401                    If the string is as long or longer than the buffer,
402                    the string is truncated and terminated with
403                    a NULL character.
404                  nMaxCount
405                    [in] Specifies the maximum number of characters to copy
406                    to the buffer, including the NULL character.
407                    If the text exceeds this limit, it is truncated.
408                 */
409
410                // ex) WindowText[] = "foo";
411                // nMaxCount == 4;
412                // GetWindowText() == 3;
413                //
414                local_input_cache.resize(local_input_cache.capacity());
415                int result = GetWindowText(edit, &local_input_cache[0], local_input_cache.size());
416                if (!result) {
417                    size_to_copy = 1;
418                    break;
419                }
420
421                if (static_cast<size_t>((result + 1))
422                        < local_input_cache.size()) {
423                    size_to_copy = result + 1;
424                    local_input_cache[result] = 0;
425                    break;
426                }
427
428                int length = GetWindowTextLength(edit);
429                size_t new_length = static_cast<size_t>(length * 1.2 + 10);
430                if (!length || new_length < local_input_cache.size()) {
431                    size_to_copy = 1;
432                    break;
433                }
434
435                try {
436                    local_input_cache.reserve(new_length);
437                } catch (std::exception& e) {
438                    halt << "local_input_cache.reserve()";
439                }
440            }
441            local_input_cache.back() = 0;
442            local_input_cache.resize(size_to_copy);
443            getChild().input_cache.write(local_input_cache);
444
445            EditChangedEvent e = {};
446            getChild().mediator.getDelegate().post(e, *this);
447
448        }
449            break;
450        }
451    }
452    SetMsgHandled(false);
453}
454
455
456template <>
457void InputWindowPlatform<InputWindow>::OnKeyDown(HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags) {
458    if (vk == VK_ESCAPE) {
459                ShowWindow(local_window, SW_HIDE);
460        PostMessage(hWnd, WM_CLOSE, 0, 0);
461    }
462}
463
464template <>
465void InputWindowPlatform<InputWindow>::OnNotify(HWND hWnd, int idCtrl, LPNMHDR pnmh) {
466    if (pnmh->hwndFrom != edit) {
467        SetMsgHandled(false);
468        return;
469    }
470    switch (pnmh->code) {
471#ifndef _WIN32_WCE
472    case EN_MSGFILTER: {
473        MSGFILTER* filter = reinterpret_cast<MSGFILTER*>(pnmh);
474        if (filter->msg == WM_KEYDOWN) {
475            if (filter->wParam == VK_ESCAPE) {
476                PostMessage(hWnd, WM_CLOSE, 0, 0);
477            } else if (filter->wParam == VK_RETURN) {
478                ExecuteEvent e;
479                TCHAR* ptr = &(getChild().local_input_cache[0]);
480                size_t bytes = (_tcslen(ptr) + 1) * sizeof(ptr[0]);
481                e.command = (TCHAR*)tmalloc(bytes);
482                if (unlikely(!e.command)) {
483                    return;
484                }
485                memcpy(e.command, ptr, bytes);
486                getChild().mediator.getDelegate().post(e, *this);
487                SetWindowText(edit, _T(""));
488            }
489        }
490    }
491    break;
492#endif
493    default:
494        SetMsgHandled(false);
495        break;
496    }
497}
498
499template <>
500void InputWindowPlatform<InputWindow>::OnPaint(HWND hWnd) {
501    PAINTSTRUCT ps = {};
502    HDC hdc = BeginPaint(hWnd , &ps);
503
504    if (is_dwm_extend_frame_into_client_area) {
505        FillRect(ps.hdc, &ps.rcPaint, (HBRUSH)GetStockObject(BLACK_BRUSH));
506    }
507
508    //HBRUSH hBrushYellow = NULL;
509    //HBRUSH hOldBrush = NULL;
510    //hBrushYellow= CreateSolidBrush(RGB(255,255,0));
511    //hOldBrush= (HBRUSH)SelectObject(hdc,hBrushYellow);  // �u���V���   //Rectangle(hdc, 2, 2, 18, 18);
512    //SelectObject(hdc,hOldBrush);                        // �u���V���
513    //DeleteObject(hBrushYellow);                         // �u���V���
514
515    HICON paint_icon = icon.load();
516        if (!paint_icon) {
517                paint_icon = local_icon;
518        }
519    if (paint_icon) {
520        int left = layout.window.padding.left + layout.icon.padding.left;
521        int top = layout.window.padding.top + layout.icon.padding.top;
522        int width = layout.icon.width - layout.icon.padding.left - layout.icon.padding.right;
523        int height = layout.icon.height - layout.icon.padding.top - layout.icon.padding.bottom;
524        //DrawIconEx(hdc, left, top, paint_icon, width, height, 0, NULL, DI_NORMAL /*| DI_COMPAT*/);
525        DrawIconEx(hdc, left, top, paint_icon, width, height, 0, NULL, DI_NORMAL | DI_IMAGE /*| DI_COMPAT*/);
526
527    }
528
529    EndPaint(hWnd, &ps);
530    SetMsgHandled(false);
531}
532
533template <>
534size_t InputWindowPlatform<InputWindow>::getEditVerticalMargin() {
535    //NONCLIENTMETRICS NCMetrics = {};
536    //NCMetrics.cbSize = sizeof(NCMetrics);
537    //SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &NCMetrics, 0);
538
539    //DWORD dwStyle = (DWORD)GetWindowLongPtr(edit, GWL_STYLE);
540    //DWORD dwExStyle = (DWORD)GetWindowLongPtr(edit, GWL_EXSTYLE);
541
542    //int cyborder = GetSystemMetrics(SM_CYBORDER);
543    //int cysizeframe = GetSystemMetrics(SM_CYSIZEFRAME);
544    //int cyfixedframe = GetSystemMetrics(SM_CYFIXEDFRAME);
545    //int cyedge = GetSystemMetrics(SM_CYEDGE);
546
547//     debug << boost::basic_format<char>(
548//         "SM_CYBORDER: %d\n"
549//         "SM_CYSIZEFRAME: %d\n"
550//         "SM_CYFIXEDFRAME: %d\n"
551//         "SM_CYEDGE: %d\n"
552//         "NONCLIENTMETRICS::iBorderWidth: %d\n"
553//         //"NONCLIENTMETRICS::iPaddedBorderWidth: %d\n"
554//         //"TEXTMETRIC::tmHeight: %d\n"
555//         //"TEXTMETRIC::tmExternalLeading: %d\n"
556//         )
557//         % cyborder % cysizeframe % cyfixedframe % cyedge % NCMetrics.iBorderWidth
558//         //% NCMetrics.iPaddedBorderWidth
559//         ;
560
561    //if (richedit_style & WS_BORDER)
562    //{
563    //    layout.edit.height += cyedge * 2;
564    //    layout.edit.height += 3; // top, bottom padding
565    //    layout.edit.height += 1; // user bottom padding
566    //}
567#ifdef _WIN32_WCE
568    return 2;
569#endif
570    if (is_dwm_extend_frame_into_client_area) {
571        return 0;
572    } else {
573        return 8;
574    }
575}
576
577template <>
578void InputWindowPlatform<InputWindow>::createUI() {
579    if (local_window) {
580                debug << "createUI re-called";
581                if (!IsWindow(local_window)) {
582                        debug << "local_window is not window";
583                }
584        return;
585    }
586
587    // -------------------------------------------------------------
588    // �N���C�A���g�̈��Ńt���[��������邩
589    //
590    if (dll.have_dwmapi_dll) {
591        BOOL enabled = FALSE;
592        HRESULT hr = dll.dll_DwmIsCompositionEnabled(&enabled);
593        if (SUCCEEDED(hr) && enabled) {
594            is_dwm_extend_frame_into_client_area = true;
595        }
596    }
597
598    // -------------------------------------------------------------
599    // �E�B���h�E�쐬
600    //
601
602    const int DEFAULT_WINDOW_WIDTH = 200;
603    const int DEFAULT_WINDOW_HEIGHT = 200;
604
605    TCHAR ClassName[] = _T("i3/WNDCLASS::lpszClassName/InputWindow"); //  <- rule required
606    int nCmdShow = SW_SHOW;
607
608    WNDCLASS wc    = {};
609    wc.style         = CS_HREDRAW | CS_VREDRAW;
610    wc.lpfnWndProc   = DefWindowProc;
611    wc.cbClsExtra    = 0;
612    wc.cbWndExtra    = 0;
613    wc.hInstance     = i3::hInstance;
614//    wc.hIcon         = NULL;//LoadIcon(hCrtInst, MAKEINTRESOURCE(IDI_ICON1));
615//    wc.hIcon         = LoadIcon(i3::hInstance, MAKEINTRESOURCE(IDI_ICON1));
616    wc.hIcon         = LoadIcon(i3::hInstance, _T("IDI_ICON1"));
617    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
618    wc.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
619    wc.lpszMenuName  = NULL;
620    wc.lpszClassName = ClassName;
621    if (!RegisterClass(&wc)) {
622        //halt << "lpszClassName: [" << wc.lpszClassName << "]";
623        //return;
624    }
625
626    DWORD dwDefaultStyle = WS_POPUP;
627    DWORD dwDefaultExStyle = 0;
628//    DWORD dwDefaultExStyle = WS_EX_DLGMODALFRAME;
629#ifdef _WIN32_WCE
630    dwDefaultStyle |= WS_BORDER;
631#else
632    dwDefaultStyle |= WS_THICKFRAME;
633//    dwDefaultStyle |= WS_DLGFRAME;
634//    dwDefaultStyle |= WS_BORDER;
635#endif
636    dwDefaultStyle &= ~WS_CAPTION;
637
638    HWND hWnd = CreateWindowEx(
639                    dwDefaultExStyle,
640                    ClassName,
641                    _T("i3/InputWindow"), //  <- need rule
642                    dwDefaultStyle,
643                    30, //CW_USEDEFAULT,
644                    30, //CW_USEDEFAULT,
645                    DEFAULT_WINDOW_WIDTH,
646                    DEFAULT_WINDOW_HEIGHT,
647                    NULL,
648                    NULL,
649                    i3::hInstance,
650                    NULL
651                );
652
653    if (!IsWindow(hWnd)) {
654        // what ..?
655        halt << hWnd;
656        return;
657    }
658
659    // -------------------------------------------------------------
660    // �G�f�B�b�g�R���g���[���I��   //
661    int richedit_style = WS_CHILD | WS_VISIBLE | WS_TABSTOP;
662    int richedit_exstyle = 0;
663    //richedit_exstyle |= WS_EX_CLIENTEDGE;
664    if (!is_dwm_extend_frame_into_client_area) {
665        //richedit_style |= WS_BORDER;
666        richedit_exstyle |= WS_EX_CLIENTEDGE;
667    }
668#ifndef _WIN32_WCE
669    TCHAR name[100] = MSFTEDIT_CLASS;
670    HMODULE module = LoadLibrary(_T("Msftedit.dll"));
671    if (!module) {
672        module = LoadLibrary(_T("Riched20.dll"));
673        if (module) {
674            _tcscpy_s(name, RICHEDIT_CLASS);
675        } else {
676            _tcscpy_s(name, _T("EDIT"));
677        }
678    }
679#else
680    TCHAR name[100] = _T("EDIT");
681#endif
682
683    // -------------------------------------------------------------
684    // �t�H���g�ݒ�    //
685    HFONT font = NULL;
686#ifndef _WIN32_WCE
687    NONCLIENTMETRICS NCMetrics = {};
688    NCMetrics.cbSize = sizeof(NCMetrics);
689    if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &NCMetrics, 0 )) {
690        font = CreateFontIndirect(&NCMetrics.lfMessageFont);
691    }
692    if (!font) {
693        font = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
694    }
695
696#else
697    font = (HFONT)SendMessage(edit, WM_GETFONT, NULL, NULL);
698    if (!font) {
699        font = (HFONT)GetStockObject(SYSTEM_FONT);
700    }
701#endif
702    // -------------------------------------------------------------
703    // �t�H���g���擾
704    //
705    TEXTMETRIC tm = {};
706    {
707        HDC dc = GetDC(hWnd);
708        HFONT old_font = (HFONT)SelectObject(dc, font);
709        GetTextMetrics(dc, &tm);
710        SelectObject(dc, old_font);
711        int result = ReleaseDC(hWnd, dc);
712    }
713
714    // -------------------------------------------------------------
715    // �E�B���h�E�T�C�Y�̍Đݒ�    //
716    {
717        layout.edit.height = tm.tmHeight + tm.tmExternalLeading + getEditVerticalMargin() +
718            layout.edit.padding.top + layout.edit.padding.bottom;
719        if (layout.edit.height > layout.icon.height) {
720            layout.window.height = layout.edit.height;
721        } else {
722            layout.window.height = layout.icon.height;
723        }
724
725        layout.window.height += layout.window.padding.top + layout.window.padding.bottom;
726        layout.window.width += layout.window.padding.left + layout.window.padding.right;
727
728        DWORD dwStyle = (DWORD)GetWindowLongPtr(hWnd, GWL_STYLE);
729        DWORD dwExStyle = (DWORD)GetWindowLongPtr(hWnd, GWL_EXSTYLE);
730        RECT r;
731        r.top = 0;
732        r.left = 0;
733        r.right = layout.window.width;
734        r.bottom = layout.window.height;
735        //r.right = 200;
736        //r.bottom = 200;
737        BOOL b = AdjustWindowRectEx(&r, dwStyle, FALSE, dwExStyle);
738        if (!b) {
739            halt << "AdjustWindowRectEx() failed";
740        }
741        {
742            layout.total_width = r.right - r.left;
743            layout.total_height = r.bottom - r.top;
744            SetWindowPos(hWnd, 0, 0, 0, layout.total_width, layout.total_height, SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOMOVE);
745        }
746    }
747
748    // -------------------------------------------------------------
749    // �E�B���h�E���� //
750
751    //SetLayeredWindowAttributes(hWnd, 0, 200, LWA_ALPHA);
752    if (is_dwm_extend_frame_into_client_area) {
753
754        //RECT pva = {};
755        //dll.dll_DwmGetWindowAttribute(hWnd, DWMWA_EXTENDED_FRAME_BOUNDS, &pva, sizeof(pva));
756        //std::basic_stringstream<TCHAR> s;
757        //s << pva.left << "," << pva.right << "," << pva.top << "," << pva.bottom;
758        //MessageBox(NULL, s.str().c_str(), _T(""), MB_OK);
759
760        HRESULT hr = S_OK;
761        int top = layout.window.height - layout.window.padding.bottom - layout.edit.height + layout.edit.padding.bottom;
762        MARGINS margins = {
763            layout.window.padding.left + layout.icon.width + layout.edit.padding.left, // left
764            layout.window.padding.right + layout.edit.padding.right,  // right
765            top,      // top
766            layout.window.padding.bottom + layout.edit.padding.bottom // bottom
767        };
768
769        hr = dll.dll_DwmExtendFrameIntoClientArea(hWnd,&margins);
770
771        DWM_BLURBEHIND bb = {};
772        bb.dwFlags = DWM_BB_ENABLE;
773        bb.fEnable = true;
774        hr = dll.dll_DwmEnableBlurBehindWindow(hWnd, &bb);
775
776        /*
777        DWORD color = 0;
778        BOOL blend = FALSE;
779        if (SUCCEEDED(hr))
780        {
781            hr = dll.dll_DwmGetColorizationColor(&color, &blend);
782            if (SUCCEEDED(hr))
783            {
784                BYTE a = (color & 0xFF000000) >> 24;
785                BYTE r = (color & 0x00FF0000) >> 16;
786                BYTE g = (color & 0x0000FF00) >>  8;
787                BYTE b = (color & 0x000000FF);
788
789                //a = 255 - ((255 - a) * 0.3);
790                a = 0x80;
791                r = 255;
792                g = 255;
793                b = 0;
794                //r = 255 - ((255 - r) * 0.5);
795                //g = 255 - ((255 - g) * 0.5);
796                //b = 255 - ((255 - b) * 0.5);
797
798                DWORD color2 = (a << 24) | (b << 16) | (g << 8) | r ;
799                //SendMessage(edit, EM_SETBKGNDCOLOR, (WPARAM)0, (LPARAM)(color2));
800                //printf("");
801            }
802        }
803        */
804    }
805
806
807    // -------------------------------------------------------------
808    // �G�f�B�b�g�R���g���[���쐬
809    //
810    edit = CreateWindowEx(
811                richedit_exstyle,
812                name,
813                //_T("RICHEDIT"),
814                //_T("EDIT"),
815                _T(""),
816                richedit_style,
817                0,
818                0,
819                100,
820                100,
821                hWnd,
822                NULL,//reinterpret_cast<HMENU>(IDC_EDIT),
823                i3::hInstance,
824                NULL
825            );
826    EditDefaultWndProc = (WNDPROC)GetWindowLongPtr(edit, GWLP_WNDPROC);
827    SetWindowLongPtr(edit, GWLP_WNDPROC, (LONG_PTR)EditWndProc2);
828
829    SendMessage(edit, WM_SETFONT, (WPARAM)font, (LPARAM)FALSE);
830#ifndef _WIN32_WCE
831    LRESULT dwEvent = SendMessage(edit, EM_GETEVENTMASK, 0, 0);
832    dwEvent |= ENM_MOUSEEVENTS | ENM_KEYEVENTS | ENM_CHANGE;
833    SendMessage(edit, EM_SETEVENTMASK, 0, (LPARAM)dwEvent);
834#endif
835
836    OnSize(hWnd, SIZE_RESTORED, layout.window.width, layout.window.height);
837
838    // -------------------------------------------------------------
839    // �^�X�N�g���C�p�̃A�C�R���̍쐬
840    //
841    notify_icon.cbSize = sizeof(notify_icon);
842    notify_icon.hIcon = local_icon;
843    notify_icon.hWnd = hWnd;
844    notify_icon.uCallbackMessage = WM_USER + 10;
845    notify_icon.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
846    _tcscpy_s(notify_icon.szTip, _T(""));
847    Shell_NotifyIcon(NIM_ADD, &notify_icon);
848
849    // -------------------------------------------------------------
850    // �E�B���h�E����ƗL��    //
851    //UpdateWindow(edit);
852    SetFocus(edit);
853    //ShowWindow(edit, SW_HIDE);
854    setWindow(hWnd);
855    //hSharedEdit.store(edit);
856    //InvalidateRect(hWnd, NULL, FALSE);
857
858}
859
860template <>
861void InputWindowPlatform<InputWindow>::run() {
862    createUI();
863    UpdateWindow(local_window);
864    ShowWindow(local_window, SW_SHOW);
865    loop();
866}
867
868template <>
869void InputWindowPlatform<InputWindow>::focus() {
870        SetForegroundWindow(local_window);
871        SetFocus(edit);
872}
873
874}
Note: See TracBrowser for help on using the browser.