Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(29)

Side by Side Diff: win8/metro_driver/metro_driver_win7.cc

Issue 1586843002: Remove remote tree host and some related input and metro_driver code (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@metro-mode-3
Patch Set: remove ash_unittests from being run Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « win8/metro_driver/metro_driver.gyp ('k') | win8/viewer/metro_viewer_constants.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "stdafx.h"
6 #include <corewindow.h>
7 #include <shobjidl.h>
8 #include <stdint.h>
9
10 #include "base/logging.h"
11 #include "base/macros.h"
12 #include "ui/gfx/geometry/safe_integer_conversions.h"
13 #include "ui/gfx/win/msg_util.h"
14
15 #pragma comment(lib, "shell32.lib")
16
17 EXTERN_C IMAGE_DOS_HEADER __ImageBase;
18 // Even though we only create a single window, we need to keep this
19 // count because of the hidden window used by the UI message loop of
20 // the metro viewer.
21 int g_window_count = 0;
22
23 const wchar_t kAshWin7AppId[] = L"Google.Chrome.AshWin7.1";
24 const wchar_t kAshWin7CoreWindowHandler[] = L"CoreWindowHandler";
25 extern float GetModernUIScale();
26 LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam,
27 LPARAM lparam);
28
29 HWND CreateMetroTopLevelWindow(const RECT& work_area) {
30 HINSTANCE hInst = reinterpret_cast<HINSTANCE>(&__ImageBase);
31 WNDCLASSEXW wcex;
32 wcex.cbSize = sizeof(wcex);
33 wcex.style = CS_HREDRAW | CS_VREDRAW;
34 wcex.lpfnWndProc = WndProc;
35 wcex.cbClsExtra = 0;
36 wcex.cbWndExtra = 0;
37 wcex.hInstance = hInst;
38 wcex.hIcon = LoadIcon(::GetModuleHandle(NULL), L"IDR_MAINFRAME");
39 wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
40 wcex.hbrBackground = (HBRUSH)(COLOR_INACTIVECAPTION+1);
41 wcex.lpszMenuName = 0;
42 wcex.lpszClassName = L"Windows.UI.Core.CoreWindow";
43 wcex.hIconSm = LoadIcon(::GetModuleHandle(NULL), L"IDR_MAINFRAME");
44
45 HWND hwnd = ::CreateWindowExW(0,
46 MAKEINTATOM(::RegisterClassExW(&wcex)),
47 L"metro_win7",
48 WS_POPUP | WS_VISIBLE | WS_MINIMIZEBOX,
49 work_area.top, work_area.left,
50 work_area.right, work_area.bottom,
51 NULL, NULL, hInst, NULL);
52 return hwnd;
53 }
54
55 typedef winfoundtn::ITypedEventHandler<
56 winapp::Core::CoreApplicationView*,
57 winapp::Activation::IActivatedEventArgs*> ActivatedHandler;
58
59 typedef winfoundtn::ITypedEventHandler<
60 winui::Core::CoreWindow*,
61 winui::Core::WindowActivatedEventArgs*> WindowActivatedHandler;
62
63 typedef winfoundtn::ITypedEventHandler<
64 winui::Core::CoreWindow*,
65 winui::Core::AutomationProviderRequestedEventArgs*>
66 AutomationProviderHandler;
67
68 typedef winfoundtn::ITypedEventHandler<
69 winui::Core::CoreWindow*,
70 winui::Core::CharacterReceivedEventArgs*> CharEventHandler;
71
72 typedef winfoundtn::ITypedEventHandler<
73 winui::Core::CoreWindow*,
74 winui::Core::CoreWindowEventArgs*> CoreWindowEventHandler;
75
76 typedef winfoundtn::ITypedEventHandler<
77 winui::Core::CoreWindow*,
78 winui::Core::InputEnabledEventArgs*> InputEnabledEventHandler;
79
80 typedef winfoundtn::ITypedEventHandler<
81 winui::Core::CoreWindow*,
82 winui::Core::KeyEventArgs*> KeyEventHandler;
83
84 typedef winfoundtn::ITypedEventHandler<
85 winui::Core::CoreWindow*,
86 winui::Core::PointerEventArgs*> PointerEventHandler;
87
88 typedef winfoundtn::ITypedEventHandler<
89 winui::Core::CoreWindow*,
90 winui::Core::WindowSizeChangedEventArgs*> SizeChangedHandler;
91
92 typedef winfoundtn::ITypedEventHandler<
93 winui::Core::CoreWindow*,
94 winui::Core::TouchHitTestingEventArgs*> TouchHitTestHandler;
95
96 typedef winfoundtn::ITypedEventHandler<
97 winui::Core::CoreWindow*,
98 winui::Core::VisibilityChangedEventArgs*> VisibilityChangedHandler;
99
100 typedef winfoundtn::ITypedEventHandler<
101 winui::Core::CoreDispatcher*,
102 winui::Core::AcceleratorKeyEventArgs*> AcceleratorKeyEventHandler;
103
104 // This interface is implemented by classes which handle mouse and keyboard
105 // input.
106 class InputHandler {
107 public:
108 InputHandler() {}
109 virtual ~InputHandler() {}
110
111 virtual bool HandleKeyboardMessage(const MSG& msg) = 0;
112 virtual bool HandleMouseMessage(const MSG& msg) = 0;
113
114 private:
115 DISALLOW_COPY_AND_ASSIGN(InputHandler);
116 };
117
118 // This class implements the winrt interfaces corresponding to mouse input.
119 class MouseEvent : public mswr::RuntimeClass<
120 winui::Core::IPointerEventArgs,
121 winui::Input::IPointerPoint,
122 winui::Input::IPointerPointProperties,
123 windevs::Input::IPointerDevice> {
124 public:
125 MouseEvent(const MSG& msg)
126 : msg_(msg) {
127 }
128
129 // IPointerEventArgs implementation.
130 HRESULT STDMETHODCALLTYPE
131 get_CurrentPoint(winui::Input::IPointerPoint** point) override {
132 return QueryInterface(winui::Input::IID_IPointerPoint,
133 reinterpret_cast<void**>(point));
134 }
135
136 HRESULT STDMETHODCALLTYPE
137 get_KeyModifiers(winsys::VirtualKeyModifiers* modifiers) override {
138 return E_NOTIMPL;
139 }
140
141 HRESULT STDMETHODCALLTYPE GetIntermediatePoints(
142 winfoundtn::Collections::IVector<winui::Input::PointerPoint*>** points)
143 override {
144 return E_NOTIMPL;
145 }
146
147 // IPointerPoint implementation.
148 HRESULT STDMETHODCALLTYPE
149 get_PointerDevice(windevs::Input::IPointerDevice** pointer_device) override {
150 return QueryInterface(windevs::Input::IID_IPointerDevice,
151 reinterpret_cast<void**>(pointer_device));
152 }
153
154 HRESULT STDMETHODCALLTYPE get_Position(winfoundtn::Point* position) override {
155 static float scale = GetModernUIScale();
156 // Scale down the points here as they are scaled up on the other side.
157 position->X = gfx::ToRoundedInt(CR_GET_X_LPARAM(msg_.lParam) / scale);
158 position->Y = gfx::ToRoundedInt(CR_GET_Y_LPARAM(msg_.lParam) / scale);
159 return S_OK;
160 }
161
162 HRESULT STDMETHODCALLTYPE get_PointerId(uint32_t* pointer_id) override {
163 // TODO(ananta)
164 // Implement this properly.
165 *pointer_id = 1;
166 return S_OK;
167 }
168
169 HRESULT STDMETHODCALLTYPE get_Timestamp(uint64_t* timestamp) override {
170 *timestamp = msg_.time;
171 return S_OK;
172 }
173
174 HRESULT STDMETHODCALLTYPE
175 get_Properties(winui::Input::IPointerPointProperties** properties) override {
176 return QueryInterface(winui::Input::IID_IPointerPointProperties,
177 reinterpret_cast<void**>(properties));
178 }
179
180 HRESULT STDMETHODCALLTYPE
181 get_RawPosition(winfoundtn::Point* position) override {
182 return E_NOTIMPL;
183 }
184
185 HRESULT STDMETHODCALLTYPE get_FrameId(uint32_t* frame_id) override {
186 return E_NOTIMPL;
187 }
188
189 HRESULT STDMETHODCALLTYPE get_IsInContact(boolean* in_contact) override {
190 return E_NOTIMPL;
191 }
192
193 // IPointerPointProperties implementation.
194 HRESULT STDMETHODCALLTYPE
195 get_PointerUpdateKind(winui::Input::PointerUpdateKind* update_kind) override {
196 // TODO(ananta)
197 // There is no WM_POINTERUPDATE equivalent on Windows 7. Look into
198 // equivalents.
199 if (msg_.message == WM_LBUTTONDOWN) {
200 *update_kind = winui::Input::PointerUpdateKind_LeftButtonPressed;
201 } else if (msg_.message == WM_RBUTTONDOWN) {
202 *update_kind = winui::Input::PointerUpdateKind_RightButtonPressed;
203 } else if (msg_.message == WM_MBUTTONDOWN) {
204 *update_kind = winui::Input::PointerUpdateKind_MiddleButtonPressed;
205 } else if (msg_.message == WM_LBUTTONUP) {
206 *update_kind = winui::Input::PointerUpdateKind_LeftButtonReleased;
207 } else if (msg_.message == WM_RBUTTONUP) {
208 *update_kind = winui::Input::PointerUpdateKind_RightButtonReleased;
209 } else if (msg_.message == WM_MBUTTONUP) {
210 *update_kind = winui::Input::PointerUpdateKind_MiddleButtonReleased;
211 }
212 return S_OK;
213 }
214
215 HRESULT STDMETHODCALLTYPE
216 get_IsLeftButtonPressed(boolean* left_button_pressed) override {
217 *left_button_pressed = msg_.wParam & MK_LBUTTON ? true : false;
218 return S_OK;
219 }
220
221 HRESULT STDMETHODCALLTYPE
222 get_IsRightButtonPressed(boolean* right_button_pressed) override {
223 *right_button_pressed = msg_.wParam & MK_RBUTTON ? true : false;
224 return S_OK;
225 }
226
227 HRESULT STDMETHODCALLTYPE
228 get_IsMiddleButtonPressed(boolean* middle_button_pressed) override {
229 *middle_button_pressed = msg_.wParam & MK_MBUTTON ? true : false;
230 return S_OK;
231 }
232
233 HRESULT STDMETHODCALLTYPE
234 get_IsHorizontalMouseWheel(boolean* is_horizontal_mouse_wheel) override {
235 *is_horizontal_mouse_wheel =
236 (msg_.message == WM_MOUSEHWHEEL) ? true : false;
237 return S_OK;
238 }
239
240 HRESULT STDMETHODCALLTYPE get_MouseWheelDelta(int* delta) override {
241 if (msg_.message == WM_MOUSEWHEEL || msg_.message == WM_MOUSEHWHEEL) {
242 *delta = GET_WHEEL_DELTA_WPARAM(msg_.wParam);
243 return S_OK;
244 } else {
245 return S_FALSE;
246 }
247 }
248
249 HRESULT STDMETHODCALLTYPE get_Pressure(float* pressure) override {
250 return E_NOTIMPL;
251 }
252
253 HRESULT STDMETHODCALLTYPE get_IsInverted(boolean* inverted) override {
254 return E_NOTIMPL;
255 }
256
257 HRESULT STDMETHODCALLTYPE get_IsEraser(boolean* is_eraser) override {
258 return E_NOTIMPL;
259 }
260
261 HRESULT STDMETHODCALLTYPE get_Orientation(float* orientation) override {
262 return E_NOTIMPL;
263 }
264
265 HRESULT STDMETHODCALLTYPE get_XTilt(float* x_tilt) override {
266 return E_NOTIMPL;
267 }
268
269 HRESULT STDMETHODCALLTYPE get_YTilt(float* y_tilt) override {
270 return E_NOTIMPL;
271 }
272
273 HRESULT STDMETHODCALLTYPE get_Twist(float* twist) override {
274 return E_NOTIMPL;
275 }
276
277 HRESULT STDMETHODCALLTYPE get_ContactRect(winfoundtn::Rect* rect) override {
278 return E_NOTIMPL;
279 }
280
281 HRESULT STDMETHODCALLTYPE
282 get_ContactRectRaw(winfoundtn::Rect* rect) override {
283 return E_NOTIMPL;
284 }
285
286 HRESULT STDMETHODCALLTYPE get_TouchConfidence(boolean* confidence) override {
287 return E_NOTIMPL;
288 }
289
290 HRESULT STDMETHODCALLTYPE get_IsPrimary(boolean* is_primary) override {
291 return E_NOTIMPL;
292 }
293
294 HRESULT STDMETHODCALLTYPE get_IsInRange(boolean* is_in_range) override {
295 return E_NOTIMPL;
296 }
297
298 HRESULT STDMETHODCALLTYPE get_IsCanceled(boolean* is_canceled) override {
299 return E_NOTIMPL;
300 }
301
302 HRESULT STDMETHODCALLTYPE
303 get_IsBarrelButtonPressed(boolean* is_barrel_button_pressed) override {
304 return E_NOTIMPL;
305 }
306
307 HRESULT STDMETHODCALLTYPE
308 get_IsXButton1Pressed(boolean* is_xbutton1_pressed) override {
309 return E_NOTIMPL;
310 }
311
312 HRESULT STDMETHODCALLTYPE
313 get_IsXButton2Pressed(boolean* is_xbutton2_pressed) override {
314 return E_NOTIMPL;
315 }
316
317 HRESULT STDMETHODCALLTYPE HasUsage(uint32_t usage_page,
318 uint32_t usage_id,
319 boolean* has_usage) override {
320 return E_NOTIMPL;
321 }
322
323 HRESULT STDMETHODCALLTYPE GetUsageValue(uint32_t usage_page,
324 uint32_t usage_id,
325 int32_t* usage_value) override {
326 return E_NOTIMPL;
327 }
328
329 // IPointerDevice implementation.
330 HRESULT STDMETHODCALLTYPE get_PointerDeviceType(
331 windevs::Input::PointerDeviceType* device_type) override {
332 if (msg_.message == WM_TOUCH) {
333 *device_type = windevs::Input::PointerDeviceType_Touch;
334 } else {
335 *device_type = windevs::Input::PointerDeviceType_Mouse;
336 }
337 return S_OK;
338 }
339
340 HRESULT STDMETHODCALLTYPE get_IsIntegrated(boolean* is_integrated) override {
341 return E_NOTIMPL;
342 }
343
344 HRESULT STDMETHODCALLTYPE get_MaxContacts(uint32_t* contacts) override {
345 return E_NOTIMPL;
346 }
347
348 HRESULT STDMETHODCALLTYPE
349 get_PhysicalDeviceRect(winfoundtn::Rect* rect) override {
350 return E_NOTIMPL;
351 }
352
353 HRESULT STDMETHODCALLTYPE get_ScreenRect(winfoundtn::Rect* rect) override {
354 return E_NOTIMPL;
355 }
356
357 HRESULT STDMETHODCALLTYPE get_SupportedUsages(
358 winfoundtn::Collections::IVectorView<windevs::Input::PointerDeviceUsage>**
359 usages) override {
360 return E_NOTIMPL;
361 }
362
363 private:
364 MSG msg_;
365
366 DISALLOW_COPY_AND_ASSIGN(MouseEvent);
367 };
368
369 // This class implements the winrt interfaces needed to support keyboard
370 // character and system character messages.
371 class KeyEvent : public mswr::RuntimeClass<
372 winui::Core::IKeyEventArgs,
373 winui::Core::ICharacterReceivedEventArgs,
374 winui::Core::IAcceleratorKeyEventArgs> {
375 public:
376 KeyEvent(const MSG& msg)
377 : msg_(msg) {}
378
379 // IKeyEventArgs implementation.
380 HRESULT STDMETHODCALLTYPE
381 get_VirtualKey(winsys::VirtualKey* virtual_key) override {
382 *virtual_key = static_cast<winsys::VirtualKey>(msg_.wParam);
383 return S_OK;
384 }
385
386 HRESULT STDMETHODCALLTYPE
387 get_KeyStatus(winui::Core::CorePhysicalKeyStatus* key_status) override {
388 // As per msdn documentation for the keyboard messages.
389 key_status->RepeatCount = msg_.lParam & 0x0000FFFF;
390 key_status->ScanCode = (msg_.lParam >> 16) & 0x00FF;
391 key_status->IsExtendedKey = (msg_.lParam & (1 << 24));
392 key_status->IsMenuKeyDown = (msg_.lParam & (1 << 29));
393 key_status->WasKeyDown = (msg_.lParam & (1 << 30));
394 key_status->IsKeyReleased = (msg_.lParam & (1 << 31));
395 return S_OK;
396 }
397
398 // ICharacterReceivedEventArgs implementation.
399 HRESULT STDMETHODCALLTYPE get_KeyCode(uint32_t* key_code) override {
400 *key_code = msg_.wParam;
401 return S_OK;
402 }
403
404 // IAcceleratorKeyEventArgs implementation.
405 HRESULT STDMETHODCALLTYPE
406 get_EventType(winui::Core::CoreAcceleratorKeyEventType* event_type) override {
407 if (msg_.message == WM_SYSKEYDOWN) {
408 *event_type = winui::Core::CoreAcceleratorKeyEventType_SystemKeyDown;
409 } else if (msg_.message == WM_SYSKEYUP) {
410 *event_type = winui::Core::CoreAcceleratorKeyEventType_SystemKeyUp;
411 } else if (msg_.message == WM_SYSCHAR) {
412 *event_type = winui::Core::CoreAcceleratorKeyEventType_SystemCharacter;
413 }
414 return S_OK;
415 }
416
417 private:
418 MSG msg_;
419 };
420
421 // The following classes are the emulation of the WinRT system as exposed
422 // to metro applications. There is one application (ICoreApplication) which
423 // contains a series of Views (ICoreApplicationView) each one of them
424 // containing a CoreWindow which represents a surface that can drawn to
425 // and that receives events.
426 //
427 // Here is the general dependency hierachy in terms of interfaces:
428 //
429 // IFrameworkViewSource --> IFrameworkView
430 // ^ |
431 // | | metro app
432 // ---------------------------------------------------------------------
433 // | | winRT system
434 // | v
435 // ICoreApplication ICoreApplicationView
436 // |
437 // v
438 // ICoreWindow -----> ICoreWindowInterop
439 // | |
440 // | |
441 // v V
442 // ICoreDispatcher <==> real HWND
443 //
444 class CoreDispatcherEmulation :
445 public mswr::RuntimeClass<
446 winui::Core::ICoreDispatcher,
447 winui::Core::ICoreAcceleratorKeys> {
448 public:
449 CoreDispatcherEmulation(InputHandler* input_handler)
450 : input_handler_(input_handler),
451 accelerator_key_event_handler_(NULL) {}
452
453 // ICoreDispatcher implementation:
454 HRESULT STDMETHODCALLTYPE get_HasThreadAccess(boolean* value) override {
455 return S_OK;
456 }
457
458 HRESULT STDMETHODCALLTYPE
459 ProcessEvents(winui::Core::CoreProcessEventsOption options) override {
460 // We don't support the other message pump modes. So we basically enter a
461 // traditional message loop that we only exit a teardown.
462 if (options != winui::Core::CoreProcessEventsOption_ProcessUntilQuit)
463 return E_FAIL;
464
465 MSG msg = {0};
466 while((::GetMessage(&msg, NULL, 0, 0) != 0) && g_window_count > 0) {
467 ProcessInputMessage(msg);
468 ::TranslateMessage(&msg);
469 ::DispatchMessage(&msg);
470 }
471 // TODO(cpu): figure what to do with msg.WParam which we would normally
472 // return here.
473 return S_OK;
474 }
475
476 HRESULT STDMETHODCALLTYPE
477 RunAsync(winui::Core::CoreDispatcherPriority priority,
478 winui::Core::IDispatchedHandler* agileCallback,
479 ABI::Windows::Foundation::IAsyncAction** asyncAction) override {
480 return S_OK;
481 }
482
483 HRESULT STDMETHODCALLTYPE
484 RunIdleAsync(winui::Core::IIdleDispatchedHandler* agileCallback,
485 winfoundtn::IAsyncAction** asyncAction) override {
486 return S_OK;
487 }
488
489 // ICoreAcceleratorKeys implementation:
490 HRESULT STDMETHODCALLTYPE
491 add_AcceleratorKeyActivated(AcceleratorKeyEventHandler* handler,
492 EventRegistrationToken* pCookie) override {
493 accelerator_key_event_handler_ = handler;
494 accelerator_key_event_handler_->AddRef();
495 return S_OK;
496 }
497
498 HRESULT STDMETHODCALLTYPE
499 remove_AcceleratorKeyActivated(EventRegistrationToken cookie) override {
500 accelerator_key_event_handler_->Release();
501 accelerator_key_event_handler_ = NULL;
502 return S_OK;
503 }
504
505 private:
506 bool ProcessInputMessage(const MSG& msg) {
507 // Poor man's way of dispatching input events.
508 bool ret = false;
509 if (input_handler_) {
510 if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST)) {
511 if ((msg.message == WM_SYSKEYDOWN) || (msg.message == WM_SYSKEYUP) ||
512 msg.message == WM_SYSCHAR) {
513 ret = HandleSystemKeys(msg);
514 } else {
515 ret = input_handler_->HandleKeyboardMessage(msg);
516 }
517 } else if ((msg.message >= WM_MOUSEFIRST) &&
518 (msg.message <= WM_MOUSELAST)) {
519 ret = input_handler_->HandleMouseMessage(msg);
520 }
521 }
522 return ret;
523 }
524
525 bool HandleSystemKeys(const MSG& msg) {
526 mswr::ComPtr<winui::Core::IAcceleratorKeyEventArgs> event_args;
527 event_args = mswr::Make<KeyEvent>(msg);
528 accelerator_key_event_handler_->Invoke(this, event_args.Get());
529 return true;
530 }
531
532 InputHandler* input_handler_;
533 AcceleratorKeyEventHandler* accelerator_key_event_handler_;
534 };
535
536 class CoreWindowEmulation
537 : public mswr::RuntimeClass<
538 mswr::RuntimeClassFlags<mswr::WinRtClassicComMix>,
539 winui::Core::ICoreWindow, ICoreWindowInterop>,
540 public InputHandler {
541 public:
542 CoreWindowEmulation(winapp::Core::IFrameworkView* app_view)
543 : mouse_moved_handler_(NULL),
544 mouse_capture_lost_handler_(NULL),
545 mouse_pressed_handler_(NULL),
546 mouse_released_handler_(NULL),
547 mouse_entered_handler_(NULL),
548 mouse_exited_handler_(NULL),
549 mouse_wheel_changed_handler_(NULL),
550 key_down_handler_(NULL),
551 key_up_handler_(NULL),
552 character_received_handler_(NULL),
553 core_hwnd_(NULL),
554 app_view_(app_view),
555 window_activated_handler_(NULL) {
556 dispatcher_ = mswr::Make<CoreDispatcherEmulation>(this);
557
558 // Unless we select our own AppUserModelID the shell might confuse us
559 // with the app launcher one and we get the wrong taskbar button and icon.
560 ::SetCurrentProcessExplicitAppUserModelID(kAshWin7AppId);
561
562 RECT work_area = {0};
563 ::SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
564 if (::IsDebuggerPresent()) {
565 work_area.top = 0;
566 work_area.left = 0;
567 work_area.right = 1600;
568 work_area.bottom = 900;
569 }
570
571 core_hwnd_ = CreateMetroTopLevelWindow(work_area);
572 ::SetProp(core_hwnd_, kAshWin7CoreWindowHandler, this);
573 }
574
575 ~CoreWindowEmulation() override {
576 if (core_hwnd_) {
577 ::RemoveProp(core_hwnd_, kAshWin7CoreWindowHandler);
578 ::DestroyWindow(core_hwnd_);
579 }
580 }
581
582 // ICoreWindow implementation:
583 HRESULT STDMETHODCALLTYPE
584 get_AutomationHostProvider(IInspectable** value) override {
585 return S_OK;
586 }
587
588 HRESULT STDMETHODCALLTYPE get_Bounds(winfoundtn::Rect* value) override {
589 RECT rect;
590 if (!::GetClientRect(core_hwnd_, &rect))
591 return E_FAIL;
592 value->Width = rect.right;
593 value->Height = rect.bottom;
594 return S_OK;
595 }
596
597 HRESULT STDMETHODCALLTYPE
598 get_CustomProperties(winfoundtn::Collections::IPropertySet** value) override {
599 return S_OK;
600 }
601
602 HRESULT STDMETHODCALLTYPE
603 get_Dispatcher(winui::Core::ICoreDispatcher** value) override {
604 return dispatcher_.CopyTo(value);
605 }
606
607 HRESULT STDMETHODCALLTYPE
608 get_FlowDirection(winui::Core::CoreWindowFlowDirection* value) override {
609 return S_OK;
610 }
611
612 HRESULT STDMETHODCALLTYPE
613 put_FlowDirection(winui::Core::CoreWindowFlowDirection value) override {
614 return S_OK;
615 }
616
617 HRESULT STDMETHODCALLTYPE get_IsInputEnabled(boolean* value) override {
618 return S_OK;
619 }
620
621 HRESULT STDMETHODCALLTYPE put_IsInputEnabled(boolean value) override {
622 return S_OK;
623 }
624
625 HRESULT STDMETHODCALLTYPE
626 get_PointerCursor(winui::Core::ICoreCursor** value) override {
627 return S_OK;
628 }
629
630 HRESULT STDMETHODCALLTYPE
631 put_PointerCursor(winui::Core::ICoreCursor* value) override {
632 return S_OK;
633 }
634
635 HRESULT STDMETHODCALLTYPE
636 get_PointerPosition(winfoundtn::Point* value) override {
637 return S_OK;
638 }
639
640 HRESULT STDMETHODCALLTYPE get_Visible(boolean* value) override {
641 return S_OK;
642 }
643
644 HRESULT STDMETHODCALLTYPE Activate(void) override {
645 // After we fire OnActivate on the View, Chrome calls us back here.
646 return S_OK;
647 }
648
649 HRESULT STDMETHODCALLTYPE Close(void) override {
650 ::PostMessage(core_hwnd_, WM_CLOSE, 0, 0);
651 core_hwnd_ = NULL;
652 return S_OK;
653 }
654
655 HRESULT STDMETHODCALLTYPE GetAsyncKeyState(
656 ABI::Windows::System::VirtualKey virtualKey,
657 winui::Core::CoreVirtualKeyStates* KeyState) override {
658 return S_OK;
659 }
660
661 HRESULT STDMETHODCALLTYPE GetKeyState(
662 ABI::Windows::System::VirtualKey virtualKey,
663 winui::Core::CoreVirtualKeyStates* KeyState) override {
664 return S_OK;
665 }
666
667 HRESULT STDMETHODCALLTYPE ReleasePointerCapture(void) override {
668 return S_OK;
669 }
670
671 HRESULT STDMETHODCALLTYPE SetPointerCapture(void) override {
672 return S_OK;
673 }
674
675 HRESULT STDMETHODCALLTYPE add_Activated(
676 WindowActivatedHandler* handler,
677 EventRegistrationToken* pCookie) override {
678 window_activated_handler_ = handler;
679 handler->AddRef();
680 return S_OK;
681 }
682
683 HRESULT STDMETHODCALLTYPE remove_Activated(
684 EventRegistrationToken cookie) override {
685 window_activated_handler_->Release();
686 window_activated_handler_ = NULL;
687 return S_OK;
688 }
689
690 HRESULT STDMETHODCALLTYPE add_AutomationProviderRequested(
691 AutomationProviderHandler* handler,
692 EventRegistrationToken* cookie) override {
693 return S_OK;
694 }
695
696 HRESULT STDMETHODCALLTYPE remove_AutomationProviderRequested(
697 EventRegistrationToken cookie) override {
698 return S_OK;
699 }
700
701 HRESULT STDMETHODCALLTYPE add_CharacterReceived(
702 CharEventHandler* handler,
703 EventRegistrationToken* pCookie) override {
704 character_received_handler_ = handler;
705 character_received_handler_->AddRef();
706 return S_OK;
707 }
708
709 HRESULT STDMETHODCALLTYPE remove_CharacterReceived(
710 EventRegistrationToken cookie) override {
711 character_received_handler_->Release();
712 character_received_handler_ = NULL;
713 return S_OK;
714 }
715
716 HRESULT STDMETHODCALLTYPE add_Closed(
717 CoreWindowEventHandler* handler,
718 EventRegistrationToken* pCookie) override {
719 return S_OK;
720 }
721
722 HRESULT STDMETHODCALLTYPE remove_Closed(
723 EventRegistrationToken cookie) override {
724 return S_OK;
725 }
726
727 HRESULT STDMETHODCALLTYPE add_InputEnabled(
728 InputEnabledEventHandler* handler,
729 EventRegistrationToken* pCookie) override {
730 return S_OK;
731 }
732
733 HRESULT STDMETHODCALLTYPE remove_InputEnabled(
734 EventRegistrationToken cookie) override {
735 return S_OK;
736 }
737
738 HRESULT STDMETHODCALLTYPE add_KeyDown(
739 KeyEventHandler* handler,
740 EventRegistrationToken* pCookie) override {
741 key_down_handler_ = handler;
742 key_down_handler_->AddRef();
743 return S_OK;
744 }
745
746 HRESULT STDMETHODCALLTYPE remove_KeyDown(
747 EventRegistrationToken cookie) override {
748 key_down_handler_->Release();
749 key_down_handler_ = NULL;
750 return S_OK;
751 }
752
753 HRESULT STDMETHODCALLTYPE add_KeyUp(
754 KeyEventHandler* handler,
755 EventRegistrationToken* pCookie) override {
756 key_up_handler_ = handler;
757 key_up_handler_->AddRef();
758 return S_OK;
759 }
760
761 HRESULT STDMETHODCALLTYPE remove_KeyUp(
762 EventRegistrationToken cookie) override {
763 key_up_handler_->Release();
764 key_up_handler_ = NULL;
765 return S_OK;
766 }
767
768 HRESULT STDMETHODCALLTYPE add_PointerCaptureLost(
769 PointerEventHandler* handler,
770 EventRegistrationToken* cookie) override {
771 mouse_capture_lost_handler_ = handler;
772 return S_OK;
773 }
774
775 HRESULT STDMETHODCALLTYPE remove_PointerCaptureLost(
776 EventRegistrationToken cookie) override {
777 mouse_capture_lost_handler_ = NULL;
778 return S_OK;
779 }
780
781 HRESULT STDMETHODCALLTYPE add_PointerEntered(
782 PointerEventHandler* handler,
783 EventRegistrationToken* cookie) override {
784 mouse_entered_handler_ = handler;
785 return S_OK;
786 }
787
788 HRESULT STDMETHODCALLTYPE remove_PointerEntered(
789 EventRegistrationToken cookie) override {
790 mouse_entered_handler_ = NULL;
791 return S_OK;
792 }
793
794 HRESULT STDMETHODCALLTYPE add_PointerExited(
795 PointerEventHandler* handler,
796 EventRegistrationToken* cookie) override {
797 mouse_exited_handler_ = handler;
798 return S_OK;
799 }
800
801 HRESULT STDMETHODCALLTYPE remove_PointerExited(
802 EventRegistrationToken cookie) override {
803 mouse_exited_handler_ = NULL;
804 return S_OK;
805 }
806
807 HRESULT STDMETHODCALLTYPE add_PointerMoved(
808 PointerEventHandler* handler,
809 EventRegistrationToken* cookie) override {
810 mouse_moved_handler_ = handler;
811 mouse_moved_handler_->AddRef();
812 return S_OK;
813 }
814
815 HRESULT STDMETHODCALLTYPE remove_PointerMoved(
816 EventRegistrationToken cookie) override {
817 mouse_moved_handler_->Release();
818 mouse_moved_handler_ = NULL;
819 return S_OK;
820 }
821
822 HRESULT STDMETHODCALLTYPE add_PointerPressed(
823 PointerEventHandler* handler,
824 EventRegistrationToken* cookie) override {
825 mouse_pressed_handler_ = handler;
826 mouse_pressed_handler_->AddRef();
827 return S_OK;
828 }
829
830 HRESULT STDMETHODCALLTYPE remove_PointerPressed(
831 EventRegistrationToken cookie) override {
832 mouse_pressed_handler_->Release();
833 mouse_pressed_handler_ = NULL;
834 return S_OK;
835 }
836
837 HRESULT STDMETHODCALLTYPE add_PointerReleased(
838 PointerEventHandler* handler,
839 EventRegistrationToken* cookie) override {
840 mouse_released_handler_ = handler;
841 mouse_released_handler_->AddRef();
842 return S_OK;
843 }
844
845 HRESULT STDMETHODCALLTYPE remove_PointerReleased(
846 EventRegistrationToken cookie) override {
847 mouse_released_handler_->Release();
848 mouse_released_handler_ = NULL;
849 return S_OK;
850 }
851
852 HRESULT STDMETHODCALLTYPE add_TouchHitTesting(
853 TouchHitTestHandler* handler,
854 EventRegistrationToken* pCookie) override {
855 return S_OK;
856 }
857
858 HRESULT STDMETHODCALLTYPE remove_TouchHitTesting(
859 EventRegistrationToken cookie) override {
860 return S_OK;
861 }
862
863 HRESULT STDMETHODCALLTYPE add_PointerWheelChanged(
864 PointerEventHandler* handler,
865 EventRegistrationToken* cookie) override {
866 mouse_wheel_changed_handler_ = handler;
867 mouse_wheel_changed_handler_->AddRef();
868 return S_OK;
869 }
870
871 HRESULT STDMETHODCALLTYPE remove_PointerWheelChanged(
872 EventRegistrationToken cookie) override {
873 mouse_wheel_changed_handler_->Release();
874 mouse_wheel_changed_handler_ = NULL;
875 return S_OK;
876 }
877
878 HRESULT STDMETHODCALLTYPE add_SizeChanged(
879 SizeChangedHandler* handler,
880 EventRegistrationToken* pCookie) override {
881 // TODO(cpu): implement this.
882 return S_OK;
883 }
884
885 HRESULT STDMETHODCALLTYPE remove_SizeChanged(
886 EventRegistrationToken cookie) override {
887 return S_OK;
888 }
889
890 HRESULT STDMETHODCALLTYPE add_VisibilityChanged(
891 VisibilityChangedHandler* handler,
892 EventRegistrationToken* pCookie) override {
893 return S_OK;
894 }
895
896 HRESULT STDMETHODCALLTYPE remove_VisibilityChanged(
897 EventRegistrationToken cookie) override {
898 return S_OK;
899 }
900
901 // ICoreWindowInterop implementation:
902 HRESULT STDMETHODCALLTYPE get_WindowHandle(HWND* hwnd) override {
903 if (!core_hwnd_)
904 return E_FAIL;
905 *hwnd = core_hwnd_;
906 return S_OK;
907 }
908
909 HRESULT STDMETHODCALLTYPE put_MessageHandled(boolean value) override {
910 return S_OK;
911 }
912
913 // InputHandler
914 bool HandleKeyboardMessage(const MSG& msg) override {
915 switch (msg.message) {
916 case WM_KEYDOWN:
917 case WM_KEYUP: {
918 mswr::ComPtr<winui::Core::IKeyEventArgs> event_args;
919 event_args = mswr::Make<KeyEvent>(msg);
920 KeyEventHandler* handler = NULL;
921 if (msg.message == WM_KEYDOWN) {
922 handler = key_down_handler_;
923 } else {
924 handler = key_up_handler_;
925 }
926 handler->Invoke(this, event_args.Get());
927 break;
928 }
929
930 case WM_CHAR:
931 case WM_DEADCHAR:
932 case WM_UNICHAR: {
933 mswr::ComPtr<winui::Core::ICharacterReceivedEventArgs> event_args;
934 event_args = mswr::Make<KeyEvent>(msg);
935 character_received_handler_->Invoke(this, event_args.Get());
936 break;
937 }
938
939 default:
940 return false;
941 }
942 return true;
943 }
944
945 bool HandleMouseMessage(const MSG& msg) override {
946 PointerEventHandler* handler = NULL;
947 mswr::ComPtr<winui::Core::IPointerEventArgs> event_args;
948 event_args = mswr::Make<MouseEvent>(msg);
949 switch (msg.message) {
950 case WM_MOUSEMOVE: {
951 handler = mouse_moved_handler_;
952 break;
953 }
954 case WM_LBUTTONDOWN: {
955 case WM_RBUTTONDOWN:
956 case WM_MBUTTONDOWN:
957 handler = mouse_pressed_handler_;
958 break;
959 }
960
961 case WM_LBUTTONUP: {
962 case WM_RBUTTONUP:
963 case WM_MBUTTONUP:
964 handler = mouse_released_handler_;
965 break;
966 }
967
968 case WM_MOUSEWHEEL: {
969 case WM_MOUSEHWHEEL:
970 handler = mouse_wheel_changed_handler_;
971 break;
972 }
973
974 default:
975 return false;
976 }
977 DCHECK(handler);
978 handler->Invoke(this, event_args.Get());
979 return true;
980 }
981
982 void OnWindowActivated() {
983 if (window_activated_handler_)
984 window_activated_handler_->Invoke(this, NULL);
985 }
986
987 private:
988 PointerEventHandler* mouse_moved_handler_;
989 PointerEventHandler* mouse_capture_lost_handler_;
990 PointerEventHandler* mouse_pressed_handler_;
991 PointerEventHandler* mouse_released_handler_;
992 PointerEventHandler* mouse_entered_handler_;
993 PointerEventHandler* mouse_exited_handler_;
994 PointerEventHandler* mouse_wheel_changed_handler_;
995 KeyEventHandler* key_down_handler_;
996 KeyEventHandler* key_up_handler_;
997 CharEventHandler* character_received_handler_;
998 HWND core_hwnd_;
999 mswr::ComPtr<winui::Core::ICoreDispatcher> dispatcher_;
1000 mswr::ComPtr<winapp::Core::IFrameworkView> app_view_;
1001 WindowActivatedHandler* window_activated_handler_;
1002 };
1003
1004 LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
1005 WPARAM wparam, LPARAM lparam) {
1006 PAINTSTRUCT ps;
1007 HDC hdc;
1008 switch (message) {
1009 case WM_ACTIVATE: {
1010 // HIWORD(wparam) is 1 if the window is minimized.
1011 bool active = (LOWORD(wparam) != WA_INACTIVE) && !HIWORD(wparam);
1012 if (active) {
1013 CoreWindowEmulation* core_window_handler =
1014 reinterpret_cast<CoreWindowEmulation*>(
1015 ::GetProp(hwnd, kAshWin7CoreWindowHandler));
1016 if (core_window_handler)
1017 core_window_handler->OnWindowActivated();
1018 }
1019 return ::DefWindowProc(hwnd, message, wparam, lparam);
1020 }
1021 case WM_CREATE:
1022 ++g_window_count;
1023 break;
1024 case WM_PAINT:
1025 hdc = ::BeginPaint(hwnd, &ps);
1026 ::EndPaint(hwnd, &ps);
1027 break;
1028 case WM_CLOSE:
1029 ::DestroyWindow(hwnd);
1030 break;
1031 case WM_DESTROY:
1032 --g_window_count;
1033 if (!g_window_count)
1034 ::PostQuitMessage(0);
1035 break;
1036 // Always allow Chrome to set the cursor.
1037 case WM_SETCURSOR:
1038 return 1;
1039 default:
1040 return ::DefWindowProc(hwnd, message, wparam, lparam);
1041 }
1042 return 0;
1043 }
1044
1045 class ActivatedEvent
1046 : public mswr::RuntimeClass<winapp::Activation::IActivatedEventArgs> {
1047 public:
1048 ActivatedEvent(winapp::Activation::ActivationKind activation_kind)
1049 : activation_kind_(activation_kind) {
1050 }
1051
1052 HRESULT STDMETHODCALLTYPE
1053 get_Kind(winapp::Activation::ActivationKind* value) override {
1054 *value = activation_kind_;
1055 return S_OK;
1056 }
1057
1058 HRESULT STDMETHODCALLTYPE get_PreviousExecutionState(
1059 winapp::Activation::ApplicationExecutionState* value) override {
1060 *value = winapp::Activation::ApplicationExecutionState_ClosedByUser;
1061 return S_OK;
1062 }
1063
1064 HRESULT STDMETHODCALLTYPE
1065 get_SplashScreen(winapp::Activation::ISplashScreen** value) override {
1066 return E_FAIL;
1067 }
1068
1069 private:
1070 winapp::Activation::ActivationKind activation_kind_;
1071 };
1072
1073 class CoreApplicationViewEmulation
1074 : public mswr::RuntimeClass<winapp::Core::ICoreApplicationView> {
1075 public:
1076 CoreApplicationViewEmulation(winapp::Core::IFrameworkView* app_view) {
1077 core_window_ = mswr::Make<CoreWindowEmulation>(app_view);
1078 }
1079
1080 HRESULT Activate() {
1081 if (activated_handler_) {
1082 auto ae = mswr::Make<ActivatedEvent>(
1083 winapp::Activation::ActivationKind_File);
1084 return activated_handler_->Invoke(this, ae.Get());
1085 } else {
1086 return S_OK;
1087 }
1088 }
1089
1090 HRESULT Close() {
1091 return core_window_->Close();
1092 }
1093
1094 // ICoreApplicationView implementation:
1095 HRESULT STDMETHODCALLTYPE
1096 get_CoreWindow(winui::Core::ICoreWindow** value) override {
1097 if (!core_window_)
1098 return E_FAIL;
1099 return core_window_.CopyTo(value);
1100 }
1101
1102 HRESULT STDMETHODCALLTYPE
1103 add_Activated(ActivatedHandler* handler,
1104 EventRegistrationToken* token) override {
1105 // The real component supports multiple handles but we don't yet.
1106 if (activated_handler_)
1107 return E_FAIL;
1108 activated_handler_ = handler;
1109 return S_OK;
1110 }
1111
1112 HRESULT STDMETHODCALLTYPE
1113 remove_Activated(EventRegistrationToken token) override {
1114 // Chrome never unregisters handlers, so we don't care about it.
1115 return S_OK;
1116 }
1117
1118 HRESULT STDMETHODCALLTYPE get_IsMain(boolean* value) override { return S_OK; }
1119
1120 HRESULT STDMETHODCALLTYPE get_IsHosted(boolean* value) override {
1121 return S_OK;
1122 }
1123
1124 private:
1125 mswr::ComPtr<CoreWindowEmulation> core_window_;
1126 mswr::ComPtr<ActivatedHandler> activated_handler_;
1127 };
1128
1129 class CoreApplicationWin7Emulation
1130 : public mswr::RuntimeClass<winapp::Core::ICoreApplication,
1131 winapp::Core::ICoreApplicationExit> {
1132 public:
1133 // ICoreApplication implementation:
1134
1135 HRESULT STDMETHODCALLTYPE get_Id(HSTRING* value) override { return S_OK; }
1136
1137 HRESULT STDMETHODCALLTYPE add_Suspending(
1138 winfoundtn::IEventHandler<winapp::SuspendingEventArgs*>* handler,
1139 EventRegistrationToken* token) override {
1140 return S_OK;
1141 }
1142
1143 HRESULT STDMETHODCALLTYPE
1144 remove_Suspending(EventRegistrationToken token) override {
1145 return S_OK;
1146 }
1147
1148 HRESULT STDMETHODCALLTYPE
1149 add_Resuming(winfoundtn::IEventHandler<IInspectable*>* handler,
1150 EventRegistrationToken* token) override {
1151 return S_OK;
1152 }
1153
1154 HRESULT STDMETHODCALLTYPE
1155 remove_Resuming(EventRegistrationToken token) override {
1156 return S_OK;
1157 }
1158
1159 HRESULT STDMETHODCALLTYPE
1160 get_Properties(winfoundtn::Collections::IPropertySet** value) override {
1161 return S_OK;
1162 }
1163
1164 HRESULT STDMETHODCALLTYPE
1165 GetCurrentView(winapp::Core::ICoreApplicationView** value) override {
1166 return S_OK;
1167 }
1168
1169 HRESULT STDMETHODCALLTYPE
1170 Run(winapp::Core::IFrameworkViewSource* viewSource) override {
1171 HRESULT hr = viewSource->CreateView(app_view_.GetAddressOf());
1172 if (FAILED(hr))
1173 return hr;
1174 view_emulation_ = mswr::Make<CoreApplicationViewEmulation>(
1175 app_view_.Get());
1176 hr = app_view_->Initialize(view_emulation_.Get());
1177 if (FAILED(hr))
1178 return hr;
1179 mswr::ComPtr<winui::Core::ICoreWindow> core_window;
1180 hr = view_emulation_->get_CoreWindow(core_window.GetAddressOf());
1181 if (FAILED(hr))
1182 return hr;
1183 hr = app_view_->SetWindow(core_window.Get());
1184 if (FAILED(hr))
1185 return hr;
1186 hr = app_view_->Load(NULL);
1187 if (FAILED(hr))
1188 return hr;
1189 hr = view_emulation_->Activate();
1190 if (FAILED(hr))
1191 return hr;
1192 return app_view_->Run();
1193 }
1194
1195 HRESULT STDMETHODCALLTYPE RunWithActivationFactories(
1196 winfoundtn::IGetActivationFactory* activationFactoryCallback) override {
1197 return S_OK;
1198 }
1199
1200 // ICoreApplicationExit implementation:
1201
1202 HRESULT STDMETHODCALLTYPE Exit(void) override {
1203 return view_emulation_->Close();
1204 }
1205
1206 HRESULT STDMETHODCALLTYPE
1207 add_Exiting(winfoundtn::IEventHandler<IInspectable*>* handler,
1208 EventRegistrationToken* token) override {
1209 return S_OK;
1210 }
1211
1212 HRESULT STDMETHODCALLTYPE
1213 remove_Exiting(EventRegistrationToken token) override {
1214 return S_OK;
1215 }
1216
1217 private:
1218 mswr::ComPtr<winapp::Core::IFrameworkView> app_view_;
1219 mswr::ComPtr<CoreApplicationViewEmulation> view_emulation_;
1220 };
1221
1222
1223 mswr::ComPtr<winapp::Core::ICoreApplication> InitWindows7() {
1224 HRESULT hr = ::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1225 if (FAILED(hr))
1226 CHECK(false);
1227 return mswr::Make<CoreApplicationWin7Emulation>();
1228 }
1229
OLDNEW
« no previous file with comments | « win8/metro_driver/metro_driver.gyp ('k') | win8/viewer/metro_viewer_constants.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698